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