src/src/smtp_out.c

   1 /*************************************************
   2 *     Exim - an Internet mail transport agent    *
   3 *************************************************/
   4
   5 /* Copyright (c) University of Cambridge 1995 - 2009 */
   6 /* See the file NOTICE for conditions of use and distribution. */
   7
   8 /* A number of functions for driving outgoing SMTP calls. */
   9
  10
  11 #include "exim.h"
  12
  13
  14
  15 /*************************************************
  16 *           Find an outgoing interface           *
  17 *************************************************/
  18
  19 /* This function is called from the smtp transport and also from the callout
  20 code in verify.c. Its job is to expand a string to get a list of interfaces,
  21 and choose a suitable one (IPv4 or IPv6) for the outgoing address.
  22
  23 Arguments:
  24   istring    string interface setting, may be NULL, meaning "any", in
  25                which case the function does nothing
  26   host_af    AF_INET or AF_INET6 for the outgoing IP address
  27   addr       the mail address being handled (for setting errors)
  28   changed    if not NULL, set TRUE if expansion actually changed istring
  29   interface  point this to the interface
  30   msg        to add to any error message
  31
  32 Returns:     TRUE on success, FALSE on failure, with error message
  33                set in addr and transport_return set to PANIC
  34 */
  35
  36 BOOL
  37 smtp_get_interface(uschar *istring, int host_af, address_item *addr,
  38   BOOL *changed, uschar **interface, uschar *msg)
  39 {
  40 uschar *expint;
  41 uschar *iface;
  42 int sep = 0;
  43
  44 if (istring == NULL) return TRUE;
  45
  46 expint = expand_string(istring);
  47 if (expint == NULL)
  48   {
  49   if (expand_string_forcedfail) return TRUE;
  50   addr->transport_return = PANIC;
  51   addr->message = string_sprintf("failed to expand \"interface\" "
  52       "option for %s: %s", msg, expand_string_message);
  53   return FALSE;
  54   }
  55
  56 if (changed != NULL) *changed = expint != istring;
  57
  58 while (isspace(*expint)) expint++;
  59 if (*expint == 0) return TRUE;
  60
  61 while ((iface = string_nextinlist(&expint, &sep, big_buffer,
  62           big_buffer_size)) != NULL)
  63   {
  64   if (string_is_ip_address(iface, NULL) == 0)
  65     {
  66     addr->transport_return = PANIC;
  67     addr->message = string_sprintf("\"%s\" is not a valid IP "
  68       "address for the \"interface\" option for %s",
  69       iface, msg);
  70     return FALSE;
  71     }
  72
  73   if (((Ustrchr(iface, ':') == NULL)? AF_INET:AF_INET6) == host_af)
  74     break;
  75   }
  76
  77 if (iface != NULL) *interface = string_copy(iface);
  78 return TRUE;
  79 }
  80
  81
  82
  83 /*************************************************
  84 *           Find an outgoing port                *
  85 *************************************************/
  86
  87 /* This function is called from the smtp transport and also from the callout
  88 code in verify.c. Its job is to find a port number. Note that getservbyname()
  89 produces the number in network byte order.
  90
  91 Arguments:
  92   rstring     raw (unexpanded) string representation of the port
  93   addr        the mail address being handled (for setting errors)
  94   port        stick the port in here
  95   msg         for adding to error message
  96
  97 Returns:      TRUE on success, FALSE on failure, with error message set
  98                 in addr, and transport_return set to PANIC
  99 */
 100
 101 BOOL
 102 smtp_get_port(uschar *rstring, address_item *addr, int *port, uschar *msg)
 103 {
 104 uschar *pstring = expand_string(rstring);
 105
 106 if (pstring == NULL)
 107   {
 108   addr->transport_return = PANIC;
 109   addr->message = string_sprintf("failed to expand \"%s\" (\"port\" option) "
 110     "for %s: %s", rstring, msg, expand_string_message);
 111   return FALSE;
 112   }
 113
 114 if (isdigit(*pstring))
 115   {
 116   uschar *end;
 117   *port = Ustrtol(pstring, &end, 0);
 118   if (end != pstring + Ustrlen(pstring))
 119     {
 120     addr->transport_return = PANIC;
 121     addr->message = string_sprintf("invalid port number for %s: %s", msg,
 122       pstring);
 123     return FALSE;
 124     }
 125   }
 126
 127 else
 128   {
 129   struct servent *smtp_service = getservbyname(CS pstring, "tcp");
 130   if (smtp_service == NULL)
 131     {
 132     addr->transport_return = PANIC;
 133     addr->message = string_sprintf("TCP port \"%s\" is not defined for %s",
 134       pstring, msg);
 135     return FALSE;
 136     }
 137   *port = ntohs(smtp_service->s_port);
 138   }
 139
 140 return TRUE;
 141 }
 142
 143
 144
 145
 146 /*************************************************
 147 *           Connect to remote host               *
 148 *************************************************/
 149
 150 /* Create a socket, and connect it to a remote host. IPv6 addresses are
 151 detected by checking for a colon in the address. AF_INET6 is defined even on
 152 non-IPv6 systems, to enable the code to be less messy. However, on such systems
 153 host->address will always be an IPv4 address.
 154
 155 The port field in the host item is used if it is set (usually router from SRV
 156 records or elsewhere). In other cases, the default passed as an argument is
 157 used, and the host item is updated with its value.
 158
 159 Arguments:
 160   host        host item containing name and address (and sometimes port)
 161   host_af     AF_INET or AF_INET6
 162   port        default remote port to connect to, in host byte order, for those
 163                 hosts whose port setting is PORT_NONE
 164   interface   outgoing interface address or NULL
 165   timeout     timeout value or 0
 166   keepalive   TRUE to use keepalive
 167   dscp        DSCP value to assign to socket
 168   event       event expansion
 169
 170 Returns:      connected socket number, or -1 with errno set
 171 */
 172
 173 int
 174 smtp_connect(host_item *host, int host_af, int port, uschar *interface,
 175   int timeout, BOOL keepalive, const uschar *dscp
 176 #ifdef EXPERIMENTAL_EVENT
 177   , uschar * event
 178 #endif
 179   )
 180 {
 181 int on = 1;
 182 int save_errno = 0;
 183 int dscp_value;
 184 int dscp_level;
 185 int dscp_option;
 186 int sock;
 187
 188 if (host->port != PORT_NONE)
 189   {
 190   HDEBUG(D_transport|D_acl|D_v)
 191     debug_printf("Transport port=%d replaced by host-specific port=%d\n", port,
 192       host->port);
 193   port = host->port;
 194   }
 195 else host->port = port;    /* Set the port actually used */
 196
 197 HDEBUG(D_transport|D_acl|D_v)
 198   {
 199   if (interface == NULL)
 200     debug_printf("Connecting to %s [%s]:%d ... ",host->name,host->address,port);
 201   else
 202     debug_printf("Connecting to %s [%s]:%d from %s ... ", host->name,
 203       host->address, port, interface);
 204   }
 205
 206 #ifdef EXPERIMENTAL_EVENT
 207   /*XXX Called from both delivery and verify.  Is that status observable? */
 208   deliver_host_address = host->address;
 209   deliver_host_port = port;
 210   if (event_raise(event, US"tcp:connect", NULL) == DEFER) return -1;
 211 #endif
 212
 213 /* Create the socket */
 214
 215 if ((sock = ip_socket(SOCK_STREAM, host_af)) < 0) return -1;
 216
 217 /* Set TCP_NODELAY; Exim does its own buffering. */
 218
 219 setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, (uschar *)(&on), sizeof(on));
 220
 221 /* Set DSCP value, if we can. For now, if we fail to set the value, we don't
 222 bomb out, just log it and continue in default traffic class. */
 223
 224 if (dscp && dscp_lookup(dscp, host_af, &dscp_level, &dscp_option, &dscp_value))
 225   {
 226   HDEBUG(D_transport|D_acl|D_v)
 227     debug_printf("DSCP \"%s\"=%x ", dscp, dscp_value);
 228   if (setsockopt(sock, dscp_level, dscp_option, &dscp_value, sizeof(dscp_value)) < 0)
 229     HDEBUG(D_transport|D_acl|D_v)
 230       debug_printf("failed to set DSCP: %s ", strerror(errno));
 231   /* If the kernel supports IPv4 and IPv6 on an IPv6 socket, we need to set the
 232   option for both; ignore failures here */
 233   if (host_af == AF_INET6 &&
 234       dscp_lookup(dscp, AF_INET, &dscp_level, &dscp_option, &dscp_value))
 235     {
 236     (void) setsockopt(sock, dscp_level, dscp_option, &dscp_value, sizeof(dscp_value));
 237     }
 238   }
 239
 240 /* Bind to a specific interface if requested. Caller must ensure the interface
 241 is the same type (IPv4 or IPv6) as the outgoing address. */
 242
 243 if (interface != NULL && ip_bind(sock, host_af, interface, 0) < 0)
 244   {
 245   save_errno = errno;
 246   HDEBUG(D_transport|D_acl|D_v)
 247     debug_printf("unable to bind outgoing SMTP call to %s: %s", interface,
 248     strerror(errno));
 249   }
 250
 251 /* Connect to the remote host, and add keepalive to the socket before returning
 252 it, if requested. */
 253
 254 else if (ip_connect(sock, host_af, host->address, port, timeout) < 0)
 255   save_errno = errno;
 256
 257 /* Either bind() or connect() failed */
 258
 259 if (save_errno != 0)
 260   {
 261   HDEBUG(D_transport|D_acl|D_v)
 262     {
 263     debug_printf("failed: %s", CUstrerror(save_errno));
 264     if (save_errno == ETIMEDOUT)
 265       debug_printf(" (timeout=%s)", readconf_printtime(timeout));
 266     debug_printf("\n");
 267     }
 268   (void)close(sock);
 269   errno = save_errno;
 270   return -1;
 271   }
 272
 273 /* Both bind() and connect() succeeded */
 274
 275 else
 276   {
 277   union sockaddr_46 interface_sock;
 278   EXIM_SOCKLEN_T size = sizeof(interface_sock);
 279   HDEBUG(D_transport|D_acl|D_v) debug_printf("connected\n");
 280   if (getsockname(sock, (struct sockaddr *)(&interface_sock), &size) == 0)
 281     sending_ip_address = host_ntoa(-1, &interface_sock, NULL, &sending_port);
 282   else
 283     {
 284     log_write(0, LOG_MAIN | ((errno == ECONNRESET)? 0 : LOG_PANIC),
 285       "getsockname() failed: %s", strerror(errno));
 286     close(sock);
 287     return -1;
 288     }
 289   if (keepalive) ip_keepalive(sock, host->address, TRUE);
 290   return sock;
 291   }
 292 }
 293
 294
 295 /*************************************************
 296 *        Flush outgoing command buffer           *
 297 *************************************************/
 298
 299 /* This function is called only from smtp_write_command() below. It flushes
 300 the buffer of outgoing commands. There is more than one in the buffer only when
 301 pipelining.
 302
 303 Argument:
 304   outblock   the SMTP output block
 305
 306 Returns:     TRUE if OK, FALSE on error, with errno set
 307 */
 308
 309 static BOOL
 310 flush_buffer(smtp_outblock *outblock)
 311 {
 312 int rc;
 313
 314 #ifdef SUPPORT_TLS
 315 if (tls_out.active == outblock->sock)
 316   rc = tls_write(FALSE, outblock->buffer, outblock->ptr - outblock->buffer);
 317 else
 318 #endif
 319
 320 rc = send(outblock->sock, outblock->buffer, outblock->ptr - outblock->buffer, 0);
 321 if (rc <= 0)
 322   {
 323   HDEBUG(D_transport|D_acl) debug_printf("send failed: %s\n", strerror(errno));
 324   return FALSE;
 325   }
 326
 327 outblock->ptr = outblock->buffer;
 328 outblock->cmd_count = 0;
 329 return TRUE;
 330 }
 331
 332
 333
 334 /*************************************************
 335 *             Write SMTP command                 *
 336 *************************************************/
 337
 338 /* The formatted command is left in big_buffer so that it can be reflected in
 339 any error message.
 340
 341 Arguments:
 342   outblock   contains buffer for pipelining, and socket
 343   noflush    if TRUE, save the command in the output buffer, for pipelining
 344   format     a format, starting with one of
 345              of HELO, MAIL FROM, RCPT TO, DATA, ".", or QUIT.
 346   ...        data for the format
 347
 348 Returns:     0 if command added to pipelining buffer, with nothing transmitted
 349             +n if n commands transmitted (may still have buffered the new one)
 350             -1 on error, with errno set
 351 */
 352
 353 int
 354 smtp_write_command(smtp_outblock *outblock, BOOL noflush, const char *format, ...)
 355 {
 356 int count;
 357 int rc = 0;
 358 va_list ap;
 359
 360 va_start(ap, format);
 361 if (!string_vformat(big_buffer, big_buffer_size, CS format, ap))
 362   log_write(0, LOG_MAIN|LOG_PANIC_DIE, "overlong write_command in outgoing "
 363     "SMTP");
 364 va_end(ap);
 365 count = Ustrlen(big_buffer);
 366
 367 if (count > outblock->buffersize)
 368   log_write(0, LOG_MAIN|LOG_PANIC_DIE, "overlong write_command in outgoing "
 369     "SMTP");
 370
 371 if (count > outblock->buffersize - (outblock->ptr - outblock->buffer))
 372   {
 373   rc = outblock->cmd_count;                 /* flush resets */
 374   if (!flush_buffer(outblock)) return -1;
 375   }
 376
 377 Ustrncpy(CS outblock->ptr, big_buffer, count);
 378 outblock->ptr += count;
 379 outblock->cmd_count++;
 380 count -= 2;
 381 big_buffer[count] = 0;     /* remove \r\n for error message */
 382
 383 /* We want to hide the actual data sent in AUTH transactions from reflections
 384 and logs. While authenticating, a flag is set in the outblock to enable this.
 385 The AUTH command itself gets any data flattened. Other lines are flattened
 386 completely. */
 387
 388 if (outblock->authenticating)
 389   {
 390   uschar *p = big_buffer;
 391   if (Ustrncmp(big_buffer, "AUTH ", 5) == 0)
 392     {
 393     p += 5;
 394     while (isspace(*p)) p++;
 395     while (!isspace(*p)) p++;
 396     while (isspace(*p)) p++;
 397     }
 398   while (*p != 0) *p++ = '*';
 399   }
 400
 401 HDEBUG(D_transport|D_acl|D_v) debug_printf("  SMTP>> %s\n", big_buffer);
 402
 403 if (!noflush)
 404   {
 405   rc += outblock->cmd_count;                /* flush resets */
 406   if (!flush_buffer(outblock)) return -1;
 407   }
 408
 409 return rc;
 410 }
 411
 412
 413
 414 /*************************************************
 415 *          Read one line of SMTP response        *
 416 *************************************************/
 417
 418 /* This function reads one line of SMTP response from the server host. This may
 419 not be a complete response - it could be just part of a multiline response. We
 420 have to use a buffer for incoming packets, because when pipelining or using
 421 LMTP, there may well be more than one response in a single packet. This
 422 function is called only from the one that follows.
 423
 424 Arguments:
 425   inblock   the SMTP input block (contains holding buffer, socket, etc.)
 426   buffer    where to put the line
 427   size      space available for the line
 428   timeout   the timeout to use when reading a packet
 429
 430 Returns:    length of a line that has been put in the buffer
 431             -1 otherwise, with errno set
 432 */
 433
 434 static int
 435 read_response_line(smtp_inblock *inblock, uschar *buffer, int size, int timeout)
 436 {
 437 uschar *p = buffer;
 438 uschar *ptr = inblock->ptr;
 439 uschar *ptrend = inblock->ptrend;
 440 int sock = inblock->sock;
 441
 442 /* Loop for reading multiple packets or reading another packet after emptying
 443 a previously-read one. */
 444
 445 for (;;)
 446   {
 447   int rc;
 448
 449   /* If there is data in the input buffer left over from last time, copy
 450   characters from it until the end of a line, at which point we can return,
 451   having removed any whitespace (which will include CR) at the end of the line.
 452   The rules for SMTP say that lines end in CRLF, but there are have been cases
 453   of hosts using just LF, and other MTAs are reported to handle this, so we
 454   just look for LF. If we run out of characters before the end of a line,
 455   carry on to read the next incoming packet. */
 456
 457   while (ptr < ptrend)
 458     {
 459     int c = *ptr++;
 460     if (c == '\n')
 461       {
 462       while (p > buffer && isspace(p[-1])) p--;
 463       *p = 0;
 464       inblock->ptr = ptr;
 465       return p - buffer;
 466       }
 467     *p++ = c;
 468     if (--size < 4)
 469       {
 470       *p = 0;                     /* Leave malformed line for error message */
 471       errno = ERRNO_SMTPFORMAT;
 472       return -1;
 473       }
 474     }
 475
 476   /* Need to read a new input packet. */
 477
 478   rc = ip_recv(sock, inblock->buffer, inblock->buffersize, timeout);
 479   if (rc <= 0) break;
 480
 481   /* Another block of data has been successfully read. Set up the pointers
 482   and let the loop continue. */
 483
 484   ptrend = inblock->ptrend = inblock->buffer + rc;
 485   ptr = inblock->buffer;
 486   DEBUG(D_transport|D_acl) debug_printf("read response data: size=%d\n", rc);
 487   }
 488
 489 /* Get here if there has been some kind of recv() error; errno is set, but we
 490 ensure that the result buffer is empty before returning. */
 491
 492 *buffer = 0;
 493 return -1;
 494 }
 495
 496
 497
 498
 499
 500 /*************************************************
 501 *              Read SMTP response                *
 502 *************************************************/
 503
 504 /* This function reads an SMTP response with a timeout, and returns the
 505 response in the given buffer, as a string. A multiline response will contain
 506 newline characters between the lines. The function also analyzes the first
 507 digit of the reply code and returns FALSE if it is not acceptable. FALSE is
 508 also returned after a reading error. In this case buffer[0] will be zero, and
 509 the error code will be in errno.
 510
 511 Arguments:
 512   inblock   the SMTP input block (contains holding buffer, socket, etc.)
 513   buffer    where to put the response
 514   size      the size of the buffer
 515   okdigit   the expected first digit of the response
 516   timeout   the timeout to use
 517
 518 Returns:    TRUE if a valid, non-error response was received; else FALSE
 519 */
 520
 521 BOOL
 522 smtp_read_response(smtp_inblock *inblock, uschar *buffer, int size, int okdigit,
 523    int timeout)
 524 {
 525 uschar *ptr = buffer;
 526 int count;
 527
 528 errno = 0;  /* Ensure errno starts out zero */
 529
 530 /* This is a loop to read and concatentate the lines that make up a multi-line
 531 response. */
 532
 533 for (;;)
 534   {
 535   if ((count = read_response_line(inblock, ptr, size, timeout)) < 0)
 536     return FALSE;
 537
 538   HDEBUG(D_transport|D_acl|D_v)
 539     debug_printf("  %s %s\n", (ptr == buffer)? "SMTP<<" : "      ", ptr);
 540
 541   /* Check the format of the response: it must start with three digits; if
 542   these are followed by a space or end of line, the response is complete. If
 543   they are followed by '-' this is a multi-line response and we must look for
 544   another line until the final line is reached. The only use made of multi-line
 545   responses is to pass them back as error messages. We therefore just
 546   concatenate them all within the buffer, which should be large enough to
 547   accept any reasonable number of lines. */
 548
 549   if (count < 3 ||
 550      !isdigit(ptr[0]) ||
 551      !isdigit(ptr[1]) ||
 552      !isdigit(ptr[2]) ||
 553      (ptr[3] != '-' && ptr[3] != ' ' && ptr[3] != 0))
 554     {
 555     errno = ERRNO_SMTPFORMAT;    /* format error */
 556     return FALSE;
 557     }
 558
 559   /* If the line we have just read is a terminal line, line, we are done.
 560   Otherwise more data has to be read. */
 561
 562   if (ptr[3] != '-') break;
 563
 564   /* Move the reading pointer upwards in the buffer and insert \n between the
 565   components of a multiline response. Space is left for this by read_response_
 566   line(). */
 567
 568   ptr += count;
 569   *ptr++ = '\n';
 570   size -= count + 1;
 571   }
 572
 573 /* Return a value that depends on the SMTP return code. On some systems a
 574 non-zero value of errno has been seen at this point, so ensure it is zero,
 575 because the caller of this function looks at errno when FALSE is returned, to
 576 distinguish between an unexpected return code and other errors such as
 577 timeouts, lost connections, etc. */
 578
 579 errno = 0;
 580 return buffer[0] == okdigit;
 581 }
 582
 583 /* End of smtp_out.c */