src/src/smtp_out.c

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