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