src/src/smtp_out.c

   1 /*************************************************
   2 *     Exim - an Internet mail transport agent    *
   3 *************************************************/
   4
   5 /* Copyright (c) The Exim Maintainers 2020 - 2022 */
   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 =
 265   (smtp_transport_options_block *)tb->options_block;
 266 const uschar * dscp = ob->dscp;
 267 int sock, dscp_value, dscp_level, dscp_option;
 268
 269 if ((sock = ip_socket(SOCK_STREAM, sc->host_af)) < 0)
 270   return -1;
 271
 272 /* Set TCP_NODELAY; Exim does its own buffering. */
 273
 274 if (setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, US &on, sizeof(on)))
 275   HDEBUG(D_transport|D_acl|D_v)
 276     debug_printf_indent("failed to set NODELAY: %s ", strerror(errno));
 277
 278 /* Set DSCP value, if we can. For now, if we fail to set the value, we don't
 279 bomb out, just log it and continue in default traffic class. */
 280
 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", 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 =
 341   (smtp_transport_options_block *)sc->tblock->options_block;
 342 int sock;
 343 int save_errno = 0;
 344 const blob * fastopen_blob = NULL;
 345
 346
 347 #ifndef DISABLE_EVENT
 348 deliver_host_address = sc->host->address;
 349 deliver_host_port = sc->host->port;
 350 if (event_raise(sc->tblock->event_action, US"tcp:connect", NULL, &errno)) return -1;
 351 #endif
 352
 353 if (  (sock = sc->sock) < 0
 354    && (sock = smtp_boundsock(sc)) < 0)
 355   save_errno = errno;
 356 sc->sock = -1;
 357
 358 /* Connect to the remote host, and add keepalive to the socket before returning
 359 it, if requested.  If the build supports TFO, request it - and if the caller
 360 requested some early-data then include that in the TFO request.  If there is
 361 early-data but no TFO support, send it after connecting. */
 362
 363 if (!save_errno)
 364   {
 365 #ifdef TCP_FASTOPEN
 366   /* See if TCP Fast Open usable.  Default is a traditional 3WHS connect */
 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 #endif
 383
 384   if (ip_connect(sock, sc->host_af, sc->host->address, sc->host->port, timeout, fastopen_blob) < 0)
 385     save_errno = errno;
 386   else if (early_data && !fastopen_blob && early_data->data && early_data->len)
 387     {
 388     /* We had some early-data to send, but couldn't do TFO */
 389     HDEBUG(D_transport|D_acl|D_v)
 390       debug_printf("sending %ld nonTFO early-data\n", (long)early_data->len);
 391
 392 #ifdef TCP_QUICKACK_notdef
 393     (void) setsockopt(sock, IPPROTO_TCP, TCP_QUICKACK, US &off, sizeof(off));
 394 #endif
 395     if (send(sock, early_data->data, early_data->len, 0) < 0)
 396       save_errno = errno;
 397     }
 398 #ifdef TCP_QUICKACK_notdef
 399   /* Under TFO (with openssl & pipe-conn; testcase 4069, as of
 400   5.10.8-100.fc32.x86_64) this seems to be inop.
 401   Perhaps overwritten when we (client) go -> ESTABLISHED on seeing the 3rd-ACK?
 402   For that case, added at smtp_reap_banner(). */
 403   (void) setsockopt(sock, IPPROTO_TCP, TCP_QUICKACK, US &off, sizeof(off));
 404 #endif
 405   }
 406
 407 if (!save_errno)
 408   {
 409   union sockaddr_46 interface_sock;
 410   EXIM_SOCKLEN_T size = sizeof(interface_sock);
 411
 412   /* Both bind() and connect() succeeded, and any early-data */
 413
 414   HDEBUG(D_transport|D_acl|D_v) debug_printf_indent(" connected\n");
 415   if (getsockname(sock, (struct sockaddr *)(&interface_sock), &size) == 0)
 416     sending_ip_address = host_ntoa(-1, &interface_sock, NULL, &sending_port);
 417   else
 418     {
 419     log_write(0, LOG_MAIN | ((errno == ECONNRESET)? 0 : LOG_PANIC),
 420       "getsockname() failed: %s", strerror(errno));
 421     close(sock);
 422     return -1;
 423     }
 424
 425   if (ob->keepalive) ip_keepalive(sock, sc->host->address, TRUE);
 426 #ifdef TCP_FASTOPEN
 427   tfo_out_check(sock);
 428 #endif
 429   return sock;
 430   }
 431
 432 /* Either bind() or connect() failed */
 433
 434 HDEBUG(D_transport|D_acl|D_v)
 435   {
 436   debug_printf_indent(" failed: %s", CUstrerror(save_errno));
 437   if (save_errno == ETIMEDOUT)
 438     debug_printf(" (timeout=%s)", readconf_printtime(timeout));
 439   debug_printf("\n");
 440   }
 441 (void)close(sock);
 442 errno = save_errno;
 443 return -1;
 444 }
 445
 446
 447
 448
 449
 450 void
 451 smtp_port_for_connect(host_item * host, int port)
 452 {
 453 if (host->port != PORT_NONE)
 454   {
 455   HDEBUG(D_transport|D_acl|D_v) if (port != host->port)
 456     debug_printf_indent("Transport port=%d replaced by host-specific port=%d\n", port,
 457       host->port);
 458   port = host->port;
 459   }
 460 else host->port = port;    /* Set the port actually used */
 461 }
 462
 463
 464 /*************************************************
 465 *           Connect to remote host               *
 466 *************************************************/
 467
 468 /* Create a socket, and connect it to a remote host. IPv6 addresses are
 469 detected by checking for a colon in the address. AF_INET6 is defined even on
 470 non-IPv6 systems, to enable the code to be less messy. However, on such systems
 471 host->address will always be an IPv4 address.
 472
 473 Arguments:
 474   sc          details for making connection: host, af, interface, transport
 475   early_data  if non-NULL, data to be sent - preferably in the TCP SYN segment
 476               Special case: non-NULL but with NULL blob.data - caller is
 477               client-data-first (eg. TLS-on-connect) and a lazy-TCP-connect is
 478               acceptable.
 479
 480 Returns:      connected socket number, or -1 with errno set
 481 */
 482
 483 int
 484 smtp_connect(smtp_connect_args * sc, const blob * early_data)
 485 {
 486 int port = sc->host->port;
 487 smtp_transport_options_block * ob = sc->ob;
 488
 489 callout_address = string_sprintf("[%s]:%d", sc->host->address, port);
 490
 491 HDEBUG(D_transport|D_acl|D_v)
 492   {
 493   uschar * s = US" ";
 494   if (sc->interface) s = string_sprintf(" from %s ", sc->interface);
 495 #ifdef SUPPORT_SOCKS
 496   if (ob->socks_proxy) s = string_sprintf("%svia proxy ", s);
 497 #endif
 498   debug_printf_indent("Connecting to %s %s%s... ", sc->host->name, callout_address, s);
 499   }
 500
 501 /* Create and connect the socket */
 502
 503 #ifdef SUPPORT_SOCKS
 504 if (ob->socks_proxy)
 505   {
 506   int sock = socks_sock_connect(sc->host, sc->host_af, port, sc->interface,
 507                                 sc->tblock, ob->connect_timeout);
 508
 509   if (sock >= 0)
 510     {
 511     if (early_data && early_data->data && early_data->len)
 512       if (send(sock, early_data->data, early_data->len, 0) < 0)
 513         {
 514         int save_errno = errno;
 515         HDEBUG(D_transport|D_acl|D_v)
 516           {
 517           debug_printf_indent("failed: %s", CUstrerror(save_errno));
 518           if (save_errno == ETIMEDOUT)
 519             debug_printf(" (timeout=%s)", readconf_printtime(ob->connect_timeout));
 520           debug_printf("\n");
 521           }
 522         (void)close(sock);
 523         sock = -1;
 524         errno = save_errno;
 525         }
 526     }
 527   return sock;
 528   }
 529 #endif
 530
 531 return smtp_sock_connect(sc, ob->connect_timeout, early_data);
 532 }
 533
 534
 535 /*************************************************
 536 *        Flush outgoing command buffer           *
 537 *************************************************/
 538
 539 /* This function is called only from smtp_write_command() below. It flushes
 540 the buffer of outgoing commands. There is more than one in the buffer only when
 541 pipelining.
 542
 543 Argument:
 544   outblock   the SMTP output block
 545   mode       further data expected, or plain
 546
 547 Returns:     TRUE if OK, FALSE on error, with errno set
 548 */
 549
 550 static BOOL
 551 flush_buffer(smtp_outblock * outblock, int mode)
 552 {
 553 int rc;
 554 int n = outblock->ptr - outblock->buffer;
 555 BOOL more = mode == SCMD_MORE;
 556 client_conn_ctx * cctx;
 557
 558 HDEBUG(D_transport|D_acl) debug_printf_indent("cmd buf flush %d bytes%s\n", n,
 559   more ? " (more expected)" : "");
 560
 561 if (!(cctx = outblock->cctx))
 562   {
 563   log_write(0, LOG_MAIN|LOG_PANIC, "null conn-context pointer");
 564   errno = 0;
 565   return FALSE;
 566   }
 567
 568 #ifndef DISABLE_TLS
 569 if (cctx->tls_ctx)              /*XXX have seen a null cctx here, rvfy sending QUIT, hence check above */
 570   rc = tls_write(cctx->tls_ctx, outblock->buffer, n, more);
 571 else
 572 #endif
 573
 574   {
 575   if (outblock->conn_args)
 576     {
 577     blob early_data = { .data = outblock->buffer, .len = n };
 578
 579     /* We ignore the more-flag if we're doing a connect with early-data, which
 580     means we won't get BDAT+data. A pity, but wise due to the idempotency
 581     requirement: TFO with data can, in rare cases, replay the data to the
 582     receiver. */
 583
 584     if (  (cctx->sock = smtp_connect(outblock->conn_args, &early_data))
 585        < 0)
 586       return FALSE;
 587     outblock->conn_args = NULL;
 588     rc = n;
 589     }
 590   else
 591     {
 592     rc = send(cctx->sock, outblock->buffer, n,
 593 #ifdef MSG_MORE
 594               more ? MSG_MORE : 0
 595 #else
 596               0
 597 #endif
 598              );
 599
 600 #if defined(__linux__)
 601     /* This is a workaround for a current linux kernel bug: as of
 602     5.6.8-200.fc31.x86_64  small (<MSS) writes get delayed by about 200ms,
 603     This is despite NODELAY being active.
 604     https://bugzilla.redhat.com/show_bug.cgi?id=1803806 */
 605
 606     if (!more)
 607       setsockopt(cctx->sock, IPPROTO_TCP, TCP_CORK, &off, sizeof(off));
 608 #endif
 609     }
 610   }
 611
 612 if (rc <= 0)
 613   {
 614   HDEBUG(D_transport|D_acl) debug_printf_indent("send failed: %s\n", strerror(errno));
 615   return FALSE;
 616   }
 617
 618 outblock->ptr = outblock->buffer;
 619 outblock->cmd_count = 0;
 620 return TRUE;
 621 }
 622
 623
 624
 625 /* This might be called both due to callout and then from delivery.
 626 Use memory that will not be released between those phases.
 627 */
 628 static void
 629 smtp_debug_resp(const uschar * buf)
 630 {
 631 #ifndef DISABLE_CLIENT_CMD_LOG
 632 int old_pool = store_pool;
 633 store_pool = POOL_PERM;
 634 client_cmd_log = string_append_listele_n(client_cmd_log, ':', buf,
 635   buf[3] == ' ' ? 3 : 4);
 636 store_pool = old_pool;
 637 #endif
 638 }
 639
 640
 641 /*************************************************
 642 *             Write SMTP command                 *
 643 *************************************************/
 644
 645 /* The formatted command is left in big_buffer so that it can be reflected in
 646 any error message.
 647
 648 Arguments:
 649   sx         SMTP connection, contains buffer for pipelining, and socket
 650   mode       buffer, write-with-more-likely, write
 651   format     a format, starting with one of
 652              of HELO, MAIL FROM, RCPT TO, DATA, ".", or QUIT.
 653              If NULL, flush pipeline buffer only.
 654   ...        data for the format
 655
 656 Returns:     0 if command added to pipelining buffer, with nothing transmitted
 657             +n if n commands transmitted (may still have buffered the new one)
 658             -1 on error, with errno set
 659 */
 660
 661 int
 662 smtp_write_command(void * sx, int mode, const char * format, ...)
 663 {
 664 smtp_outblock * outblock = &((smtp_context *)sx)->outblock;
 665 int rc = 0;
 666
 667 if (format)
 668   {
 669   gstring gs = { .size = big_buffer_size, .ptr = 0, .s = big_buffer };
 670   va_list ap;
 671
 672   /* Use taint-unchecked routines for writing into big_buffer, trusting that
 673   we'll never expand the results.  Actually, the error-message use - leaving
 674   the results in big_buffer for potential later use - is uncomfortably distant.
 675   XXX Would be better to assume all smtp commands are short, use normal pool
 676   alloc rather than big_buffer, and another global for the data-for-error. */
 677
 678   va_start(ap, format);
 679   if (!string_vformat(&gs, SVFMT_TAINT_NOCHK, CS format, ap))
 680     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "overlong write_command in outgoing "
 681       "SMTP");
 682   va_end(ap);
 683   string_from_gstring(&gs);
 684
 685   if (gs.ptr > outblock->buffersize)
 686     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "overlong write_command in outgoing "
 687       "SMTP");
 688
 689   if (gs.ptr > outblock->buffersize - (outblock->ptr - outblock->buffer))
 690     {
 691     rc = outblock->cmd_count;                 /* flush resets */
 692     if (!flush_buffer(outblock, SCMD_FLUSH)) return -1;
 693     }
 694
 695   Ustrncpy(outblock->ptr, gs.s, gs.ptr);
 696   outblock->ptr += gs.ptr;
 697   outblock->cmd_count++;
 698   gs.ptr -= 2; string_from_gstring(&gs); /* remove \r\n for error message */
 699
 700   /* We want to hide the actual data sent in AUTH transactions from reflections
 701   and logs. While authenticating, a flag is set in the outblock to enable this.
 702   The AUTH command itself gets any data flattened. Other lines are flattened
 703   completely. */
 704
 705   if (outblock->authenticating)
 706     {
 707     uschar *p = big_buffer;
 708     if (Ustrncmp(big_buffer, "AUTH ", 5) == 0)
 709       {
 710       p += 5;
 711       while (isspace(*p)) p++;
 712       while (!isspace(*p)) p++;
 713       while (isspace(*p)) p++;
 714       }
 715     while (*p) *p++ = '*';
 716     }
 717
 718   smtp_debug_cmd(big_buffer, mode);
 719   }
 720
 721 if (mode != SCMD_BUFFER)
 722   {
 723   rc += outblock->cmd_count;                /* flush resets */
 724   if (!flush_buffer(outblock, mode)) return -1;
 725   }
 726
 727 return rc;
 728 }
 729
 730
 731
 732 /*************************************************
 733 *          Read one line of SMTP response        *
 734 *************************************************/
 735
 736 /* This function reads one line of SMTP response from the server host. This may
 737 not be a complete response - it could be just part of a multiline response. We
 738 have to use a buffer for incoming packets, because when pipelining or using
 739 LMTP, there may well be more than one response in a single packet. This
 740 function is called only from the one that follows.
 741
 742 Arguments:
 743   inblock   the SMTP input block (contains holding buffer, socket, etc.)
 744   buffer    where to put the line
 745   size      space available for the line
 746   timelimit deadline for reading the lime, seconds past epoch
 747
 748 Returns:    length of a line that has been put in the buffer
 749             -1 otherwise, with errno set, and inblock->ptr adjusted
 750 */
 751
 752 static int
 753 read_response_line(smtp_inblock *inblock, uschar *buffer, int size, time_t timelimit)
 754 {
 755 uschar *p = buffer;
 756 uschar *ptr = inblock->ptr;
 757 uschar *ptrend = inblock->ptrend;
 758 client_conn_ctx * cctx = inblock->cctx;
 759
 760 /* Loop for reading multiple packets or reading another packet after emptying
 761 a previously-read one. */
 762
 763 for (;;)
 764   {
 765   int rc;
 766
 767   /* If there is data in the input buffer left over from last time, copy
 768   characters from it until the end of a line, at which point we can return,
 769   having removed any whitespace (which will include CR) at the end of the line.
 770   The rules for SMTP say that lines end in CRLF, but there are have been cases
 771   of hosts using just LF, and other MTAs are reported to handle this, so we
 772   just look for LF. If we run out of characters before the end of a line,
 773   carry on to read the next incoming packet. */
 774
 775   while (ptr < ptrend)
 776     {
 777     int c = *ptr++;
 778     if (c == '\n')
 779       {
 780       while (p > buffer && isspace(p[-1])) p--;
 781       *p = 0;
 782       inblock->ptr = ptr;
 783       return p - buffer;
 784       }
 785     *p++ = c;
 786     if (--size < 4)
 787       {
 788       *p = 0;                     /* Leave malformed line for error message */
 789       errno = ERRNO_SMTPFORMAT;
 790       inblock->ptr = ptr;
 791       return -1;
 792       }
 793     }
 794
 795   /* Need to read a new input packet. */
 796
 797   if((rc = ip_recv(cctx, inblock->buffer, inblock->buffersize, timelimit)) <= 0)
 798     {
 799     DEBUG(D_deliver|D_transport|D_acl|D_v)
 800       debug_printf_indent(errno ? "  SMTP(%s)<<\n" : "  SMTP(closed)<<\n",
 801         strerror(errno));
 802     break;
 803     }
 804
 805   /* Another block of data has been successfully read. Set up the pointers
 806   and let the loop continue. */
 807
 808   ptrend = inblock->ptrend = inblock->buffer + rc;
 809   ptr = inblock->buffer;
 810   DEBUG(D_transport|D_acl) debug_printf_indent("read response data: size=%d\n", rc);
 811   }
 812
 813 /* Get here if there has been some kind of recv() error; errno is set, but we
 814 ensure that the result buffer is empty before returning. */
 815
 816 inblock->ptr = inblock->ptrend = inblock->buffer;
 817 *buffer = 0;
 818 return -1;
 819 }
 820
 821
 822
 823
 824
 825 /*************************************************
 826 *              Read SMTP response                *
 827 *************************************************/
 828
 829 /* This function reads an SMTP response with a timeout, and returns the
 830 response in the given buffer, as a string. A multiline response will contain
 831 newline characters between the lines. The function also analyzes the first
 832 digit of the reply code and returns FALSE if it is not acceptable. FALSE is
 833 also returned after a reading error. In this case buffer[0] will be zero, and
 834 the error code will be in errno.
 835
 836 Arguments:
 837   sx        the SMTP connection (contains input block with holding buffer,
 838                 socket, etc.)
 839   buffer    where to put the response
 840   size      the size of the buffer
 841   okdigit   the expected first digit of the response
 842   timeout   the timeout to use, in seconds
 843
 844 Returns:    TRUE if a valid, non-error response was received; else FALSE
 845 */
 846 /*XXX could move to smtp transport; no other users */
 847
 848 BOOL
 849 smtp_read_response(void * sx0, uschar * buffer, int size, int okdigit,
 850    int timeout)
 851 {
 852 smtp_context * sx = sx0;
 853 uschar * ptr = buffer;
 854 int count = 0;
 855 time_t timelimit = time(NULL) + timeout;
 856 BOOL yield = FALSE;
 857
 858 errno = 0;  /* Ensure errno starts out zero */
 859 buffer[0] = '\0';
 860
 861 #ifndef DISABLE_PIPE_CONNECT
 862 if (sx->pending_BANNER || sx->pending_EHLO)
 863   {
 864   int rc;
 865   if ((rc = smtp_reap_early_pipe(sx, &count)) != OK)
 866     {
 867     DEBUG(D_transport) debug_printf("failed reaping pipelined cmd responsess\n");
 868     if (rc == DEFER) errno = ERRNO_TLSFAILURE;
 869     goto out;
 870     }
 871   }
 872 #endif
 873
 874 /* This is a loop to read and concatenate the lines that make up a multi-line
 875 response. */
 876
 877 for (;;)
 878   {
 879   if ((count = read_response_line(&sx->inblock, ptr, size, timelimit)) < 0)
 880     return FALSE;
 881
 882   HDEBUG(D_transport|D_acl|D_v)
 883     debug_printf_indent("  %s %s\n", ptr == buffer ? "SMTP<<" : "      ", ptr);
 884
 885   /* Check the format of the response: it must start with three digits; if
 886   these are followed by a space or end of line, the response is complete. If
 887   they are followed by '-' this is a multi-line response and we must look for
 888   another line until the final line is reached. The only use made of multi-line
 889   responses is to pass them back as error messages. We therefore just
 890   concatenate them all within the buffer, which should be large enough to
 891   accept any reasonable number of lines. */
 892
 893   if (count < 3 ||
 894      !isdigit(ptr[0]) ||
 895      !isdigit(ptr[1]) ||
 896      !isdigit(ptr[2]) ||
 897      (ptr[3] != '-' && ptr[3] != ' ' && ptr[3] != 0))
 898     {
 899     errno = ERRNO_SMTPFORMAT;    /* format error */
 900     goto out;
 901     }
 902
 903   /* If the line we have just read is a terminal line, line, we are done.
 904   Otherwise more data has to be read. */
 905
 906   if (ptr[3] != '-') break;
 907
 908   /* Move the reading pointer upwards in the buffer and insert \n between the
 909   components of a multiline response. Space is left for this by read_response_
 910   line(). */
 911
 912   ptr += count;
 913   *ptr++ = '\n';
 914   size -= count + 1;
 915   }
 916
 917 #ifdef TCP_FASTOPEN
 918 tfo_out_check(sx->cctx.sock);
 919 #endif
 920
 921 /* Return a value that depends on the SMTP return code. On some systems a
 922 non-zero value of errno has been seen at this point, so ensure it is zero,
 923 because the caller of this function looks at errno when FALSE is returned, to
 924 distinguish between an unexpected return code and other errors such as
 925 timeouts, lost connections, etc. */
 926
 927 errno = 0;
 928 yield = buffer[0] == okdigit;
 929
 930 out:
 931   smtp_debug_resp(buffer);
 932   return yield;
 933 }
 934
 935 /* End of smtp_out.c */
 936 /* vi: aw ai sw=2
 937 */