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)
 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)
 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 #ifdef TCP_FASTOPEN
 144 static void
 145 tfo_out_check(int sock)
 146 {
 147 # if defined(TCP_INFO) && defined(EXIM_HAVE_TCPI_UNACKED)
 148 struct tcp_info tinfo;
 149 socklen_t len = sizeof(tinfo);
 150
 151 if (getsockopt(sock, IPPROTO_TCP, TCP_INFO, &tinfo, &len) == 0)
 152   {
 153   /* This is a somewhat dubious detection method; totally undocumented so likely
 154   to fail in future kernels.  There seems to be no documented way. */
 155
 156   if (tinfo.tcpi_unacked > 1)
 157     {
 158     DEBUG(D_transport|D_v) debug_printf("TCP_FASTOPEN mode connection\n");
 159     tcp_out_fastopen = TRUE;
 160     }
 161   }
 162 # endif
 163 }
 164 #endif
 165
 166
 167 /* Arguments as for smtp_connect(), plus
 168   early_data    if non-NULL, data to be sent - preferably in the TCP SYN segment
 169
 170 Returns:      connected socket number, or -1 with errno set
 171 */
 172
 173 int
 174 smtp_sock_connect(host_item * host, int host_af, int port, uschar * interface,
 175   transport_instance * tb, int timeout, const blob * early_data)
 176 {
 177 smtp_transport_options_block * ob =
 178   (smtp_transport_options_block *)tb->options_block;
 179 const uschar * dscp = ob->dscp;
 180 int dscp_value;
 181 int dscp_level;
 182 int dscp_option;
 183 int sock;
 184 int save_errno = 0;
 185
 186 #ifndef DISABLE_EVENT
 187 deliver_host_address = host->address;
 188 deliver_host_port = port;
 189 if (event_raise(tb->event_action, US"tcp:connect", NULL)) return -1;
 190 #endif
 191
 192 if ((sock = ip_socket(SOCK_STREAM, host_af)) < 0) return -1;
 193
 194 /* Set TCP_NODELAY; Exim does its own buffering. */
 195
 196 if (setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, US &on, sizeof(on)))
 197   HDEBUG(D_transport|D_acl|D_v)
 198     debug_printf_indent("failed to set NODELAY: %s ", strerror(errno));
 199
 200 /* Set DSCP value, if we can. For now, if we fail to set the value, we don't
 201 bomb out, just log it and continue in default traffic class. */
 202
 203 if (dscp && dscp_lookup(dscp, host_af, &dscp_level, &dscp_option, &dscp_value))
 204   {
 205   HDEBUG(D_transport|D_acl|D_v)
 206     debug_printf_indent("DSCP \"%s\"=%x ", dscp, dscp_value);
 207   if (setsockopt(sock, dscp_level, dscp_option, &dscp_value, sizeof(dscp_value)) < 0)
 208     HDEBUG(D_transport|D_acl|D_v)
 209       debug_printf_indent("failed to set DSCP: %s ", strerror(errno));
 210   /* If the kernel supports IPv4 and IPv6 on an IPv6 socket, we need to set the
 211   option for both; ignore failures here */
 212   if (host_af == AF_INET6 &&
 213       dscp_lookup(dscp, AF_INET, &dscp_level, &dscp_option, &dscp_value))
 214     (void) setsockopt(sock, dscp_level, dscp_option, &dscp_value, sizeof(dscp_value));
 215   }
 216
 217 /* Bind to a specific interface if requested. Caller must ensure the interface
 218 is the same type (IPv4 or IPv6) as the outgoing address. */
 219
 220 if (interface && ip_bind(sock, host_af, interface, 0) < 0)
 221   {
 222   save_errno = errno;
 223   HDEBUG(D_transport|D_acl|D_v)
 224     debug_printf_indent("unable to bind outgoing SMTP call to %s: %s", interface,
 225     strerror(errno));
 226   }
 227
 228 /* Connect to the remote host, and add keepalive to the socket before returning
 229 it, if requested.  If the build supports TFO, request it - and if the caller
 230 requested some early-data then include that in the TFO request. */
 231
 232 else
 233   {
 234   const blob * fastopen = NULL;
 235
 236 #ifdef TCP_FASTOPEN
 237   if (verify_check_given_host(&ob->hosts_try_fastopen, host) == OK)
 238     fastopen = early_data ? early_data : &tcp_fastopen_nodata;
 239 #endif
 240
 241   if (ip_connect(sock, host_af, host->address, port, timeout, fastopen) < 0)
 242     save_errno = errno;
 243   else if (early_data && !fastopen && early_data->data && early_data->len)
 244     if (send(sock, early_data->data, early_data->len, 0) < 0)
 245       save_errno = errno;
 246   }
 247
 248 /* Either bind() or connect() failed */
 249
 250 if (save_errno != 0)
 251   {
 252   HDEBUG(D_transport|D_acl|D_v)
 253     {
 254     debug_printf_indent("failed: %s", CUstrerror(save_errno));
 255     if (save_errno == ETIMEDOUT)
 256       debug_printf(" (timeout=%s)", readconf_printtime(timeout));
 257     debug_printf("\n");
 258     }
 259   (void)close(sock);
 260   errno = save_errno;
 261   return -1;
 262   }
 263
 264 /* Both bind() and connect() succeeded */
 265
 266 else
 267   {
 268   union sockaddr_46 interface_sock;
 269   EXIM_SOCKLEN_T size = sizeof(interface_sock);
 270   HDEBUG(D_transport|D_acl|D_v) debug_printf_indent("connected\n");
 271   if (getsockname(sock, (struct sockaddr *)(&interface_sock), &size) == 0)
 272     sending_ip_address = host_ntoa(-1, &interface_sock, NULL, &sending_port);
 273   else
 274     {
 275     log_write(0, LOG_MAIN | ((errno == ECONNRESET)? 0 : LOG_PANIC),
 276       "getsockname() failed: %s", strerror(errno));
 277     close(sock);
 278     return -1;
 279     }
 280   if (ob->keepalive) ip_keepalive(sock, host->address, TRUE);
 281 #ifdef TCP_FASTOPEN
 282   tfo_out_check(sock);
 283 #endif
 284   return sock;
 285   }
 286 }
 287
 288
 289
 290
 291
 292 void
 293 smtp_port_for_connect(host_item * host, int port)
 294 {
 295 if (host->port != PORT_NONE)
 296   {
 297   HDEBUG(D_transport|D_acl|D_v)
 298     debug_printf_indent("Transport port=%d replaced by host-specific port=%d\n", port,
 299       host->port);
 300   port = host->port;
 301   }
 302 else host->port = port;    /* Set the port actually used */
 303 }
 304
 305
 306 /*************************************************
 307 *           Connect to remote host               *
 308 *************************************************/
 309
 310 /* Create a socket, and connect it to a remote host. IPv6 addresses are
 311 detected by checking for a colon in the address. AF_INET6 is defined even on
 312 non-IPv6 systems, to enable the code to be less messy. However, on such systems
 313 host->address will always be an IPv4 address.
 314
 315 Arguments:
 316   host        host item containing name and address and port
 317   host_af     AF_INET or AF_INET6
 318   interface   outgoing interface address or NULL
 319   timeout     timeout value or 0
 320   tb          transport
 321
 322 Returns:      connected socket number, or -1 with errno set
 323 */
 324
 325 int
 326 smtp_connect(host_item *host, int host_af, uschar *interface,
 327   int timeout, transport_instance * tb)
 328 {
 329 int port = host->port;
 330 #ifdef SUPPORT_SOCKS
 331 smtp_transport_options_block * ob =
 332   (smtp_transport_options_block *)tb->options_block;
 333 #endif
 334
 335 callout_address = string_sprintf("[%s]:%d", host->address, port);
 336
 337 HDEBUG(D_transport|D_acl|D_v)
 338   {
 339   uschar * s = US" ";
 340   if (interface) s = string_sprintf(" from %s ", interface);
 341 #ifdef SUPPORT_SOCKS
 342   if (ob->socks_proxy) s = string_sprintf("%svia proxy ", s);
 343 #endif
 344   debug_printf_indent("Connecting to %s %s%s... ", host->name, callout_address, s);
 345   }
 346
 347 /* Create and connect the socket */
 348
 349 #ifdef SUPPORT_SOCKS
 350 if (ob->socks_proxy)
 351   return socks_sock_connect(host, host_af, port, interface, tb, timeout);
 352 #endif
 353
 354 return smtp_sock_connect(host, host_af, port, interface, tb, timeout, NULL);
 355 }
 356
 357
 358 /*************************************************
 359 *        Flush outgoing command buffer           *
 360 *************************************************/
 361
 362 /* This function is called only from smtp_write_command() below. It flushes
 363 the buffer of outgoing commands. There is more than one in the buffer only when
 364 pipelining.
 365
 366 Argument:
 367   outblock   the SMTP output block
 368   mode       further data expected, or plain
 369
 370 Returns:     TRUE if OK, FALSE on error, with errno set
 371 */
 372
 373 static BOOL
 374 flush_buffer(smtp_outblock * outblock, int mode)
 375 {
 376 int rc;
 377 int n = outblock->ptr - outblock->buffer;
 378 BOOL more = mode == SCMD_MORE;
 379
 380 HDEBUG(D_transport|D_acl) debug_printf_indent("cmd buf flush %d bytes%s\n", n,
 381   more ? " (more expected)" : "");
 382
 383 #ifdef SUPPORT_TLS
 384 if (tls_out.active == outblock->sock)
 385   rc = tls_write(FALSE, outblock->buffer, n, more);
 386 else
 387 #endif
 388   rc = send(outblock->sock, outblock->buffer, n,
 389 #ifdef MSG_MORE
 390             more ? MSG_MORE : 0
 391 #else
 392             0
 393 #endif
 394            );
 395
 396 if (rc <= 0)
 397   {
 398   HDEBUG(D_transport|D_acl) debug_printf_indent("send failed: %s\n", strerror(errno));
 399   return FALSE;
 400   }
 401
 402 outblock->ptr = outblock->buffer;
 403 outblock->cmd_count = 0;
 404 return TRUE;
 405 }
 406
 407
 408
 409 /*************************************************
 410 *             Write SMTP command                 *
 411 *************************************************/
 412
 413 /* The formatted command is left in big_buffer so that it can be reflected in
 414 any error message.
 415
 416 Arguments:
 417   outblock   contains buffer for pipelining, and socket
 418   mode       buffer, write-with-more-likely, write
 419   format     a format, starting with one of
 420              of HELO, MAIL FROM, RCPT TO, DATA, ".", or QUIT.
 421              If NULL, flush pipeline buffer only.
 422   ...        data for the format
 423
 424 Returns:     0 if command added to pipelining buffer, with nothing transmitted
 425             +n if n commands transmitted (may still have buffered the new one)
 426             -1 on error, with errno set
 427 */
 428
 429 int
 430 smtp_write_command(smtp_outblock * outblock, int mode, const char *format, ...)
 431 {
 432 int count;
 433 int rc = 0;
 434 va_list ap;
 435
 436 if (format)
 437   {
 438   va_start(ap, format);
 439   if (!string_vformat(big_buffer, big_buffer_size, CS format, ap))
 440     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "overlong write_command in outgoing "
 441       "SMTP");
 442   va_end(ap);
 443   count = Ustrlen(big_buffer);
 444
 445   if (count > outblock->buffersize)
 446     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "overlong write_command in outgoing "
 447       "SMTP");
 448
 449   if (count > outblock->buffersize - (outblock->ptr - outblock->buffer))
 450     {
 451     rc = outblock->cmd_count;                 /* flush resets */
 452     if (!flush_buffer(outblock, SCMD_FLUSH)) return -1;
 453     }
 454
 455   Ustrncpy(CS outblock->ptr, big_buffer, count);
 456   outblock->ptr += count;
 457   outblock->cmd_count++;
 458   count -= 2;
 459   big_buffer[count] = 0;     /* remove \r\n for error message */
 460
 461   /* We want to hide the actual data sent in AUTH transactions from reflections
 462   and logs. While authenticating, a flag is set in the outblock to enable this.
 463   The AUTH command itself gets any data flattened. Other lines are flattened
 464   completely. */
 465
 466   if (outblock->authenticating)
 467     {
 468     uschar *p = big_buffer;
 469     if (Ustrncmp(big_buffer, "AUTH ", 5) == 0)
 470       {
 471       p += 5;
 472       while (isspace(*p)) p++;
 473       while (!isspace(*p)) p++;
 474       while (isspace(*p)) p++;
 475       }
 476     while (*p != 0) *p++ = '*';
 477     }
 478
 479   HDEBUG(D_transport|D_acl|D_v) debug_printf_indent("  SMTP>> %s\n", big_buffer);
 480   }
 481
 482 if (mode != SCMD_BUFFER)
 483   {
 484   rc += outblock->cmd_count;                /* flush resets */
 485   if (!flush_buffer(outblock, mode)) return -1;
 486   }
 487
 488 return rc;
 489 }
 490
 491
 492
 493 /*************************************************
 494 *          Read one line of SMTP response        *
 495 *************************************************/
 496
 497 /* This function reads one line of SMTP response from the server host. This may
 498 not be a complete response - it could be just part of a multiline response. We
 499 have to use a buffer for incoming packets, because when pipelining or using
 500 LMTP, there may well be more than one response in a single packet. This
 501 function is called only from the one that follows.
 502
 503 Arguments:
 504   inblock   the SMTP input block (contains holding buffer, socket, etc.)
 505   buffer    where to put the line
 506   size      space available for the line
 507   timeout   the timeout to use when reading a packet
 508
 509 Returns:    length of a line that has been put in the buffer
 510             -1 otherwise, with errno set
 511 */
 512
 513 static int
 514 read_response_line(smtp_inblock *inblock, uschar *buffer, int size, int timeout)
 515 {
 516 uschar *p = buffer;
 517 uschar *ptr = inblock->ptr;
 518 uschar *ptrend = inblock->ptrend;
 519 int sock = inblock->sock;
 520
 521 /* Loop for reading multiple packets or reading another packet after emptying
 522 a previously-read one. */
 523
 524 for (;;)
 525   {
 526   int rc;
 527
 528   /* If there is data in the input buffer left over from last time, copy
 529   characters from it until the end of a line, at which point we can return,
 530   having removed any whitespace (which will include CR) at the end of the line.
 531   The rules for SMTP say that lines end in CRLF, but there are have been cases
 532   of hosts using just LF, and other MTAs are reported to handle this, so we
 533   just look for LF. If we run out of characters before the end of a line,
 534   carry on to read the next incoming packet. */
 535
 536   while (ptr < ptrend)
 537     {
 538     int c = *ptr++;
 539     if (c == '\n')
 540       {
 541       while (p > buffer && isspace(p[-1])) p--;
 542       *p = 0;
 543       inblock->ptr = ptr;
 544       return p - buffer;
 545       }
 546     *p++ = c;
 547     if (--size < 4)
 548       {
 549       *p = 0;                     /* Leave malformed line for error message */
 550       errno = ERRNO_SMTPFORMAT;
 551       return -1;
 552       }
 553     }
 554
 555   /* Need to read a new input packet. */
 556
 557   if((rc = ip_recv(sock, inblock->buffer, inblock->buffersize, timeout)) <= 0)
 558     {
 559     DEBUG(D_deliver|D_transport|D_acl)
 560       debug_printf_indent(errno ? "  SMTP(%s)<<\n" : "  SMTP(closed)<<\n",
 561         strerror(errno));
 562     break;
 563     }
 564
 565   /* Another block of data has been successfully read. Set up the pointers
 566   and let the loop continue. */
 567
 568   ptrend = inblock->ptrend = inblock->buffer + rc;
 569   ptr = inblock->buffer;
 570   DEBUG(D_transport|D_acl) debug_printf_indent("read response data: size=%d\n", rc);
 571   }
 572
 573 /* Get here if there has been some kind of recv() error; errno is set, but we
 574 ensure that the result buffer is empty before returning. */
 575
 576 *buffer = 0;
 577 return -1;
 578 }
 579
 580
 581
 582
 583
 584 /*************************************************
 585 *              Read SMTP response                *
 586 *************************************************/
 587
 588 /* This function reads an SMTP response with a timeout, and returns the
 589 response in the given buffer, as a string. A multiline response will contain
 590 newline characters between the lines. The function also analyzes the first
 591 digit of the reply code and returns FALSE if it is not acceptable. FALSE is
 592 also returned after a reading error. In this case buffer[0] will be zero, and
 593 the error code will be in errno.
 594
 595 Arguments:
 596   inblock   the SMTP input block (contains holding buffer, socket, etc.)
 597   buffer    where to put the response
 598   size      the size of the buffer
 599   okdigit   the expected first digit of the response
 600   timeout   the timeout to use, in seconds
 601
 602 Returns:    TRUE if a valid, non-error response was received; else FALSE
 603 */
 604
 605 BOOL
 606 smtp_read_response(smtp_inblock *inblock, uschar *buffer, int size, int okdigit,
 607    int timeout)
 608 {
 609 uschar *ptr = buffer;
 610 int count;
 611
 612 errno = 0;  /* Ensure errno starts out zero */
 613
 614 /* This is a loop to read and concatenate the lines that make up a multi-line
 615 response. */
 616
 617 for (;;)
 618   {
 619   if ((count = read_response_line(inblock, ptr, size, timeout)) < 0)
 620     return FALSE;
 621
 622   HDEBUG(D_transport|D_acl|D_v)
 623     debug_printf_indent("  %s %s\n", (ptr == buffer)? "SMTP<<" : "      ", ptr);
 624
 625   /* Check the format of the response: it must start with three digits; if
 626   these are followed by a space or end of line, the response is complete. If
 627   they are followed by '-' this is a multi-line response and we must look for
 628   another line until the final line is reached. The only use made of multi-line
 629   responses is to pass them back as error messages. We therefore just
 630   concatenate them all within the buffer, which should be large enough to
 631   accept any reasonable number of lines. */
 632
 633   if (count < 3 ||
 634      !isdigit(ptr[0]) ||
 635      !isdigit(ptr[1]) ||
 636      !isdigit(ptr[2]) ||
 637      (ptr[3] != '-' && ptr[3] != ' ' && ptr[3] != 0))
 638     {
 639     errno = ERRNO_SMTPFORMAT;    /* format error */
 640     return FALSE;
 641     }
 642
 643   /* If the line we have just read is a terminal line, line, we are done.
 644   Otherwise more data has to be read. */
 645
 646   if (ptr[3] != '-') break;
 647
 648   /* Move the reading pointer upwards in the buffer and insert \n between the
 649   components of a multiline response. Space is left for this by read_response_
 650   line(). */
 651
 652   ptr += count;
 653   *ptr++ = '\n';
 654   size -= count + 1;
 655   }
 656
 657 /* Return a value that depends on the SMTP return code. On some systems a
 658 non-zero value of errno has been seen at this point, so ensure it is zero,
 659 because the caller of this function looks at errno when FALSE is returned, to
 660 distinguish between an unexpected return code and other errors such as
 661 timeouts, lost connections, etc. */
 662
 663 errno = 0;
 664 return buffer[0] == okdigit;
 665 }
 666
 667 /* End of smtp_out.c */
 668 /* vi: aw ai sw=2
 669 */