src/src/smtp_out.c

   1 /*************************************************
   2 *     Exim - an Internet mail transport agent    *
   3 *************************************************/
   4
   5 /* Copyright (c) University of Cambridge 1995 - 2018 */
   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) return TRUE;
  45
  46 if (!(expint = expand_string(istring)))
  47   {
  48   if (f.expand_string_forcedfail) return TRUE;
  49   addr->transport_return = PANIC;
  50   addr->message = string_sprintf("failed to expand \"interface\" "
  51       "option for %s: %s", msg, expand_string_message);
  52   return FALSE;
  53   }
  54
  55 if (is_tainted(expint))
  56   {
  57   log_write(0, LOG_MAIN|LOG_PANIC,
  58     "attempt to use tainted value '%s' from '%s' for interface",
  59     expint, istring);
  60   addr->transport_return = PANIC;
  61   addr->message = string_sprintf("failed to expand \"interface\" "
  62       "option for %s: configuration error", msg);
  63   return FALSE;
  64   }
  65
  66 while (isspace(*expint)) expint++;
  67 if (*expint == 0) return TRUE;
  68
  69 while ((iface = string_nextinlist(&expint, &sep, big_buffer,
  70           big_buffer_size)))
  71   {
  72   if (string_is_ip_address(iface, NULL) == 0)
  73     {
  74     addr->transport_return = PANIC;
  75     addr->message = string_sprintf("\"%s\" is not a valid IP "
  76       "address for the \"interface\" option for %s",
  77       iface, msg);
  78     return FALSE;
  79     }
  80
  81   if (((Ustrchr(iface, ':') == NULL)? AF_INET:AF_INET6) == host_af)
  82     break;
  83   }
  84
  85 if (iface) *interface = string_copy(iface);
  86 return TRUE;
  87 }
  88
  89
  90
  91 /*************************************************
  92 *           Find an outgoing port                *
  93 *************************************************/
  94
  95 /* This function is called from the smtp transport and also from the callout
  96 code in verify.c. Its job is to find a port number. Note that getservbyname()
  97 produces the number in network byte order.
  98
  99 Arguments:
 100   rstring     raw (unexpanded) string representation of the port
 101   addr        the mail address being handled (for setting errors)
 102   port        stick the port in here
 103   msg         for adding to error message
 104
 105 Returns:      TRUE on success, FALSE on failure, with error message set
 106                 in addr, and transport_return set to PANIC
 107 */
 108
 109 BOOL
 110 smtp_get_port(uschar *rstring, address_item *addr, int *port, uschar *msg)
 111 {
 112 uschar *pstring = expand_string(rstring);
 113
 114 if (!pstring)
 115   {
 116   addr->transport_return = PANIC;
 117   addr->message = string_sprintf("failed to expand \"%s\" (\"port\" option) "
 118     "for %s: %s", rstring, msg, expand_string_message);
 119   return FALSE;
 120   }
 121
 122 if (isdigit(*pstring))
 123   {
 124   uschar *end;
 125   *port = Ustrtol(pstring, &end, 0);
 126   if (end != pstring + Ustrlen(pstring))
 127     {
 128     addr->transport_return = PANIC;
 129     addr->message = string_sprintf("invalid port number for %s: %s", msg,
 130       pstring);
 131     return FALSE;
 132     }
 133   }
 134
 135 else
 136   {
 137   struct servent *smtp_service = getservbyname(CS pstring, "tcp");
 138   if (!smtp_service)
 139     {
 140     addr->transport_return = PANIC;
 141     addr->message = string_sprintf("TCP port \"%s\" is not defined for %s",
 142       pstring, msg);
 143     return FALSE;
 144     }
 145   *port = ntohs(smtp_service->s_port);
 146   }
 147
 148 return TRUE;
 149 }
 150
 151
 152
 153
 154 #ifdef TCP_FASTOPEN
 155 static void
 156 tfo_out_check(int sock)
 157 {
 158 # if defined(TCP_INFO) && defined(EXIM_HAVE_TCPI_UNACKED)
 159 struct tcp_info tinfo;
 160 socklen_t len = sizeof(tinfo);
 161
 162 switch (tcp_out_fastopen)
 163   {
 164     /* This is a somewhat dubious detection method; totally undocumented so likely
 165     to fail in future kernels.  There seems to be no documented way.  What we really
 166     want to know is if the server sent smtp-banner data before our ACK of his SYN,ACK
 167     hit him.  What this (possibly?) detects is whether we sent a TFO cookie with our
 168     SYN, as distinct from a TFO request.  This gets a false-positive when the server
 169     key is rotated; we send the old one (which this test sees) but the server returns
 170     the new one and does not send its SMTP banner before we ACK his SYN,ACK.
 171      To force that rotation case:
 172      '# echo -n "00000000-00000000-00000000-0000000" >/proc/sys/net/ipv4/tcp_fastopen_key'
 173     The kernel seems to be counting unack'd packets. */
 174
 175   case TFO_ATTEMPTED_NODATA:
 176     if (  getsockopt(sock, IPPROTO_TCP, TCP_INFO, &tinfo, &len) == 0
 177        && tinfo.tcpi_state == TCP_SYN_SENT
 178        && tinfo.tcpi_unacked > 1
 179        )
 180       {
 181       DEBUG(D_transport|D_v)
 182         debug_printf("TCP_FASTOPEN tcpi_unacked %d\n", tinfo.tcpi_unacked);
 183       tcp_out_fastopen = TFO_USED_NODATA;
 184       }
 185     break;
 186
 187     /* When called after waiting for received data we should be able
 188     to tell if data we sent was accepted. */
 189
 190   case TFO_ATTEMPTED_DATA:
 191     if (  getsockopt(sock, IPPROTO_TCP, TCP_INFO, &tinfo, &len) == 0
 192        && tinfo.tcpi_state == TCP_ESTABLISHED
 193        )
 194       if (tinfo.tcpi_options & TCPI_OPT_SYN_DATA)
 195         {
 196         DEBUG(D_transport|D_v) debug_printf("TFO: data was acked\n");
 197         tcp_out_fastopen = TFO_USED_DATA;
 198         }
 199       else
 200         {
 201         DEBUG(D_transport|D_v) debug_printf("TFO: had to retransmit\n");
 202         tcp_out_fastopen = TFO_NOT_USED;
 203         }
 204     break;
 205
 206   default: break; /* compiler quietening */
 207   }
 208 # endif
 209 }
 210 #endif
 211
 212
 213 /* Arguments as for smtp_connect(), plus
 214   early_data    if non-NULL, idenmpotent data to be sent -
 215                 preferably in the TCP SYN segment
 216
 217 Returns:      connected socket number, or -1 with errno set
 218 */
 219
 220 int
 221 smtp_sock_connect(host_item * host, int host_af, int port, uschar * interface,
 222   transport_instance * tb, int timeout, const blob * early_data)
 223 {
 224 smtp_transport_options_block * ob =
 225   (smtp_transport_options_block *)tb->options_block;
 226 const uschar * dscp = ob->dscp;
 227 int dscp_value;
 228 int dscp_level;
 229 int dscp_option;
 230 int sock;
 231 int save_errno = 0;
 232 const blob * fastopen_blob = NULL;
 233
 234
 235 #ifndef DISABLE_EVENT
 236 deliver_host_address = host->address;
 237 deliver_host_port = port;
 238 if (event_raise(tb->event_action, US"tcp:connect", NULL)) return -1;
 239 #endif
 240
 241 if ((sock = ip_socket(SOCK_STREAM, host_af)) < 0) return -1;
 242
 243 /* Set TCP_NODELAY; Exim does its own buffering. */
 244
 245 if (setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, US &on, sizeof(on)))
 246   HDEBUG(D_transport|D_acl|D_v)
 247     debug_printf_indent("failed to set NODELAY: %s ", strerror(errno));
 248
 249 /* Set DSCP value, if we can. For now, if we fail to set the value, we don't
 250 bomb out, just log it and continue in default traffic class. */
 251
 252 if (dscp && dscp_lookup(dscp, host_af, &dscp_level, &dscp_option, &dscp_value))
 253   {
 254   HDEBUG(D_transport|D_acl|D_v)
 255     debug_printf_indent("DSCP \"%s\"=%x ", dscp, dscp_value);
 256   if (setsockopt(sock, dscp_level, dscp_option, &dscp_value, sizeof(dscp_value)) < 0)
 257     HDEBUG(D_transport|D_acl|D_v)
 258       debug_printf_indent("failed to set DSCP: %s ", strerror(errno));
 259   /* If the kernel supports IPv4 and IPv6 on an IPv6 socket, we need to set the
 260   option for both; ignore failures here */
 261   if (host_af == AF_INET6 &&
 262       dscp_lookup(dscp, AF_INET, &dscp_level, &dscp_option, &dscp_value))
 263     (void) setsockopt(sock, dscp_level, dscp_option, &dscp_value, sizeof(dscp_value));
 264   }
 265
 266 /* Bind to a specific interface if requested. Caller must ensure the interface
 267 is the same type (IPv4 or IPv6) as the outgoing address. */
 268
 269 if (interface && ip_bind(sock, host_af, interface, 0) < 0)
 270   {
 271   save_errno = errno;
 272   HDEBUG(D_transport|D_acl|D_v)
 273     debug_printf_indent("unable to bind outgoing SMTP call to %s: %s", interface,
 274     strerror(errno));
 275   }
 276
 277 /* Connect to the remote host, and add keepalive to the socket before returning
 278 it, if requested.  If the build supports TFO, request it - and if the caller
 279 requested some early-data then include that in the TFO request.  If there is
 280 early-data but no TFO support, send it after connecting. */
 281
 282 else
 283   {
 284 #ifdef TCP_FASTOPEN
 285   if (verify_check_given_host(CUSS &ob->hosts_try_fastopen, host) == OK)
 286     fastopen_blob = early_data ? early_data : &tcp_fastopen_nodata;
 287 #endif
 288
 289   if (ip_connect(sock, host_af, host->address, port, timeout, fastopen_blob) < 0)
 290     save_errno = errno;
 291   else if (early_data && !fastopen_blob && early_data->data && early_data->len)
 292     {
 293     HDEBUG(D_transport|D_acl|D_v)
 294       debug_printf("sending %ld nonTFO early-data\n", (long)early_data->len);
 295
 296 #ifdef TCP_QUICKACK
 297     (void) setsockopt(sock, IPPROTO_TCP, TCP_QUICKACK, US &off, sizeof(off));
 298 #endif
 299     if (send(sock, early_data->data, early_data->len, 0) < 0)
 300       save_errno = errno;
 301     }
 302   }
 303
 304 /* Either bind() or connect() failed */
 305
 306 if (save_errno != 0)
 307   {
 308   HDEBUG(D_transport|D_acl|D_v)
 309     {
 310     debug_printf_indent(" failed: %s", CUstrerror(save_errno));
 311     if (save_errno == ETIMEDOUT)
 312       debug_printf(" (timeout=%s)", readconf_printtime(timeout));
 313     debug_printf("\n");
 314     }
 315   (void)close(sock);
 316   errno = save_errno;
 317   return -1;
 318   }
 319
 320 /* Both bind() and connect() succeeded, and any early-data */
 321
 322 else
 323   {
 324   union sockaddr_46 interface_sock;
 325   EXIM_SOCKLEN_T size = sizeof(interface_sock);
 326
 327   HDEBUG(D_transport|D_acl|D_v) debug_printf_indent(" connected\n");
 328   if (getsockname(sock, (struct sockaddr *)(&interface_sock), &size) == 0)
 329     sending_ip_address = host_ntoa(-1, &interface_sock, NULL, &sending_port);
 330   else
 331     {
 332     log_write(0, LOG_MAIN | ((errno == ECONNRESET)? 0 : LOG_PANIC),
 333       "getsockname() failed: %s", strerror(errno));
 334     close(sock);
 335     return -1;
 336     }
 337
 338   if (ob->keepalive) ip_keepalive(sock, host->address, TRUE);
 339 #ifdef TCP_FASTOPEN
 340   tfo_out_check(sock);
 341 #endif
 342   return sock;
 343   }
 344 }
 345
 346
 347
 348
 349
 350 void
 351 smtp_port_for_connect(host_item * host, int port)
 352 {
 353 if (host->port != PORT_NONE)
 354   {
 355   HDEBUG(D_transport|D_acl|D_v)
 356     debug_printf_indent("Transport port=%d replaced by host-specific port=%d\n", port,
 357       host->port);
 358   port = host->port;
 359   }
 360 else host->port = port;    /* Set the port actually used */
 361 }
 362
 363
 364 /*************************************************
 365 *           Connect to remote host               *
 366 *************************************************/
 367
 368 /* Create a socket, and connect it to a remote host. IPv6 addresses are
 369 detected by checking for a colon in the address. AF_INET6 is defined even on
 370 non-IPv6 systems, to enable the code to be less messy. However, on such systems
 371 host->address will always be an IPv4 address.
 372
 373 Arguments:
 374   sc          details for making connection: host, af, interface, transport
 375   early_data  if non-NULL, data to be sent - preferably in the TCP SYN segment
 376
 377 Returns:      connected socket number, or -1 with errno set
 378 */
 379
 380 int
 381 smtp_connect(smtp_connect_args * sc, const blob * early_data)
 382 {
 383 int port = sc->host->port;
 384 smtp_transport_options_block * ob = sc->ob;
 385
 386 callout_address = string_sprintf("[%s]:%d", sc->host->address, port);
 387
 388 HDEBUG(D_transport|D_acl|D_v)
 389   {
 390   uschar * s = US" ";
 391   if (sc->interface) s = string_sprintf(" from %s ", sc->interface);
 392 #ifdef SUPPORT_SOCKS
 393   if (ob->socks_proxy) s = string_sprintf("%svia proxy ", s);
 394 #endif
 395   debug_printf_indent("Connecting to %s %s%s... ", sc->host->name, callout_address, s);
 396   }
 397
 398 /* Create and connect the socket */
 399
 400 #ifdef SUPPORT_SOCKS
 401 if (ob->socks_proxy)
 402   {
 403   int sock = socks_sock_connect(sc->host, sc->host_af, port, sc->interface,
 404                                 sc->tblock, ob->connect_timeout);
 405
 406   if (sock >= 0)
 407     {
 408     if (early_data && early_data->data && early_data->len)
 409       if (send(sock, early_data->data, early_data->len, 0) < 0)
 410         {
 411         int save_errno = errno;
 412         HDEBUG(D_transport|D_acl|D_v)
 413           {
 414           debug_printf_indent("failed: %s", CUstrerror(save_errno));
 415           if (save_errno == ETIMEDOUT)
 416             debug_printf(" (timeout=%s)", readconf_printtime(ob->connect_timeout));
 417           debug_printf("\n");
 418           }
 419         (void)close(sock);
 420         sock = -1;
 421         errno = save_errno;
 422         }
 423     }
 424   return sock;
 425   }
 426 #endif
 427
 428 return smtp_sock_connect(sc->host, sc->host_af, port, sc->interface,
 429                           sc->tblock, ob->connect_timeout, early_data);
 430 }
 431
 432
 433 /*************************************************
 434 *        Flush outgoing command buffer           *
 435 *************************************************/
 436
 437 /* This function is called only from smtp_write_command() below. It flushes
 438 the buffer of outgoing commands. There is more than one in the buffer only when
 439 pipelining.
 440
 441 Argument:
 442   outblock   the SMTP output block
 443   mode       further data expected, or plain
 444
 445 Returns:     TRUE if OK, FALSE on error, with errno set
 446 */
 447
 448 static BOOL
 449 flush_buffer(smtp_outblock * outblock, int mode)
 450 {
 451 int rc;
 452 int n = outblock->ptr - outblock->buffer;
 453 BOOL more = mode == SCMD_MORE;
 454
 455 HDEBUG(D_transport|D_acl) debug_printf_indent("cmd buf flush %d bytes%s\n", n,
 456   more ? " (more expected)" : "");
 457
 458 #ifndef DISABLE_TLS
 459 if (outblock->cctx->tls_ctx)
 460   rc = tls_write(outblock->cctx->tls_ctx, outblock->buffer, n, more);
 461 else
 462 #endif
 463
 464   {
 465   if (outblock->conn_args)
 466     {
 467     blob early_data = { .data = outblock->buffer, .len = n };
 468
 469     /* We ignore the more-flag if we're doing a connect with early-data, which
 470     means we won't get BDAT+data. A pity, but wise due to the idempotency
 471     requirement: TFO with data can, in rare cases, replay the data to the
 472     receiver. */
 473
 474     if (  (outblock->cctx->sock = smtp_connect(outblock->conn_args, &early_data))
 475        < 0)
 476       return FALSE;
 477     outblock->conn_args = NULL;
 478     rc = n;
 479     }
 480   else
 481
 482     rc = send(outblock->cctx->sock, outblock->buffer, n,
 483 #ifdef MSG_MORE
 484               more ? MSG_MORE : 0
 485 #else
 486               0
 487 #endif
 488              );
 489   }
 490
 491 if (rc <= 0)
 492   {
 493   HDEBUG(D_transport|D_acl) debug_printf_indent("send failed: %s\n", strerror(errno));
 494   return FALSE;
 495   }
 496
 497 outblock->ptr = outblock->buffer;
 498 outblock->cmd_count = 0;
 499 return TRUE;
 500 }
 501
 502
 503
 504 /*************************************************
 505 *             Write SMTP command                 *
 506 *************************************************/
 507
 508 /* The formatted command is left in big_buffer so that it can be reflected in
 509 any error message.
 510
 511 Arguments:
 512   sx         SMTP connection, contains buffer for pipelining, and socket
 513   mode       buffer, write-with-more-likely, write
 514   format     a format, starting with one of
 515              of HELO, MAIL FROM, RCPT TO, DATA, ".", or QUIT.
 516              If NULL, flush pipeline buffer only.
 517   ...        data for the format
 518
 519 Returns:     0 if command added to pipelining buffer, with nothing transmitted
 520             +n if n commands transmitted (may still have buffered the new one)
 521             -1 on error, with errno set
 522 */
 523
 524 int
 525 smtp_write_command(void * sx, int mode, const char *format, ...)
 526 {
 527 smtp_outblock * outblock = &((smtp_context *)sx)->outblock;
 528 int rc = 0;
 529
 530 if (format)
 531   {
 532   gstring gs = { .size = big_buffer_size, .ptr = 0, .s = big_buffer };
 533   va_list ap;
 534
 535   /* Use taint-unchecked routines for writing into big_buffer, trusting that
 536   we'll never expand the results.  Actually, the error-message use - leaving
 537   the results in big_buffer for potential later use - is uncomfortably distant.
 538   XXX Would be better to assume all smtp commands are short, use normal pool
 539   alloc rather than big_buffer, and another global for the data-for-error. */
 540
 541   va_start(ap, format);
 542   if (!string_vformat(&gs, SVFMT_TAINT_NOCHK, CS format, ap))
 543     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "overlong write_command in outgoing "
 544       "SMTP");
 545   va_end(ap);
 546   string_from_gstring(&gs);
 547
 548   if (gs.ptr > outblock->buffersize)
 549     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "overlong write_command in outgoing "
 550       "SMTP");
 551
 552   if (gs.ptr > outblock->buffersize - (outblock->ptr - outblock->buffer))
 553     {
 554     rc = outblock->cmd_count;                 /* flush resets */
 555     if (!flush_buffer(outblock, SCMD_FLUSH)) return -1;
 556     }
 557
 558   Ustrncpy(outblock->ptr, gs.s, gs.ptr);
 559   outblock->ptr += gs.ptr;
 560   outblock->cmd_count++;
 561   gs.ptr -= 2; string_from_gstring(&gs); /* remove \r\n for error message */
 562
 563   /* We want to hide the actual data sent in AUTH transactions from reflections
 564   and logs. While authenticating, a flag is set in the outblock to enable this.
 565   The AUTH command itself gets any data flattened. Other lines are flattened
 566   completely. */
 567
 568   if (outblock->authenticating)
 569     {
 570     uschar *p = big_buffer;
 571     if (Ustrncmp(big_buffer, "AUTH ", 5) == 0)
 572       {
 573       p += 5;
 574       while (isspace(*p)) p++;
 575       while (!isspace(*p)) p++;
 576       while (isspace(*p)) p++;
 577       }
 578     while (*p != 0) *p++ = '*';
 579     }
 580
 581   HDEBUG(D_transport|D_acl|D_v) debug_printf_indent("  SMTP>> %s\n", big_buffer);
 582   }
 583
 584 if (mode != SCMD_BUFFER)
 585   {
 586   rc += outblock->cmd_count;                /* flush resets */
 587   if (!flush_buffer(outblock, mode)) return -1;
 588   }
 589
 590 return rc;
 591 }
 592
 593
 594
 595 /*************************************************
 596 *          Read one line of SMTP response        *
 597 *************************************************/
 598
 599 /* This function reads one line of SMTP response from the server host. This may
 600 not be a complete response - it could be just part of a multiline response. We
 601 have to use a buffer for incoming packets, because when pipelining or using
 602 LMTP, there may well be more than one response in a single packet. This
 603 function is called only from the one that follows.
 604
 605 Arguments:
 606   inblock   the SMTP input block (contains holding buffer, socket, etc.)
 607   buffer    where to put the line
 608   size      space available for the line
 609   timelimit deadline for reading the lime, seconds past epoch
 610
 611 Returns:    length of a line that has been put in the buffer
 612             -1 otherwise, with errno set
 613 */
 614
 615 static int
 616 read_response_line(smtp_inblock *inblock, uschar *buffer, int size, time_t timelimit)
 617 {
 618 uschar *p = buffer;
 619 uschar *ptr = inblock->ptr;
 620 uschar *ptrend = inblock->ptrend;
 621 client_conn_ctx * cctx = inblock->cctx;
 622
 623 /* Loop for reading multiple packets or reading another packet after emptying
 624 a previously-read one. */
 625
 626 for (;;)
 627   {
 628   int rc;
 629
 630   /* If there is data in the input buffer left over from last time, copy
 631   characters from it until the end of a line, at which point we can return,
 632   having removed any whitespace (which will include CR) at the end of the line.
 633   The rules for SMTP say that lines end in CRLF, but there are have been cases
 634   of hosts using just LF, and other MTAs are reported to handle this, so we
 635   just look for LF. If we run out of characters before the end of a line,
 636   carry on to read the next incoming packet. */
 637
 638   while (ptr < ptrend)
 639     {
 640     int c = *ptr++;
 641     if (c == '\n')
 642       {
 643       while (p > buffer && isspace(p[-1])) p--;
 644       *p = 0;
 645       inblock->ptr = ptr;
 646       return p - buffer;
 647       }
 648     *p++ = c;
 649     if (--size < 4)
 650       {
 651       *p = 0;                     /* Leave malformed line for error message */
 652       errno = ERRNO_SMTPFORMAT;
 653       return -1;
 654       }
 655     }
 656
 657   /* Need to read a new input packet. */
 658
 659   if((rc = ip_recv(cctx, inblock->buffer, inblock->buffersize, timelimit)) <= 0)
 660     {
 661     DEBUG(D_deliver|D_transport|D_acl|D_v)
 662       debug_printf_indent(errno ? "  SMTP(%s)<<\n" : "  SMTP(closed)<<\n",
 663         strerror(errno));
 664     break;
 665     }
 666
 667   /* Another block of data has been successfully read. Set up the pointers
 668   and let the loop continue. */
 669
 670   ptrend = inblock->ptrend = inblock->buffer + rc;
 671   ptr = inblock->buffer;
 672   DEBUG(D_transport|D_acl) debug_printf_indent("read response data: size=%d\n", rc);
 673   }
 674
 675 /* Get here if there has been some kind of recv() error; errno is set, but we
 676 ensure that the result buffer is empty before returning. */
 677
 678 *buffer = 0;
 679 return -1;
 680 }
 681
 682
 683
 684
 685
 686 /*************************************************
 687 *              Read SMTP response                *
 688 *************************************************/
 689
 690 /* This function reads an SMTP response with a timeout, and returns the
 691 response in the given buffer, as a string. A multiline response will contain
 692 newline characters between the lines. The function also analyzes the first
 693 digit of the reply code and returns FALSE if it is not acceptable. FALSE is
 694 also returned after a reading error. In this case buffer[0] will be zero, and
 695 the error code will be in errno.
 696
 697 Arguments:
 698   sx        the SMTP connection (contains input block with holding buffer,
 699                 socket, etc.)
 700   buffer    where to put the response
 701   size      the size of the buffer
 702   okdigit   the expected first digit of the response
 703   timeout   the timeout to use, in seconds
 704
 705 Returns:    TRUE if a valid, non-error response was received; else FALSE
 706 */
 707 /*XXX could move to smtp transport; no other users */
 708
 709 BOOL
 710 smtp_read_response(void * sx0, uschar * buffer, int size, int okdigit,
 711    int timeout)
 712 {
 713 smtp_context * sx = sx0;
 714 uschar * ptr = buffer;
 715 int count = 0;
 716 time_t timelimit = time(NULL) + timeout;
 717
 718 errno = 0;  /* Ensure errno starts out zero */
 719
 720 #ifdef SUPPORT_PIPE_CONNECT
 721 if (sx->pending_BANNER || sx->pending_EHLO)
 722   {
 723   int rc;
 724   if ((rc = smtp_reap_early_pipe(sx, &count)) != OK)
 725     {
 726     DEBUG(D_transport) debug_printf("failed reaping pipelined cmd responsess\n");
 727     buffer[0] = '\0';
 728     if (rc == DEFER) errno = ERRNO_TLSFAILURE;
 729     return FALSE;
 730     }
 731   }
 732 #endif
 733
 734 /* This is a loop to read and concatenate the lines that make up a multi-line
 735 response. */
 736
 737 for (;;)
 738   {
 739   if ((count = read_response_line(&sx->inblock, ptr, size, timelimit)) < 0)
 740     return FALSE;
 741
 742   HDEBUG(D_transport|D_acl|D_v)
 743     debug_printf_indent("  %s %s\n", ptr == buffer ? "SMTP<<" : "      ", ptr);
 744
 745   /* Check the format of the response: it must start with three digits; if
 746   these are followed by a space or end of line, the response is complete. If
 747   they are followed by '-' this is a multi-line response and we must look for
 748   another line until the final line is reached. The only use made of multi-line
 749   responses is to pass them back as error messages. We therefore just
 750   concatenate them all within the buffer, which should be large enough to
 751   accept any reasonable number of lines. */
 752
 753   if (count < 3 ||
 754      !isdigit(ptr[0]) ||
 755      !isdigit(ptr[1]) ||
 756      !isdigit(ptr[2]) ||
 757      (ptr[3] != '-' && ptr[3] != ' ' && ptr[3] != 0))
 758     {
 759     errno = ERRNO_SMTPFORMAT;    /* format error */
 760     return FALSE;
 761     }
 762
 763   /* If the line we have just read is a terminal line, line, we are done.
 764   Otherwise more data has to be read. */
 765
 766   if (ptr[3] != '-') break;
 767
 768   /* Move the reading pointer upwards in the buffer and insert \n between the
 769   components of a multiline response. Space is left for this by read_response_
 770   line(). */
 771
 772   ptr += count;
 773   *ptr++ = '\n';
 774   size -= count + 1;
 775   }
 776
 777 #ifdef TCP_FASTOPEN
 778   tfo_out_check(sx->cctx.sock);
 779 #endif
 780
 781 /* Return a value that depends on the SMTP return code. On some systems a
 782 non-zero value of errno has been seen at this point, so ensure it is zero,
 783 because the caller of this function looks at errno when FALSE is returned, to
 784 distinguish between an unexpected return code and other errors such as
 785 timeouts, lost connections, etc. */
 786
 787 errno = 0;
 788 return buffer[0] == okdigit;
 789 }
 790
 791 /* End of smtp_out.c */
 792 /* vi: aw ai sw=2
 793 */