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