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 /* This might be called both due to callout and then from delivery.
 600 Use memory that will not be released between those phases.
 601 */
 602 static void
 603 smtp_debug_resp(const uschar * buf)
 604 {
 605 #ifndef DISABLE_CLIENT_CMD_LOG
 606 int old_pool = store_pool;
 607 store_pool = POOL_PERM;
 608 client_cmd_log = string_append_listele_n(client_cmd_log, ':', buf,
 609   buf[3] == ' ' ? 3 : 4);
 610 store_pool = old_pool;
 611 #endif
 612 }
 613
 614
 615 /*************************************************
 616 *             Write SMTP command                 *
 617 *************************************************/
 618
 619 /* The formatted command is left in big_buffer so that it can be reflected in
 620 any error message.
 621
 622 Arguments:
 623   sx         SMTP connection, contains buffer for pipelining, and socket
 624   mode       buffer, write-with-more-likely, write
 625   format     a format, starting with one of
 626              of HELO, MAIL FROM, RCPT TO, DATA, ".", or QUIT.
 627              If NULL, flush pipeline buffer only.
 628   ...        data for the format
 629
 630 Returns:     0 if command added to pipelining buffer, with nothing transmitted
 631             +n if n commands transmitted (may still have buffered the new one)
 632             -1 on error, with errno set
 633 */
 634
 635 int
 636 smtp_write_command(void * sx, int mode, const char * format, ...)
 637 {
 638 smtp_outblock * outblock = &((smtp_context *)sx)->outblock;
 639 int rc = 0;
 640
 641 if (format)
 642   {
 643   gstring gs = { .size = big_buffer_size, .ptr = 0, .s = big_buffer };
 644   va_list ap;
 645
 646   /* Use taint-unchecked routines for writing into big_buffer, trusting that
 647   we'll never expand the results.  Actually, the error-message use - leaving
 648   the results in big_buffer for potential later use - is uncomfortably distant.
 649   XXX Would be better to assume all smtp commands are short, use normal pool
 650   alloc rather than big_buffer, and another global for the data-for-error. */
 651
 652   va_start(ap, format);
 653   if (!string_vformat(&gs, SVFMT_TAINT_NOCHK, CS format, ap))
 654     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "overlong write_command in outgoing "
 655       "SMTP");
 656   va_end(ap);
 657   string_from_gstring(&gs);
 658
 659   if (gs.ptr > outblock->buffersize)
 660     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "overlong write_command in outgoing "
 661       "SMTP");
 662
 663   if (gs.ptr > outblock->buffersize - (outblock->ptr - outblock->buffer))
 664     {
 665     rc = outblock->cmd_count;                 /* flush resets */
 666     if (!flush_buffer(outblock, SCMD_FLUSH)) return -1;
 667     }
 668
 669   Ustrncpy(outblock->ptr, gs.s, gs.ptr);
 670   outblock->ptr += gs.ptr;
 671   outblock->cmd_count++;
 672   gs.ptr -= 2; string_from_gstring(&gs); /* remove \r\n for error message */
 673
 674   /* We want to hide the actual data sent in AUTH transactions from reflections
 675   and logs. While authenticating, a flag is set in the outblock to enable this.
 676   The AUTH command itself gets any data flattened. Other lines are flattened
 677   completely. */
 678
 679   if (outblock->authenticating)
 680     {
 681     uschar *p = big_buffer;
 682     if (Ustrncmp(big_buffer, "AUTH ", 5) == 0)
 683       {
 684       p += 5;
 685       while (isspace(*p)) p++;
 686       while (!isspace(*p)) p++;
 687       while (isspace(*p)) p++;
 688       }
 689     while (*p) *p++ = '*';
 690     }
 691
 692   smtp_debug_cmd(big_buffer, mode);
 693   }
 694
 695 if (mode != SCMD_BUFFER)
 696   {
 697   rc += outblock->cmd_count;                /* flush resets */
 698   if (!flush_buffer(outblock, mode)) return -1;
 699   }
 700
 701 return rc;
 702 }
 703
 704
 705
 706 /*************************************************
 707 *          Read one line of SMTP response        *
 708 *************************************************/
 709
 710 /* This function reads one line of SMTP response from the server host. This may
 711 not be a complete response - it could be just part of a multiline response. We
 712 have to use a buffer for incoming packets, because when pipelining or using
 713 LMTP, there may well be more than one response in a single packet. This
 714 function is called only from the one that follows.
 715
 716 Arguments:
 717   inblock   the SMTP input block (contains holding buffer, socket, etc.)
 718   buffer    where to put the line
 719   size      space available for the line
 720   timelimit deadline for reading the lime, seconds past epoch
 721
 722 Returns:    length of a line that has been put in the buffer
 723             -1 otherwise, with errno set, and inblock->ptr adjusted
 724 */
 725
 726 static int
 727 read_response_line(smtp_inblock *inblock, uschar *buffer, int size, time_t timelimit)
 728 {
 729 uschar *p = buffer;
 730 uschar *ptr = inblock->ptr;
 731 uschar *ptrend = inblock->ptrend;
 732 client_conn_ctx * cctx = inblock->cctx;
 733
 734 /* Loop for reading multiple packets or reading another packet after emptying
 735 a previously-read one. */
 736
 737 for (;;)
 738   {
 739   int rc;
 740
 741   /* If there is data in the input buffer left over from last time, copy
 742   characters from it until the end of a line, at which point we can return,
 743   having removed any whitespace (which will include CR) at the end of the line.
 744   The rules for SMTP say that lines end in CRLF, but there are have been cases
 745   of hosts using just LF, and other MTAs are reported to handle this, so we
 746   just look for LF. If we run out of characters before the end of a line,
 747   carry on to read the next incoming packet. */
 748
 749   while (ptr < ptrend)
 750     {
 751     int c = *ptr++;
 752     if (c == '\n')
 753       {
 754       while (p > buffer && isspace(p[-1])) p--;
 755       *p = 0;
 756       inblock->ptr = ptr;
 757       return p - buffer;
 758       }
 759     *p++ = c;
 760     if (--size < 4)
 761       {
 762       *p = 0;                     /* Leave malformed line for error message */
 763       errno = ERRNO_SMTPFORMAT;
 764       inblock->ptr = ptr;
 765       return -1;
 766       }
 767     }
 768
 769   /* Need to read a new input packet. */
 770
 771   if((rc = ip_recv(cctx, inblock->buffer, inblock->buffersize, timelimit)) <= 0)
 772     {
 773     DEBUG(D_deliver|D_transport|D_acl|D_v)
 774       debug_printf_indent(errno ? "  SMTP(%s)<<\n" : "  SMTP(closed)<<\n",
 775         strerror(errno));
 776     break;
 777     }
 778
 779   /* Another block of data has been successfully read. Set up the pointers
 780   and let the loop continue. */
 781
 782   ptrend = inblock->ptrend = inblock->buffer + rc;
 783   ptr = inblock->buffer;
 784   DEBUG(D_transport|D_acl) debug_printf_indent("read response data: size=%d\n", rc);
 785   }
 786
 787 /* Get here if there has been some kind of recv() error; errno is set, but we
 788 ensure that the result buffer is empty before returning. */
 789
 790 inblock->ptr = inblock->ptrend = inblock->buffer;
 791 *buffer = 0;
 792 return -1;
 793 }
 794
 795
 796
 797
 798
 799 /*************************************************
 800 *              Read SMTP response                *
 801 *************************************************/
 802
 803 /* This function reads an SMTP response with a timeout, and returns the
 804 response in the given buffer, as a string. A multiline response will contain
 805 newline characters between the lines. The function also analyzes the first
 806 digit of the reply code and returns FALSE if it is not acceptable. FALSE is
 807 also returned after a reading error. In this case buffer[0] will be zero, and
 808 the error code will be in errno.
 809
 810 Arguments:
 811   sx        the SMTP connection (contains input block with holding buffer,
 812                 socket, etc.)
 813   buffer    where to put the response
 814   size      the size of the buffer
 815   okdigit   the expected first digit of the response
 816   timeout   the timeout to use, in seconds
 817
 818 Returns:    TRUE if a valid, non-error response was received; else FALSE
 819 */
 820 /*XXX could move to smtp transport; no other users */
 821
 822 BOOL
 823 smtp_read_response(void * sx0, uschar * buffer, int size, int okdigit,
 824    int timeout)
 825 {
 826 smtp_context * sx = sx0;
 827 uschar * ptr = buffer;
 828 int count = 0;
 829 time_t timelimit = time(NULL) + timeout;
 830 BOOL yield = FALSE;
 831
 832 errno = 0;  /* Ensure errno starts out zero */
 833 buffer[0] = '\0';
 834
 835 #ifndef DISABLE_PIPE_CONNECT
 836 if (sx->pending_BANNER || sx->pending_EHLO)
 837   {
 838   int rc;
 839   if ((rc = smtp_reap_early_pipe(sx, &count)) != OK)
 840     {
 841     DEBUG(D_transport) debug_printf("failed reaping pipelined cmd responsess\n");
 842     if (rc == DEFER) errno = ERRNO_TLSFAILURE;
 843     goto out;
 844     }
 845   }
 846 #endif
 847
 848 /* This is a loop to read and concatenate the lines that make up a multi-line
 849 response. */
 850
 851 for (;;)
 852   {
 853   if ((count = read_response_line(&sx->inblock, ptr, size, timelimit)) < 0)
 854     return FALSE;
 855
 856   HDEBUG(D_transport|D_acl|D_v)
 857     debug_printf_indent("  %s %s\n", ptr == buffer ? "SMTP<<" : "      ", ptr);
 858
 859   /* Check the format of the response: it must start with three digits; if
 860   these are followed by a space or end of line, the response is complete. If
 861   they are followed by '-' this is a multi-line response and we must look for
 862   another line until the final line is reached. The only use made of multi-line
 863   responses is to pass them back as error messages. We therefore just
 864   concatenate them all within the buffer, which should be large enough to
 865   accept any reasonable number of lines. */
 866
 867   if (count < 3 ||
 868      !isdigit(ptr[0]) ||
 869      !isdigit(ptr[1]) ||
 870      !isdigit(ptr[2]) ||
 871      (ptr[3] != '-' && ptr[3] != ' ' && ptr[3] != 0))
 872     {
 873     errno = ERRNO_SMTPFORMAT;    /* format error */
 874     goto out;
 875     }
 876
 877   /* If the line we have just read is a terminal line, line, we are done.
 878   Otherwise more data has to be read. */
 879
 880   if (ptr[3] != '-') break;
 881
 882   /* Move the reading pointer upwards in the buffer and insert \n between the
 883   components of a multiline response. Space is left for this by read_response_
 884   line(). */
 885
 886   ptr += count;
 887   *ptr++ = '\n';
 888   size -= count + 1;
 889   }
 890
 891 #ifdef TCP_FASTOPEN
 892 tfo_out_check(sx->cctx.sock);
 893 #endif
 894
 895 /* Return a value that depends on the SMTP return code. On some systems a
 896 non-zero value of errno has been seen at this point, so ensure it is zero,
 897 because the caller of this function looks at errno when FALSE is returned, to
 898 distinguish between an unexpected return code and other errors such as
 899 timeouts, lost connections, etc. */
 900
 901 errno = 0;
 902 yield = buffer[0] == okdigit;
 903
 904 out:
 905   smtp_debug_resp(buffer);
 906   return yield;
 907 }
 908
 909 /* End of smtp_out.c */
 910 /* vi: aw ai sw=2
 911 */