src/src/smtp_out.c

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