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