src/src/smtp_out.c

   1 /*************************************************
   2 *     Exim - an Internet mail transport agent    *
   3 *************************************************/
   4
   5 /* Copyright (c) The Exim Maintainers 2020 - 2023 */
   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 GET_OPTION("dscp");
 282 if (dscp && dscp_lookup(dscp, sc->host_af, &dscp_level, &dscp_option, &dscp_value))
 283   {
 284   HDEBUG(D_transport|D_acl|D_v)
 285     debug_printf_indent("DSCP \"%s\"=%x ", dscp, dscp_value);
 286   if (setsockopt(sock, dscp_level, dscp_option, &dscp_value, sizeof(dscp_value)) < 0)
 287     HDEBUG(D_transport|D_acl|D_v)
 288       debug_printf_indent("failed to set DSCP: %s ", strerror(errno));
 289   /* If the kernel supports IPv4 and IPv6 on an IPv6 socket, we need to set the
 290   option for both; ignore failures here */
 291   if (sc->host_af == AF_INET6 &&
 292       dscp_lookup(dscp, AF_INET, &dscp_level, &dscp_option, &dscp_value))
 293     (void) setsockopt(sock, dscp_level, dscp_option, &dscp_value, sizeof(dscp_value));
 294   }
 295
 296 /* Bind to a specific interface if requested. Caller must ensure the interface
 297 is the same type (IPv4 or IPv6) as the outgoing address. */
 298
 299 if (sc->interface)
 300   {
 301   union sockaddr_46 interface_sock;
 302   EXIM_SOCKLEN_T size = sizeof(interface_sock);
 303
 304   if (  ip_bind(sock, sc->host_af, sc->interface, 0) < 0
 305      || getsockname(sock, (struct sockaddr *) &interface_sock, &size) < 0
 306      )
 307     {
 308     HDEBUG(D_transport|D_acl|D_v)
 309       debug_printf_indent("unable to bind outgoing SMTP call to %s: %s\n", sc->interface,
 310         strerror(errno));
 311     close(sock);
 312     return -1;
 313     }
 314   sending_ip_address = host_ntoa(-1, &interface_sock, NULL, &sending_port);
 315   }
 316
 317 sc->sock = sock;
 318 return sock;
 319 }
 320
 321
 322 /* Arguments:
 323   host        host item containing name and address and port
 324   host_af     AF_INET or AF_INET6
 325   port        TCP port number
 326   interface   outgoing interface address or NULL
 327   tb          transport
 328   timeout     timeout value or 0
 329   early_data    if non-NULL, idempotent data to be sent -
 330                 preferably in the TCP SYN segment
 331               Special case: non-NULL but with NULL blob.data - caller is
 332               client-data-first (eg. TLS-on-connect) and a lazy-TCP-connect is
 333               acceptable.
 334
 335 Returns:      connected socket number, or -1 with errno set
 336 */
 337
 338 int
 339 smtp_sock_connect(smtp_connect_args * sc, int timeout, const blob * early_data)
 340 {
 341 smtp_transport_options_block * ob =
 342   (smtp_transport_options_block *)sc->tblock->options_block;
 343 int sock;
 344 int save_errno = 0;
 345 const blob * fastopen_blob = NULL;
 346
 347
 348 #ifndef DISABLE_EVENT
 349 deliver_host_address = sc->host->address;
 350 deliver_host_port = sc->host->port;
 351 if (event_raise(sc->tblock->event_action, US"tcp:connect", NULL, &errno)) return -1;
 352 #endif
 353
 354 if (  (sock = sc->sock) < 0
 355    && (sock = smtp_boundsock(sc)) < 0)
 356   save_errno = errno;
 357 sc->sock = -1;
 358
 359 /* Connect to the remote host, and add keepalive to the socket before returning
 360 it, if requested.  If the build supports TFO, request it - and if the caller
 361 requested some early-data then include that in the TFO request.  If there is
 362 early-data but no TFO support, send it after connecting. */
 363
 364 if (!save_errno)
 365   {
 366 #ifdef TCP_FASTOPEN
 367   /* See if TCP Fast Open usable.  Default is a traditional 3WHS connect */
 368   if (verify_check_given_host(CUSS &ob->hosts_try_fastopen, sc->host) == OK)
 369     {
 370     if (!early_data)
 371       fastopen_blob = &tcp_fastopen_nodata;     /* TFO, with no data */
 372     else if (early_data->data)
 373       fastopen_blob = early_data;               /* TFO, with data */
 374 # ifdef TCP_FASTOPEN_CONNECT
 375     else
 376       {                                         /* expecting client data */
 377       DEBUG(D_transport|D_acl|D_v) debug_printf(" set up lazy-connect\n");
 378       setsockopt(sock, IPPROTO_TCP, TCP_FASTOPEN_CONNECT, US &on, sizeof(on));
 379       /* fastopen_blob = NULL;           lazy TFO, triggered by data write */
 380       }
 381 # endif
 382     }
 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... ", 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 rc;
 555 int n = outblock->ptr - outblock->buffer;
 556 BOOL more = mode == SCMD_MORE;
 557 client_conn_ctx * cctx;
 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 if (cctx->tls_ctx)              /*XXX have seen a null cctx here, rvfy sending QUIT, hence check above */
 571   rc = tls_write(cctx->tls_ctx, outblock->buffer, n, more);
 572 else
 573 #endif
 574
 575   {
 576   if (outblock->conn_args)
 577     {
 578     blob early_data = { .data = outblock->buffer, .len = n };
 579
 580     /* We ignore the more-flag if we're doing a connect with early-data, which
 581     means we won't get BDAT+data. A pity, but wise due to the idempotency
 582     requirement: TFO with data can, in rare cases, replay the data to the
 583     receiver. */
 584
 585     if (  (cctx->sock = smtp_connect(outblock->conn_args, &early_data))
 586        < 0)
 587       return FALSE;
 588     outblock->conn_args = NULL;
 589     rc = n;
 590     }
 591   else
 592     {
 593     rc = send(cctx->sock, outblock->buffer, n,
 594 #ifdef MSG_MORE
 595               more ? MSG_MORE : 0
 596 #else
 597               0
 598 #endif
 599              );
 600
 601 #if defined(__linux__)
 602     /* This is a workaround for a current linux kernel bug: as of
 603     5.6.8-200.fc31.x86_64  small (<MSS) writes get delayed by about 200ms,
 604     This is despite NODELAY being active.
 605     https://bugzilla.redhat.com/show_bug.cgi?id=1803806 */
 606
 607     if (!more)
 608       setsockopt(cctx->sock, IPPROTO_TCP, TCP_CORK, &off, sizeof(off));
 609 #endif
 610     }
 611   }
 612
 613 if (rc <= 0)
 614   {
 615   HDEBUG(D_transport|D_acl) debug_printf_indent("send failed: %s\n", strerror(errno));
 616   return FALSE;
 617   }
 618
 619 outblock->ptr = outblock->buffer;
 620 outblock->cmd_count = 0;
 621 return TRUE;
 622 }
 623
 624
 625
 626 /* This might be called both due to callout and then from delivery.
 627 Use memory that will not be released between those phases.
 628 */
 629 static void
 630 smtp_debug_resp(const uschar * buf)
 631 {
 632 #ifndef DISABLE_CLIENT_CMD_LOG
 633 int old_pool = store_pool;
 634 store_pool = POOL_PERM;
 635 client_cmd_log = string_append_listele_n(client_cmd_log, ':', buf,
 636   buf[3] == ' ' ? 3 : 4);
 637 store_pool = old_pool;
 638 #endif
 639 }
 640
 641
 642 /*************************************************
 643 *             Write SMTP command                 *
 644 *************************************************/
 645
 646 /* The formatted command is left in big_buffer so that it can be reflected in
 647 any error message.
 648
 649 Arguments:
 650   sx         SMTP connection, contains buffer for pipelining, and socket
 651   mode       buffer, write-with-more-likely, write
 652   format     a format, starting with one of
 653              of HELO, MAIL FROM, RCPT TO, DATA, BDAT, ".", or QUIT.
 654              If NULL, flush pipeline buffer only.
 655   ...        data for the format
 656
 657 Returns:     0 if command added to pipelining buffer, with nothing transmitted
 658             +n if n commands transmitted (may still have buffered the new one)
 659             -1 on error, with errno set
 660 */
 661
 662 int
 663 smtp_write_command(void * sx, int mode, const char * format, ...)
 664 {
 665 smtp_outblock * outblock = &((smtp_context *)sx)->outblock;
 666 int rc = 0;
 667
 668 if (format)
 669   {
 670   gstring gs = { .size = big_buffer_size, .ptr = 0, .s = big_buffer };
 671   va_list ap;
 672
 673   /* Use taint-unchecked routines for writing into big_buffer, trusting that
 674   we'll never expand the results.  Actually, the error-message use - leaving
 675   the results in big_buffer for potential later use - is uncomfortably distant.
 676   XXX Would be better to assume all smtp commands are short, use normal pool
 677   alloc rather than big_buffer, and another global for the data-for-error. */
 678
 679   va_start(ap, format);
 680   if (!string_vformat(&gs, SVFMT_TAINT_NOCHK, CS format, ap))
 681     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "overlong write_command in outgoing "
 682       "SMTP");
 683   va_end(ap);
 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       Uskip_whitespace(&p);
 712       Uskip_nonwhite(&p);
 713       Uskip_whitespace(&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 */