src/src/smtp_out.c

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