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