src/src/smtp_out.c

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