src/src/smtp_out.c

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