src/src/smtp_out.c

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