src/src/smtp_out.c

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