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