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