src/src/smtp_out.c

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