src/src/smtp_in.c

   1 /* $Cambridge: exim/src/src/smtp_in.c,v 1.1 2004/10/07 10:39:01 ph10 Exp $ */
   2
   3 /*************************************************
   4 *     Exim - an Internet mail transport agent    *
   5 *************************************************/
   6
   7 /* Copyright (c) University of Cambridge 1995 - 2004 */
   8 /* See the file NOTICE for conditions of use and distribution. */
   9
  10 /* Functions for handling an incoming SMTP call. */
  11
  12
  13 #include "exim.h"
  14
  15
  16 /* Initialize for TCP wrappers if so configured. It appears that the macro
  17 HAVE_IPV6 is used in some versions of the tcpd.h header, so we unset it before
  18 including that header, and restore its value afterwards. */
  19
  20 #ifdef USE_TCP_WRAPPERS
  21
  22   #if HAVE_IPV6
  23   #define EXIM_HAVE_IPV6
  24   #endif
  25   #undef HAVE_IPV6
  26   #include <tcpd.h>
  27   #undef HAVE_IPV6
  28   #ifdef EXIM_HAVE_IPV6
  29   #define HAVE_IPV6 TRUE
  30   #endif
  31
  32 int allow_severity = LOG_INFO;
  33 int deny_severity  = LOG_NOTICE;
  34 #endif
  35
  36
  37 /* Size of buffer for reading SMTP commands */
  38
  39 #define cmd_buffer_size  512      /* Ref. RFC 821 */
  40
  41 /* Size of buffer for reading SMTP incoming packets */
  42
  43 #define in_buffer_size  8192
  44
  45 /* Structure for SMTP command list */
  46
  47 typedef struct {
  48   char *name;
  49   int len;
  50   short int cmd;
  51   short int has_arg;
  52   short int is_mail_cmd;
  53 } smtp_cmd_list;
  54
  55 /* Codes for identifying commands. We order them so that those that come first
  56 are those for which synchronization is always required. Checking this can help
  57 block some spam.  */
  58
  59 enum {
  60   /* These commands are required to be synchronized, i.e. to be the last in a
  61   block of commands when pipelining. */
  62
  63   HELO_CMD, EHLO_CMD, DATA_CMD, /* These are listed in the pipelining */
  64   VRFY_CMD, EXPN_CMD, NOOP_CMD, /* RFC as requiring synchronization */
  65   ETRN_CMD,                     /* This by analogy with TURN from the RFC */
  66   STARTTLS_CMD,                 /* Required by the STARTTLS RFC */
  67
  68   /* This is a dummy to identify the non-sync commands when pipelining */
  69
  70   NON_SYNC_CMD_PIPELINING,
  71
  72   /* These commands need not be synchronized when pipelining */
  73
  74   MAIL_CMD, RCPT_CMD, RSET_CMD,
  75
  76   /* This is a dummy to identify the non-sync commands when not pipelining */
  77
  78   NON_SYNC_CMD_NON_PIPELINING,
  79
  80   /* I have been unable to find a statement about the use of pipelining
  81   with AUTH, so to be on the safe side it is here, though I kind of feel
  82   it should be up there with the synchronized commands. */
  83
  84   AUTH_CMD,
  85
  86   /* I'm not sure about these, but I don't think they matter. */
  87
  88   QUIT_CMD, HELP_CMD,
  89
  90   /* These are specials that don't correspond to actual commands */
  91
  92   EOF_CMD, OTHER_CMD, BADARG_CMD, BADCHAR_CMD, BADSYN_CMD,
  93   TOO_MANY_NONMAIL_CMD };
  94
  95
  96
  97 /*************************************************
  98 *                Local static variables          *
  99 *************************************************/
 100
 101 static auth_instance *authenticated_by;
 102 static BOOL auth_advertised;
 103 #ifdef SUPPORT_TLS
 104 static BOOL tls_advertised;
 105 #endif
 106 static BOOL esmtp;
 107 static BOOL helo_required = FALSE;
 108 static BOOL helo_verify = FALSE;
 109 static BOOL helo_seen;
 110 static BOOL helo_accept_junk;
 111 static BOOL count_nonmail;
 112 static BOOL pipelining_advertised;
 113 static int  nonmail_command_count;
 114 static int  synprot_error_count;
 115 static int  unknown_command_count;
 116 static int  sync_cmd_limit;
 117 static int  smtp_write_error = 0;
 118
 119 static uschar *smtp_data;
 120
 121 static uschar *cmd_buffer;
 122
 123 /* We need to know the position of RSET, HELO, EHLO, AUTH, and STARTTLS. Their
 124 final fields of all except AUTH are forced TRUE at the start of a new message
 125 setup, to allow one of each between messages that is not counted as a nonmail
 126 command. (In fact, only one of HELO/EHLO is not counted.) Also, we have to
 127 allow a new EHLO after starting up TLS.
 128
 129 AUTH is "falsely" labelled as a mail command initially, so that it doesn't get
 130 counted. However, the flag is changed when AUTH is received, so that multiple
 131 failing AUTHs will eventually hit the limit. After a successful AUTH, another
 132 AUTH is already forbidden. After a TLS session is started, AUTH's flag is again
 133 forced TRUE, to allow for the re-authentication that can happen at that point.
 134
 135 QUIT is also "falsely" labelled as a mail command so that it doesn't up the
 136 count of non-mail commands and possibly provoke an error. */
 137
 138 static smtp_cmd_list cmd_list[] = {
 139   { "rset",       sizeof("rset")-1,       RSET_CMD, FALSE, FALSE },  /* First */
 140   { "helo",       sizeof("helo")-1,       HELO_CMD, TRUE,  FALSE },
 141   { "ehlo",       sizeof("ehlo")-1,       EHLO_CMD, TRUE,  FALSE },
 142   { "auth",       sizeof("auth")-1,       AUTH_CMD, TRUE,  TRUE  },
 143   #ifdef SUPPORT_TLS
 144   { "starttls",   sizeof("starttls")-1,   STARTTLS_CMD, FALSE, FALSE },
 145   #endif
 146
 147 /* If you change anything above here, also fix the definitions below. */
 148
 149   { "mail from:", sizeof("mail from:")-1, MAIL_CMD, TRUE,  TRUE  },
 150   { "rcpt to:",   sizeof("rcpt to:")-1,   RCPT_CMD, TRUE,  TRUE  },
 151   { "data",       sizeof("data")-1,       DATA_CMD, FALSE, TRUE  },
 152   { "quit",       sizeof("quit")-1,       QUIT_CMD, FALSE, TRUE  },
 153   { "noop",       sizeof("noop")-1,       NOOP_CMD, TRUE,  FALSE },
 154   { "etrn",       sizeof("etrn")-1,       ETRN_CMD, TRUE,  FALSE },
 155   { "vrfy",       sizeof("vrfy")-1,       VRFY_CMD, TRUE,  FALSE },
 156   { "expn",       sizeof("expn")-1,       EXPN_CMD, TRUE,  FALSE },
 157   { "help",       sizeof("help")-1,       HELP_CMD, TRUE,  FALSE }
 158 };
 159
 160 static smtp_cmd_list *cmd_list_end =
 161   cmd_list + sizeof(cmd_list)/sizeof(smtp_cmd_list);
 162
 163 #define CMD_LIST_RSET      0
 164 #define CMD_LIST_HELO      1
 165 #define CMD_LIST_EHLO      2
 166 #define CMD_LIST_AUTH      3
 167 #define CMD_LIST_STARTTLS  4
 168
 169 static uschar *protocols[] = {
 170   US"local-smtp",
 171   US"local-esmtp",
 172   US"local-esmtpa",
 173   US"local-esmtps",
 174   US"local-esmtpsa"
 175   };
 176
 177 #define pnormal  0
 178 #define pextend  1
 179 #define pauthed  1  /* added to pextend */
 180 #define pcrpted  2  /* added to pextend */
 181 #define pnlocal  6  /* offset to remove "local" */
 182
 183 /* When reading SMTP from a remote host, we have to use our own versions of the
 184 C input-reading functions, in order to be able to flush the SMTP output only
 185 when about to read more data from the socket. This is the only way to get
 186 optimal performance when the client is using pipelining. Flushing for every
 187 command causes a separate packet and reply packet each time; saving all the
 188 responses up (when pipelining) combines them into one packet and one response.
 189
 190 For simplicity, these functions are used for *all* SMTP input, not only when
 191 receiving over a socket. However, after setting up a secure socket (SSL), input
 192 is read via the OpenSSL library, and another set of functions is used instead
 193 (see tls.c).
 194
 195 These functions are set in the receive_getc etc. variables and called with the
 196 same interface as the C functions. However, since there can only ever be
 197 one incoming SMTP call, we just use a single buffer and flags. There is no need
 198 to implement a complicated private FILE-like structure.*/
 199
 200 static uschar *smtp_inbuffer;
 201 static uschar *smtp_inptr;
 202 static uschar *smtp_inend;
 203 static int     smtp_had_eof;
 204 static int     smtp_had_error;
 205
 206
 207 /*************************************************
 208 *          SMTP version of getc()                *
 209 *************************************************/
 210
 211 /* This gets the next byte from the SMTP input buffer. If the buffer is empty,
 212 it flushes the output, and refills the buffer, with a timeout. The signal
 213 handler is set appropriately by the calling function. This function is not used
 214 after a connection has negotated itself into an TLS/SSL state.
 215
 216 Arguments:  none
 217 Returns:    the next character or EOF
 218 */
 219
 220 int
 221 smtp_getc(void)
 222 {
 223 if (smtp_inptr >= smtp_inend)
 224   {
 225   int rc, save_errno;
 226   fflush(smtp_out);
 227   if (smtp_receive_timeout > 0) alarm(smtp_receive_timeout);
 228   rc = read(fileno(smtp_in), smtp_inbuffer, in_buffer_size);
 229   save_errno = errno;
 230   alarm(0);
 231   if (rc <= 0)
 232     {
 233     /* Must put the error text in fixed store, because this might be during
 234     header reading, where it releases unused store above the header. */
 235     if (rc < 0)
 236       {
 237       smtp_had_error = save_errno;
 238       smtp_read_error = string_copy_malloc(
 239         string_sprintf(" (error: %s)", strerror(save_errno)));
 240       }
 241     else smtp_had_eof = 1;
 242     return EOF;
 243     }
 244   smtp_inend = smtp_inbuffer + rc;
 245   smtp_inptr = smtp_inbuffer;
 246   }
 247 return *smtp_inptr++;
 248 }
 249
 250
 251
 252 /*************************************************
 253 *          SMTP version of ungetc()              *
 254 *************************************************/
 255
 256 /* Puts a character back in the input buffer. Only ever
 257 called once.
 258
 259 Arguments:
 260   ch           the character
 261
 262 Returns:       the character
 263 */
 264
 265 int
 266 smtp_ungetc(int ch)
 267 {
 268 *(--smtp_inptr) = ch;
 269 return ch;
 270 }
 271
 272
 273
 274
 275 /*************************************************
 276 *          SMTP version of feof()                *
 277 *************************************************/
 278
 279 /* Tests for a previous EOF
 280
 281 Arguments:     none
 282 Returns:       non-zero if the eof flag is set
 283 */
 284
 285 int
 286 smtp_feof(void)
 287 {
 288 return smtp_had_eof;
 289 }
 290
 291
 292
 293
 294 /*************************************************
 295 *          SMTP version of ferror()              *
 296 *************************************************/
 297
 298 /* Tests for a previous read error, and returns with errno
 299 restored to what it was when the error was detected.
 300
 301 Arguments:     none
 302 Returns:       non-zero if the error flag is set
 303 */
 304
 305 int
 306 smtp_ferror(void)
 307 {
 308 errno = smtp_had_error;
 309 return smtp_had_error;
 310 }
 311
 312
 313
 314
 315 /*************************************************
 316 *     Write formatted string to SMTP channel     *
 317 *************************************************/
 318
 319 /* This is a separate function so that we don't have to repeat everything for
 320 TLS support or debugging. It is global so that the daemon and the
 321 authentication functions can use it. It does not return any error indication,
 322 because major problems such as dropped connections won't show up till an output
 323 flush for non-TLS connections. The smtp_fflush() function is available for
 324 checking that: for convenience, TLS output errors are remembered here so that
 325 they are also picked up later by smtp_fflush().
 326
 327 Arguments:
 328   format      format string
 329   ...         optional arguments
 330
 331 Returns:      nothing
 332 */
 333
 334 void
 335 smtp_printf(char *format, ...)
 336 {
 337 va_list ap;
 338
 339 DEBUG(D_receive)
 340   {
 341   va_start(ap, format);
 342   (void) string_vformat(big_buffer, big_buffer_size, format, ap);
 343   debug_printf("SMTP>> %s", big_buffer);
 344   }
 345
 346 va_start(ap, format);
 347
 348 /* If in a TLS session we have to format the string, and then write it using a
 349 TLS function. */
 350
 351 #ifdef SUPPORT_TLS
 352 if (tls_active >= 0)
 353   {
 354   if (!string_vformat(big_buffer, big_buffer_size, format, ap))
 355     {
 356     log_write(0, LOG_MAIN|LOG_PANIC, "string too large in smtp_printf");
 357     smtp_closedown(US"Unexpected error");
 358     exim_exit(EXIT_FAILURE);
 359     }
 360   if (tls_write(big_buffer, Ustrlen(big_buffer)) < 0) smtp_write_error = -1;
 361   }
 362 else
 363 #endif
 364
 365 /* Otherwise, just use the standard library function. */
 366
 367 if (vfprintf(smtp_out, format, ap) < 0) smtp_write_error = -1;
 368 va_end(ap);
 369 }
 370
 371
 372
 373 /*************************************************
 374 *        Flush SMTP out and check for error      *
 375 *************************************************/
 376
 377 /* This function isn't currently used within Exim (it detects errors when it
 378 tries to read the next SMTP input), but is available for use in local_scan().
 379 For non-TLS connections, it flushes the output and checks for errors. For
 380 TLS-connections, it checks for a previously-detected TLS write error.
 381
 382 Arguments:  none
 383 Returns:    0 for no error; -1 after an error
 384 */
 385
 386 int
 387 smtp_fflush(void)
 388 {
 389 if (tls_active < 0 && fflush(smtp_out) != 0) smtp_write_error = -1;
 390 return smtp_write_error;
 391 }
 392
 393
 394
 395 /*************************************************
 396 *          SMTP command read timeout             *
 397 *************************************************/
 398
 399 /* Signal handler for timing out incoming SMTP commands. This attempts to
 400 finish off tidily.
 401
 402 Argument: signal number (SIGALRM)
 403 Returns:  nothing
 404 */
 405
 406 static void
 407 command_timeout_handler(int sig)
 408 {
 409 sig = sig;    /* Keep picky compilers happy */
 410 log_write(L_lost_incoming_connection,
 411           LOG_MAIN, "SMTP command timeout on%s connection from %s",
 412           (tls_active >= 0)? " TLS" : "",
 413           host_and_ident(FALSE));
 414 if (smtp_batched_input)
 415   moan_smtp_batch(NULL, "421 SMTP command timeout");  /* Does not return */
 416 smtp_printf("421 %s: SMTP command timeout - closing connection\r\n",
 417   smtp_active_hostname);
 418 mac_smtp_fflush();
 419 exim_exit(EXIT_FAILURE);
 420 }
 421
 422
 423
 424 /*************************************************
 425 *               SIGTERM received                 *
 426 *************************************************/
 427
 428 /* Signal handler for handling SIGTERM. Again, try to finish tidily.
 429
 430 Argument: signal number (SIGTERM)
 431 Returns:  nothing
 432 */
 433
 434 static void
 435 command_sigterm_handler(int sig)
 436 {
 437 sig = sig;    /* Keep picky compilers happy */
 438 log_write(0, LOG_MAIN, "%s closed after SIGTERM", smtp_get_connection_info());
 439 if (smtp_batched_input)
 440   moan_smtp_batch(NULL, "421 SIGTERM received");  /* Does not return */
 441 smtp_printf("421 %s: Service not available - closing connection\r\n",
 442   smtp_active_hostname);
 443 exim_exit(EXIT_FAILURE);
 444 }
 445
 446
 447
 448 /*************************************************
 449 *           Read one command line                *
 450 *************************************************/
 451
 452 /* Strictly, SMTP commands coming over the net are supposed to end with CRLF.
 453 There are sites that don't do this, and in any case internal SMTP probably
 454 should check only for LF. Consequently, we check here for LF only. The line
 455 ends up with [CR]LF removed from its end. If we get an overlong line, treat as
 456 an unknown command. The command is read into the static cmd_buffer.
 457
 458 The character reading routine sets up a timeout for each block actually read
 459 from the input (which may contain more than one command). We set up a special
 460 signal handler that closes down the session on a timeout. Control does not
 461 return when it runs.
 462
 463 Arguments:
 464   check_sync   if TRUE, check synchronization rules if global option is TRUE
 465
 466 Returns:       a code identifying the command (enumerated above)
 467 */
 468
 469 static int
 470 smtp_read_command(BOOL check_sync)
 471 {
 472 int c;
 473 int ptr = 0;
 474 smtp_cmd_list *p;
 475 BOOL hadnull = FALSE;
 476
 477 os_non_restarting_signal(SIGALRM, command_timeout_handler);
 478
 479 while ((c = (receive_getc)()) != '\n' && c != EOF)
 480   {
 481   if (ptr >= cmd_buffer_size)
 482     {
 483     os_non_restarting_signal(SIGALRM, sigalrm_handler);
 484     return OTHER_CMD;
 485     }
 486   if (c == 0)
 487     {
 488     hadnull = TRUE;
 489     c = '?';
 490     }
 491   cmd_buffer[ptr++] = c;
 492   }
 493
 494 receive_linecount++;    /* For BSMTP errors */
 495 os_non_restarting_signal(SIGALRM, sigalrm_handler);
 496
 497 /* If hit end of file, return pseudo EOF command. Whether we have a
 498 part-line already read doesn't matter, since this is an error state. */
 499
 500 if (c == EOF) return EOF_CMD;
 501
 502 /* Remove any CR and white space at the end of the line, and terminate the
 503 string. */
 504
 505 while (ptr > 0 && isspace(cmd_buffer[ptr-1])) ptr--;
 506 cmd_buffer[ptr] = 0;
 507
 508 DEBUG(D_receive) debug_printf("SMTP<< %s\n", cmd_buffer);
 509
 510 /* NULLs are not allowed in SMTP commands */
 511
 512 if (hadnull) return BADCHAR_CMD;
 513
 514 /* Scan command list and return identity, having set the data pointer
 515 to the start of the actual data characters. Check for SMTP synchronization
 516 if required. */
 517
 518 for (p = cmd_list; p < cmd_list_end; p++)
 519   {
 520   if (strncmpic(cmd_buffer, US p->name, p->len) == 0)
 521     {
 522     if (smtp_inptr < smtp_inend &&                     /* Outstanding input */
 523         p->cmd < sync_cmd_limit &&                     /* Command should sync */
 524         check_sync &&                                  /* Local flag set */
 525         smtp_enforce_sync &&                           /* Global flag set */
 526         sender_host_address != NULL &&                 /* Not local input */
 527         !sender_host_notsocket)                        /* Really is a socket */
 528       return BADSYN_CMD;
 529
 530     /* Point after the command, but don't skip over leading spaces till after
 531     the following test, so that if it fails, the command name can easily be
 532     logged. */
 533
 534     smtp_data = cmd_buffer + p->len;
 535
 536     /* Count non-mail commands from those hosts that are controlled in this
 537     way. The default is all hosts. We don't waste effort checking the list
 538     until we get a non-mail command, but then cache the result to save checking
 539     again. If there's a DEFER while checking the host, assume it's in the list.
 540
 541     Note that one instance of RSET, EHLO/HELO, and STARTTLS is allowed at the
 542     start of each incoming message by fiddling with the value in the table. */
 543
 544     if (!p->is_mail_cmd)
 545       {
 546       if (count_nonmail == TRUE_UNSET) count_nonmail =
 547         verify_check_host(&smtp_accept_max_nonmail_hosts) != FAIL;
 548       if (count_nonmail && ++nonmail_command_count > smtp_accept_max_nonmail)
 549         return TOO_MANY_NONMAIL_CMD;
 550       }
 551
 552     /* Get the data pointer over leading spaces and return; if there is no data
 553     for a command that expects it, we give the error centrally here. */
 554
 555     while (isspace(*smtp_data)) smtp_data++;
 556     return (p->has_arg || *smtp_data == 0)? p->cmd : BADARG_CMD;
 557     }
 558   }
 559
 560 /* Enforce synchronization for unknown commands */
 561
 562 if (smtp_inptr < smtp_inend &&                     /* Outstanding input */
 563     check_sync &&                                  /* Local flag set */
 564     smtp_enforce_sync &&                           /* Global flag set */
 565     sender_host_address != NULL &&                 /* Not local input */
 566     !sender_host_notsocket)                        /* Really is a socket */
 567   return BADSYN_CMD;
 568
 569 return OTHER_CMD;
 570 }
 571
 572
 573
 574 /*************************************************
 575 *          Forced closedown of call              *
 576 *************************************************/
 577
 578 /* This function is called from log.c when Exim is dying because of a serious
 579 disaster, and also from some other places. If an incoming non-batched SMTP
 580 channel is open, it swallows the rest of the incoming message if in the DATA
 581 phase, sends the reply string, and gives an error to all subsequent commands
 582 except QUIT. The existence of an SMTP call is detected by the non-NULLness of
 583 smtp_in.
 584
 585 Argument:   SMTP reply string to send, excluding the code
 586 Returns:    nothing
 587 */
 588
 589 void
 590 smtp_closedown(uschar *message)
 591 {
 592 if (smtp_in == NULL || smtp_batched_input) return;
 593 receive_swallow_smtp();
 594 smtp_printf("421 %s\r\n", message);
 595
 596 for (;;)
 597   {
 598   switch(smtp_read_command(FALSE))
 599     {
 600     case EOF_CMD:
 601     return;
 602
 603     case QUIT_CMD:
 604     smtp_printf("221 %s closing connection\r\n", smtp_active_hostname);
 605     mac_smtp_fflush();
 606     return;
 607
 608     case RSET_CMD:
 609     smtp_printf("250 Reset OK\r\n");
 610     break;
 611
 612     default:
 613     smtp_printf("421 %s\r\n", message);
 614     break;
 615     }
 616   }
 617 }
 618
 619
 620
 621
 622 /*************************************************
 623 *        Set up connection info for logging      *
 624 *************************************************/
 625
 626 /* This function is called when logging information about an SMTP connection.
 627 It sets up appropriate source information, depending on the type of connection.
 628
 629 Argument:    none
 630 Returns:     a string describing the connection
 631 */
 632
 633 uschar *
 634 smtp_get_connection_info(void)
 635 {
 636 if (host_checking)
 637   return string_sprintf("SMTP connection from %s", sender_fullhost);
 638
 639 if (sender_host_unknown || sender_host_notsocket)
 640   return string_sprintf("SMTP connection from %s", sender_ident);
 641
 642 if (is_inetd)
 643   return string_sprintf("SMTP connection from %s (via inetd)", sender_fullhost);
 644
 645 if ((log_extra_selector & LX_incoming_interface) != 0 &&
 646      interface_address != NULL)
 647   return string_sprintf("SMTP connection from %s I=[%s]:%d", sender_fullhost,
 648     interface_address, interface_port);
 649
 650 return string_sprintf("SMTP connection from %s", sender_fullhost);
 651 }
 652
 653
 654
 655 /*************************************************
 656 *   Check HELO line and set sender_helo_name     *
 657 *************************************************/
 658
 659 /* Check the format of a HELO line. The data for HELO/EHLO is supposed to be
 660 the domain name of the sending host, or an ip literal in square brackets. The
 661 arrgument is placed in sender_helo_name, which is in malloc store, because it
 662 must persist over multiple incoming messages. If helo_accept_junk is set, this
 663 host is permitted to send any old junk (needed for some broken hosts).
 664 Otherwise, helo_allow_chars can be used for rogue characters in general
 665 (typically people want to let in underscores).
 666
 667 Argument:
 668   s       the data portion of the line (already past any white space)
 669
 670 Returns:  TRUE or FALSE
 671 */
 672
 673 static BOOL
 674 check_helo(uschar *s)
 675 {
 676 uschar *start = s;
 677 uschar *end = s + Ustrlen(s);
 678 BOOL yield = helo_accept_junk;
 679
 680 /* Discard any previous helo name */
 681
 682 if (sender_helo_name != NULL)
 683   {
 684   store_free(sender_helo_name);
 685   sender_helo_name = NULL;
 686   }
 687
 688 /* Skip tests if junk is permitted. */
 689
 690 if (!yield)
 691   {
 692   /* Allow the new standard form for IPv6 address literals, namely,
 693   [IPv6:....], and because someone is bound to use it, allow an equivalent
 694   IPv4 form. Allow plain addresses as well. */
 695
 696   if (*s == '[')
 697     {
 698     if (end[-1] == ']')
 699       {
 700       end[-1] = 0;
 701       if (strncmpic(s, US"[IPv6:", 6) == 0)
 702         yield = (string_is_ip_address(s+6, NULL) == 6);
 703       else if (strncmpic(s, US"[IPv4:", 6) == 0)
 704         yield = (string_is_ip_address(s+6, NULL) == 4);
 705       else
 706         yield = (string_is_ip_address(s+1, NULL) != 0);
 707       end[-1] = ']';
 708       }
 709     }
 710
 711   /* Non-literals must be alpha, dot, hyphen, plus any non-valid chars
 712   that have been configured (usually underscore - sigh). */
 713
 714   else if (*s != 0)
 715     {
 716     yield = TRUE;
 717     while (*s != 0)
 718       {
 719       if (!isalnum(*s) && *s != '.' && *s != '-' &&
 720           Ustrchr(helo_allow_chars, *s) == NULL)
 721         {
 722         yield = FALSE;
 723         break;
 724         }
 725       s++;
 726       }
 727     }
 728   }
 729
 730 /* Save argument if OK */
 731
 732 if (yield) sender_helo_name = string_copy_malloc(start);
 733 return yield;
 734 }
 735
 736
 737
 738
 739
 740 /*************************************************
 741 *         Extract SMTP command option            *
 742 *************************************************/
 743
 744 /* This function picks the next option setting off the end of smtp_data. It
 745 is called for MAIL FROM and RCPT TO commands, to pick off the optional ESMTP
 746 things that can appear there.
 747
 748 Arguments:
 749    name           point this at the name
 750    value          point this at the data string
 751
 752 Returns:          TRUE if found an option
 753 */
 754
 755 static BOOL
 756 extract_option(uschar **name, uschar **value)
 757 {
 758 uschar *n;
 759 uschar *v = smtp_data + Ustrlen(smtp_data) -1;
 760 while (isspace(*v)) v--;
 761 v[1] = 0;
 762
 763 while (v > smtp_data && *v != '=' && !isspace(*v)) v--;
 764 if (*v != '=') return FALSE;
 765
 766 n = v;
 767 while(isalpha(n[-1])) n--;
 768
 769 if (n[-1] != ' ') return FALSE;
 770
 771 n[-1] = 0;
 772 *name = n;
 773 *v++ = 0;
 774 *value = v;
 775 return TRUE;
 776 }
 777
 778
 779
 780
 781
 782
 783
 784 /*************************************************
 785 *         Reset for new message                  *
 786 *************************************************/
 787
 788 /* This function is called whenever the SMTP session is reset from
 789 within either of the setup functions.
 790
 791 Argument:   the stacking pool storage reset point
 792 Returns:    nothing
 793 */
 794
 795 static void
 796 smtp_reset(void *reset_point)
 797 {
 798 int i;
 799 store_reset(reset_point);
 800 recipients_list = NULL;
 801 rcpt_count = rcpt_defer_count = rcpt_fail_count =
 802   raw_recipients_count = recipients_count = recipients_list_max = 0;
 803 message_size = -1;
 804 acl_warn_headers = NULL;
 805 queue_only_policy = FALSE;
 806 deliver_freeze = FALSE;             /* Can be set by ACL */
 807 submission_mode = FALSE;            /* Can be set by ACL */
 808 sender_address = NULL;
 809 raw_sender = NULL;                  /* After SMTP rewrite, before qualifying */
 810 sender_address_unrewritten = NULL;  /* Set only after verify rewrite */
 811 sender_verified_list = NULL;        /* No senders verified */
 812 memset(sender_address_cache, 0, sizeof(sender_address_cache));
 813 memset(sender_domain_cache, 0, sizeof(sender_domain_cache));
 814 authenticated_sender = NULL;
 815 body_linecount = body_zerocount = 0;
 816
 817 for (i = 0; i < ACL_M_MAX; i++) acl_var[ACL_C_MAX + i] = NULL;
 818
 819 /* The message body variables use malloc store. They may be set if this is
 820 not the first message in an SMTP session and the previous message caused them
 821 to be referenced in an ACL. */
 822
 823 if (message_body != NULL)
 824   {
 825   store_free(message_body);
 826   message_body = NULL;
 827   }
 828
 829 if (message_body_end != NULL)
 830   {
 831   store_free(message_body_end);
 832   message_body_end = NULL;
 833   }
 834
 835 /* Warning log messages are also saved in malloc store. They are saved to avoid
 836 repetition in the same message, but it seems right to repeat them for different
 837 messagess. */
 838
 839 while (acl_warn_logged != NULL)
 840   {
 841   string_item *this = acl_warn_logged;
 842   acl_warn_logged = acl_warn_logged->next;
 843   store_free(this);
 844   }
 845 }
 846
 847
 848
 849
 850
 851 /*************************************************
 852 *  Initialize for incoming batched SMTP message  *
 853 *************************************************/
 854
 855 /* This function is called from smtp_setup_msg() in the case when
 856 smtp_batched_input is true. This happens when -bS is used to pass a whole batch
 857 of messages in one file with SMTP commands between them. All errors must be
 858 reported by sending a message, and only MAIL FROM, RCPT TO, and DATA are
 859 relevant. After an error on a sender, or an invalid recipient, the remainder
 860 of the message is skipped. The value of received_protocol is already set.
 861
 862 Argument: none
 863 Returns:  > 0 message successfully started (reached DATA)
 864           = 0 QUIT read or end of file reached
 865           < 0 should not occur
 866 */
 867
 868 static int
 869 smtp_setup_batch_msg(void)
 870 {
 871 int done = 0;
 872 void *reset_point = store_get(0);
 873
 874 /* Save the line count at the start of each transaction - single commands
 875 like HELO and RSET count as whole transactions. */
 876
 877 bsmtp_transaction_linecount = receive_linecount;
 878
 879 if ((receive_feof)()) return 0;   /* Treat EOF as QUIT */
 880
 881 smtp_reset(reset_point);                /* Reset for start of message */
 882
 883 /* Deal with SMTP commands. This loop is exited by setting done to a POSITIVE
 884 value. The values are 2 larger than the required yield of the function. */
 885
 886 while (done <= 0)
 887   {
 888   uschar *errmess;
 889   uschar *recipient = NULL;
 890   int start, end, sender_domain, recipient_domain;
 891
 892   switch(smtp_read_command(FALSE))
 893     {
 894     /* The HELO/EHLO commands set sender_address_helo if they have
 895     valid data; otherwise they are ignored, except that they do
 896     a reset of the state. */
 897
 898     case HELO_CMD:
 899     case EHLO_CMD:
 900
 901     check_helo(smtp_data);
 902     /* Fall through */
 903
 904     case RSET_CMD:
 905     smtp_reset(reset_point);
 906     bsmtp_transaction_linecount = receive_linecount;
 907     break;
 908
 909
 910     /* The MAIL FROM command requires an address as an operand. All we
 911     do here is to parse it for syntactic correctness. The form "<>" is
 912     a special case which converts into an empty string. The start/end
 913     pointers in the original are not used further for this address, as
 914     it is the canonical extracted address which is all that is kept. */
 915
 916     case MAIL_CMD:
 917     if (sender_address != NULL)
 918       /* The function moan_smtp_batch() does not return. */
 919       moan_smtp_batch(cmd_buffer, "503 Sender already given");
 920
 921     if (smtp_data[0] == 0)
 922       /* The function moan_smtp_batch() does not return. */
 923       moan_smtp_batch(cmd_buffer, "501 MAIL FROM must have an address operand");
 924
 925     /* Reset to start of message */
 926
 927     smtp_reset(reset_point);
 928
 929     /* Apply SMTP rewrite */
 930
 931     raw_sender = ((rewrite_existflags & rewrite_smtp) != 0)?
 932       rewrite_one(smtp_data, rewrite_smtp|rewrite_smtp_sender, NULL, FALSE,
 933         US"", global_rewrite_rules) : smtp_data;
 934
 935     /* Extract the address; the TRUE flag allows <> as valid */
 936
 937     raw_sender =
 938       parse_extract_address(raw_sender, &errmess, &start, &end, &sender_domain,
 939         TRUE);
 940
 941     if (raw_sender == NULL)
 942       /* The function moan_smtp_batch() does not return. */
 943       moan_smtp_batch(cmd_buffer, "501 %s", errmess);
 944
 945     sender_address = string_copy(raw_sender);
 946
 947     /* Qualify unqualified sender addresses if permitted to do so. */
 948
 949     if (sender_domain == 0 && sender_address[0] != 0 && sender_address[0] != '@')
 950       {
 951       if (allow_unqualified_sender)
 952         {
 953         sender_address = rewrite_address_qualify(sender_address, FALSE);
 954         DEBUG(D_receive) debug_printf("unqualified address %s accepted "
 955           "and rewritten\n", raw_sender);
 956         }
 957       /* The function moan_smtp_batch() does not return. */
 958       else moan_smtp_batch(cmd_buffer, "501 sender address must contain "
 959         "a domain");
 960       }
 961     break;
 962
 963
 964     /* The RCPT TO command requires an address as an operand. All we do
 965     here is to parse it for syntactic correctness. There may be any number
 966     of RCPT TO commands, specifying multiple senders. We build them all into
 967     a data structure that is in argc/argv format. The start/end values
 968     given by parse_extract_address are not used, as we keep only the
 969     extracted address. */
 970
 971     case RCPT_CMD:
 972     if (sender_address == NULL)
 973       /* The function moan_smtp_batch() does not return. */
 974       moan_smtp_batch(cmd_buffer, "503 No sender yet given");
 975
 976     if (smtp_data[0] == 0)
 977       /* The function moan_smtp_batch() does not return. */
 978       moan_smtp_batch(cmd_buffer, "501 RCPT TO must have an address operand");
 979
 980     /* Check maximum number allowed */
 981
 982     if (recipients_max > 0 && recipients_count + 1 > recipients_max)
 983       /* The function moan_smtp_batch() does not return. */
 984       moan_smtp_batch(cmd_buffer, "%s too many recipients",
 985         recipients_max_reject? "552": "452");
 986
 987     /* Apply SMTP rewrite, then extract address. Don't allow "<>" as a
 988     recipient address */
 989
 990     recipient = ((rewrite_existflags & rewrite_smtp) != 0)?
 991       rewrite_one(smtp_data, rewrite_smtp, NULL, FALSE, US"",
 992         global_rewrite_rules) : smtp_data;
 993
 994     /* rfc821_domains = TRUE; << no longer needed */
 995     recipient = parse_extract_address(recipient, &errmess, &start, &end,
 996       &recipient_domain, FALSE);
 997     /* rfc821_domains = FALSE; << no longer needed */
 998
 999     if (recipient == NULL)
1000       /* The function moan_smtp_batch() does not return. */
1001       moan_smtp_batch(cmd_buffer, "501 %s", errmess);
1002
1003     /* If the recipient address is unqualified, qualify it if permitted. Then
1004     add it to the list of recipients. */
1005
1006     if (recipient_domain == 0)
1007       {
1008       if (allow_unqualified_recipient)
1009         {
1010         DEBUG(D_receive) debug_printf("unqualified address %s accepted\n",
1011           recipient);
1012         recipient = rewrite_address_qualify(recipient, TRUE);
1013         }
1014       /* The function moan_smtp_batch() does not return. */
1015       else moan_smtp_batch(cmd_buffer, "501 recipient address must contain "
1016         "a domain");
1017       }
1018     receive_add_recipient(recipient, -1);
1019     break;
1020
1021
1022     /* The DATA command is legal only if it follows successful MAIL FROM
1023     and RCPT TO commands. This function is complete when a valid DATA
1024     command is encountered. */
1025
1026     case DATA_CMD:
1027     if (sender_address == NULL || recipients_count <= 0)
1028       {
1029       /* The function moan_smtp_batch() does not return. */
1030       if (sender_address == NULL)
1031         moan_smtp_batch(cmd_buffer,
1032           "503 MAIL FROM:<sender> command must precede DATA");
1033       else
1034         moan_smtp_batch(cmd_buffer,
1035           "503 RCPT TO:<recipient> must precede DATA");
1036       }
1037     else
1038       {
1039       done = 3;                      /* DATA successfully achieved */
1040       message_ended = END_NOTENDED;  /* Indicate in middle of message */
1041       }
1042     break;
1043
1044
1045     /* The VRFY, EXPN, HELP, ETRN, and NOOP commands are ignored. */
1046
1047     case VRFY_CMD:
1048     case EXPN_CMD:
1049     case HELP_CMD:
1050     case NOOP_CMD:
1051     case ETRN_CMD:
1052     bsmtp_transaction_linecount = receive_linecount;
1053     break;
1054
1055
1056     case EOF_CMD:
1057     case QUIT_CMD:
1058     done = 2;
1059     break;
1060
1061
1062     case BADARG_CMD:
1063     /* The function moan_smtp_batch() does not return. */
1064     moan_smtp_batch(cmd_buffer, "501 Unexpected argument data");
1065     break;
1066
1067
1068     case BADCHAR_CMD:
1069     /* The function moan_smtp_batch() does not return. */
1070     moan_smtp_batch(cmd_buffer, "501 Unexpected NULL in SMTP command");
1071     break;
1072
1073
1074     default:
1075     /* The function moan_smtp_batch() does not return. */
1076     moan_smtp_batch(cmd_buffer, "500 Command unrecognized");
1077     break;
1078     }
1079   }
1080
1081 return done - 2;  /* Convert yield values */
1082 }
1083
1084
1085
1086
1087 /*************************************************
1088 *          Start an SMTP session                 *
1089 *************************************************/
1090
1091 /* This function is called at the start of an SMTP session. Thereafter,
1092 smtp_setup_msg() is called to initiate each separate message. This
1093 function does host-specific testing, and outputs the banner line.
1094
1095 Arguments:     none
1096 Returns:       FALSE if the session can not continue; something has
1097                gone wrong, or the connection to the host is blocked
1098 */
1099
1100 BOOL
1101 smtp_start_session(void)
1102 {
1103 int size = 256;
1104 int i, ptr;
1105 uschar *p, *s, *ss;
1106
1107 helo_seen = esmtp = helo_accept_junk = FALSE;
1108 count_nonmail = TRUE_UNSET;
1109 synprot_error_count = unknown_command_count = nonmail_command_count = 0;
1110 smtp_delay_mail = smtp_rlm_base;
1111 auth_advertised = FALSE;
1112 pipelining_advertised = FALSE;
1113 sync_cmd_limit = NON_SYNC_CMD_NON_PIPELINING;
1114
1115 memset(sender_host_cache, 0, sizeof(sender_host_cache));
1116
1117 sender_host_authenticated = NULL;
1118 authenticated_by = NULL;
1119
1120 #ifdef SUPPORT_TLS
1121 tls_cipher = tls_peerdn = NULL;
1122 tls_advertised = FALSE;
1123 #endif
1124
1125 /* Reset ACL connection variables */
1126
1127 for (i = 0; i < ACL_C_MAX; i++) acl_var[i] = NULL;
1128
1129 cmd_buffer = (uschar *)malloc(cmd_buffer_size + 1);  /* allow for trailing 0 */
1130 if (cmd_buffer == NULL)
1131   log_write(0, LOG_MAIN|LOG_PANIC_DIE,
1132     "malloc() failed for SMTP command buffer");
1133
1134 /* For batched input, the protocol setting can be overridden from the
1135 command line by a trusted caller. */
1136
1137 if (smtp_batched_input)
1138   {
1139   if (received_protocol == NULL) received_protocol = US"local-bsmtp";
1140   }
1141
1142 /* For non-batched SMTP input, the protocol setting is forced here. It will be
1143 reset later if any of EHLO/AUTH/STARTTLS are received. */
1144
1145 else
1146   received_protocol =
1147     protocols[pnormal] + ((sender_host_address != NULL)? pnlocal : 0);
1148
1149 /* Set up the buffer for inputting using direct read() calls, and arrange to
1150 call the local functions instead of the standard C ones. */
1151
1152 smtp_inbuffer = (uschar *)malloc(in_buffer_size);
1153 if (smtp_inbuffer == NULL)
1154   log_write(0, LOG_MAIN|LOG_PANIC_DIE, "malloc() failed for SMTP input buffer");
1155 receive_getc = smtp_getc;
1156 receive_ungetc = smtp_ungetc;
1157 receive_feof = smtp_feof;
1158 receive_ferror = smtp_ferror;
1159 smtp_inptr = smtp_inend = smtp_inbuffer;
1160 smtp_had_eof = smtp_had_error = 0;
1161
1162 /* Set up the message size limit; this may be host-specific */
1163
1164 thismessage_size_limit = expand_string_integer(message_size_limit);
1165 if (thismessage_size_limit < 0)
1166   {
1167   if (thismessage_size_limit == -1)
1168     log_write(0, LOG_MAIN|LOG_PANIC, "unable to expand message_size_limit: "
1169       "%s", expand_string_message);
1170   else
1171     log_write(0, LOG_MAIN|LOG_PANIC, "invalid message_size_limit: "
1172       "%s", expand_string_message);
1173   smtp_closedown(US"Temporary local problem - please try later");
1174   return FALSE;
1175   }
1176
1177 /* When a message is input locally via the -bs or -bS options, sender_host_
1178 unknown is set unless -oMa was used to force an IP address, in which case it
1179 is checked like a real remote connection. When -bs is used from inetd, this
1180 flag is not set, causing the sending host to be checked. The code that deals
1181 with IP source routing (if configured) is never required for -bs or -bS and
1182 the flag sender_host_notsocket is used to suppress it.
1183
1184 If smtp_accept_max and smtp_accept_reserve are set, keep some connections in
1185 reserve for certain hosts and/or networks. */
1186
1187 if (!sender_host_unknown)
1188   {
1189   int rc;
1190   BOOL reserved_host = FALSE;
1191
1192   /* Look up IP options (source routing info) on the socket if this is not an
1193   -oMa "host", and if any are found, log them and drop the connection.
1194
1195   Linux (and others now, see below) is different to everyone else, so there
1196   has to be some conditional compilation here. Versions of Linux before 2.1.15
1197   used a structure whose name was "options". Somebody finally realized that
1198   this name was silly, and it got changed to "ip_options". I use the
1199   newer name here, but there is a fudge in the script that sets up os.h
1200   to define a macro in older Linux systems.
1201
1202   Sigh. Linux is a fast-moving target. Another generation of Linux uses
1203   glibc 2, which has chosen ip_opts for the structure name. This is now
1204   really a glibc thing rather than a Linux thing, so the condition name
1205   has been changed to reflect this. It is relevant also to GNU/Hurd.
1206
1207   Mac OS 10.x (Darwin) is like the later glibc versions, but without the
1208   setting of the __GLIBC__ macro, so we can't detect it automatically. There's
1209   a special macro defined in the os.h file.
1210
1211   Some DGUX versions on older hardware appear not to support IP options at
1212   all, so there is now a general macro which can be set to cut out this
1213   support altogether.
1214
1215   How to do this properly in IPv6 is not yet known. */
1216
1217   #if !HAVE_IPV6 && !defined(NO_IP_OPTIONS)
1218
1219   #ifdef GLIBC_IP_OPTIONS
1220     #if (!defined __GLIBC__) || (__GLIBC__ < 2)
1221     #define OPTSTYLE 1
1222     #else
1223     #define OPTSTYLE 2
1224     #endif
1225   #elif defined DARWIN_IP_OPTIONS
1226     #define OPTSTYLE 2
1227   #else
1228     #define OPTSTYLE 3
1229   #endif
1230
1231   if (!host_checking && !sender_host_notsocket)
1232     {
1233     #if OPTSTYLE == 1
1234     SOCKLEN_T optlen = sizeof(struct ip_options) + MAX_IPOPTLEN;
1235     struct ip_options *ipopt = store_get(optlen);
1236     #elif OPTSTYLE == 2
1237     struct ip_opts ipoptblock;
1238     struct ip_opts *ipopt = &ipoptblock;
1239     SOCKLEN_T optlen = sizeof(ipoptblock);
1240     #else
1241     struct ipoption ipoptblock;
1242     struct ipoption *ipopt = &ipoptblock;
1243     SOCKLEN_T optlen = sizeof(ipoptblock);
1244     #endif
1245
1246     /* Occasional genuine failures of getsockopt() have been seen - for
1247     example, "reset by peer". Therefore, just log and give up on this
1248     call, unless the error is ENOPROTOOPT. This error is given by systems
1249     that have the interfaces but not the mechanism - e.g. GNU/Hurd at the time
1250     of writing. So for that error, carry on - we just can't do an IP options
1251     check. */
1252
1253     DEBUG(D_receive) debug_printf("checking for IP options\n");
1254
1255     if (getsockopt(fileno(smtp_out), IPPROTO_IP, IP_OPTIONS, (uschar *)(ipopt),
1256           &optlen) < 0)
1257       {
1258       if (errno != ENOPROTOOPT)
1259         {
1260         log_write(0, LOG_MAIN, "getsockopt() failed from %s: %s",
1261           host_and_ident(FALSE), strerror(errno));
1262         smtp_printf("451 SMTP service not available\r\n");
1263         return FALSE;
1264         }
1265       }
1266
1267     /* Deal with any IP options that are set. On the systems I have looked at,
1268     the value of MAX_IPOPTLEN has been 40, meaning that there should never be
1269     more logging data than will fit in big_buffer. Nevertheless, after somebody
1270     questioned this code, I've added in some paranoid checking. */
1271
1272     else if (optlen > 0)
1273       {
1274       uschar *p = big_buffer;
1275       uschar *pend = big_buffer + big_buffer_size;
1276       uschar *opt, *adptr;
1277       int optcount;
1278       struct in_addr addr;
1279
1280       #if OPTSTYLE == 1
1281       uschar *optstart = (uschar *)(ipopt->__data);
1282       #elif OPTSTYLE == 2
1283       uschar *optstart = (uschar *)(ipopt->ip_opts);
1284       #else
1285       uschar *optstart = (uschar *)(ipopt->ipopt_list);
1286       #endif
1287
1288       DEBUG(D_receive) debug_printf("IP options exist\n");
1289
1290       Ustrcpy(p, "IP options on incoming call:");
1291       p += Ustrlen(p);
1292
1293       for (opt = optstart; opt != NULL &&
1294            opt < (uschar *)(ipopt) + optlen;)
1295         {
1296         switch (*opt)
1297           {
1298           case IPOPT_EOL:
1299           opt = NULL;
1300           break;
1301
1302           case IPOPT_NOP:
1303           opt++;
1304           break;
1305
1306           case IPOPT_SSRR:
1307           case IPOPT_LSRR:
1308           if (!string_format(p, pend-p, " %s [@%s",
1309                (*opt == IPOPT_SSRR)? "SSRR" : "LSRR",
1310                #if OPTSTYLE == 1
1311                inet_ntoa(*((struct in_addr *)(&(ipopt->faddr))))))
1312                #elif OPTSTYLE == 2
1313                inet_ntoa(ipopt->ip_dst)))
1314                #else
1315                inet_ntoa(ipopt->ipopt_dst)))
1316                #endif
1317             {
1318             opt = NULL;
1319             break;
1320             }
1321
1322           p += Ustrlen(p);
1323           optcount = (opt[1] - 3) / sizeof(struct in_addr);
1324           adptr = opt + 3;
1325           while (optcount-- > 0)
1326             {
1327             memcpy(&addr, adptr, sizeof(addr));
1328             if (!string_format(p, pend - p - 1, "%s%s",
1329                   (optcount == 0)? ":" : "@", inet_ntoa(addr)))
1330               {
1331               opt = NULL;
1332               break;
1333               }
1334             p += Ustrlen(p);
1335             adptr += sizeof(struct in_addr);
1336             }
1337           *p++ = ']';
1338           opt += opt[1];
1339           break;
1340
1341           default:
1342             {
1343             int i;
1344             if (pend - p < 4 + 3*opt[1]) { opt = NULL; break; }
1345             Ustrcat(p, "[ ");
1346             p += 2;
1347             for (i = 0; i < opt[1]; i++)
1348               {
1349               sprintf(CS p, "%2.2x ", opt[i]);
1350               p += 3;
1351               }
1352             *p++ = ']';
1353             }
1354           opt += opt[1];
1355           break;
1356           }
1357         }
1358
1359       *p = 0;
1360       log_write(0, LOG_MAIN, "%s", big_buffer);
1361
1362       /* Refuse any call with IP options. This is what tcpwrappers 7.5 does. */
1363
1364       log_write(0, LOG_MAIN|LOG_REJECT,
1365         "connection from %s refused (IP options)", host_and_ident(FALSE));
1366
1367       smtp_printf("554 SMTP service not available\r\n");
1368       return FALSE;
1369       }
1370
1371     /* Length of options = 0 => there are no options */
1372
1373     else DEBUG(D_receive) debug_printf("no IP options found\n");
1374     }
1375   #endif  /* HAVE_IPV6 && !defined(NO_IP_OPTIONS) */
1376
1377   /* Set keep-alive in socket options. The option is on by default. This
1378   setting is an attempt to get rid of some hanging connections that stick in
1379   read() when the remote end (usually a dialup) goes away. */
1380
1381   if (smtp_accept_keepalive && !sender_host_notsocket)
1382     ip_keepalive(fileno(smtp_out), sender_host_address, FALSE);
1383
1384   /* If the current host matches host_lookup, set the name by doing a
1385   reverse lookup. On failure, sender_host_name will be NULL and
1386   host_lookup_failed will be TRUE. This may or may not be serious - optional
1387   checks later. */
1388
1389   if (verify_check_host(&host_lookup) == OK)
1390     {
1391     (void)host_name_lookup();
1392     host_build_sender_fullhost();
1393     }
1394
1395   /* Delay this until we have the full name, if it is looked up. */
1396
1397   set_process_info("handling incoming connection from %s",
1398     host_and_ident(FALSE));
1399
1400   /* Start up TLS if tls_on_connect is set. This is for supporting the legacy
1401   smtps port for use with older style SSL MTAs. */
1402
1403   #ifdef SUPPORT_TLS
1404   if (tls_on_connect && tls_server_start(tls_require_ciphers) != OK)
1405     return FALSE;
1406   #endif
1407
1408   /* Test for explicit connection rejection */
1409
1410   if (verify_check_host(&host_reject_connection) == OK)
1411     {
1412     log_write(L_connection_reject, LOG_MAIN|LOG_REJECT, "refused connection "
1413       "from %s (host_reject_connection)", host_and_ident(FALSE));
1414     smtp_printf("554 SMTP service not available\r\n");
1415     return FALSE;
1416     }
1417
1418   /* Test with TCP Wrappers if so configured */
1419
1420   #ifdef USE_TCP_WRAPPERS
1421   if (!hosts_ctl("exim",
1422          (sender_host_name == NULL)? STRING_UNKNOWN : CS sender_host_name,
1423          (sender_host_address == NULL)? STRING_UNKNOWN : CS sender_host_address,
1424          (sender_ident == NULL)? STRING_UNKNOWN : CS sender_ident))
1425     {
1426     HDEBUG(D_receive) debug_printf("tcp wrappers rejection\n");
1427     log_write(L_connection_reject,
1428               LOG_MAIN|LOG_REJECT, "refused connection from %s "
1429               "(tcp wrappers)", host_and_ident(FALSE));
1430     smtp_printf("554 SMTP service not available\r\n");
1431     return FALSE;
1432     }
1433   #endif
1434
1435   /* Check for reserved slots. Note that the count value doesn't include
1436   this process, as it gets upped in the parent process. */
1437
1438   if (smtp_accept_max > 0 &&
1439       smtp_accept_count + 1 > smtp_accept_max - smtp_accept_reserve)
1440     {
1441     if ((rc = verify_check_host(&smtp_reserve_hosts)) != OK)
1442       {
1443       log_write(L_connection_reject,
1444         LOG_MAIN, "temporarily refused connection from %s: not in "
1445         "reserve list: connected=%d max=%d reserve=%d%s",
1446         host_and_ident(FALSE), smtp_accept_count, smtp_accept_max,
1447         smtp_accept_reserve, (rc == DEFER)? " (lookup deferred)" : "");
1448       smtp_printf("421 %s: Too many concurrent SMTP connections; "
1449         "please try again later\r\n", smtp_active_hostname);
1450       return FALSE;
1451       }
1452     reserved_host = TRUE;
1453     }
1454
1455   /* If a load level above which only messages from reserved hosts are
1456   accepted is set, check the load. For incoming calls via the daemon, the
1457   check is done in the superior process if there are no reserved hosts, to
1458   save a fork. In all cases, the load average will already be available
1459   in a global variable at this point. */
1460
1461   if (smtp_load_reserve >= 0 &&
1462        load_average > smtp_load_reserve &&
1463        !reserved_host &&
1464        verify_check_host(&smtp_reserve_hosts) != OK)
1465     {
1466     log_write(L_connection_reject,
1467       LOG_MAIN, "temporarily refused connection from %s: not in "
1468       "reserve list and load average = %.2f", host_and_ident(FALSE),
1469       (double)load_average/1000.0);
1470     smtp_printf("421 %s: Too much load; please try again later\r\n",
1471       smtp_active_hostname);
1472     return FALSE;
1473     }
1474
1475   /* Determine whether unqualified senders or recipients are permitted
1476   for this host. Unfortunately, we have to do this every time, in order to
1477   set the flags so that they can be inspected when considering qualifying
1478   addresses in the headers. For a site that permits no qualification, this
1479   won't take long, however. */
1480
1481   allow_unqualified_sender =
1482     verify_check_host(&sender_unqualified_hosts) == OK;
1483
1484   allow_unqualified_recipient =
1485     verify_check_host(&recipient_unqualified_hosts) == OK;
1486
1487   /* Determine whether HELO/EHLO is required for this host. The requirement
1488   can be hard or soft. */
1489
1490   helo_required = verify_check_host(&helo_verify_hosts) == OK;
1491   if (!helo_required)
1492     helo_verify = verify_check_host(&helo_try_verify_hosts) == OK;
1493
1494   /* Determine whether this hosts is permitted to send syntactic junk
1495   after a HELO or EHLO command. */
1496
1497   helo_accept_junk = verify_check_host(&helo_accept_junk_hosts) == OK;
1498   }
1499
1500 /* For batch SMTP input we are now done. */
1501
1502 if (smtp_batched_input) return TRUE;
1503
1504 /* Run the ACL if it exists */
1505
1506 if (acl_smtp_connect != NULL)
1507   {
1508   int rc;
1509   uschar *user_msg, *log_msg;
1510   smtp_data = US"in \"connect\" ACL";    /* For logged failure message */
1511   rc = acl_check(ACL_WHERE_CONNECT, US"", acl_smtp_connect, &user_msg,
1512     &log_msg);
1513   if (rc != OK)
1514     {
1515     (void)smtp_handle_acl_fail(ACL_WHERE_CONNECT, rc, user_msg, log_msg);
1516     return FALSE;
1517     }
1518   }
1519
1520 /* Output the initial message for a two-way SMTP connection. It may contain
1521 newlines, which then cause a multi-line response to be given. */
1522
1523 s = expand_string(smtp_banner);
1524 if (s == NULL)
1525   log_write(0, LOG_MAIN|LOG_PANIC_DIE, "Expansion of \"%s\" (smtp_banner) "
1526     "failed: %s", smtp_banner, expand_string_message);
1527
1528 /* Remove any terminating newlines; might as well remove trailing space too */
1529
1530 p = s + Ustrlen(s);
1531 while (p > s && isspace(p[-1])) p--;
1532 *p = 0;
1533
1534 /* It seems that CC:Mail is braindead, and assumes that the greeting message
1535 is all contained in a single IP packet. The original code wrote out the
1536 greeting using several calls to fprint/fputc, and on busy servers this could
1537 cause it to be split over more than one packet - which caused CC:Mail to fall
1538 over when it got the second part of the greeting after sending its first
1539 command. Sigh. To try to avoid this, build the complete greeting message
1540 first, and output it in one fell swoop. This gives a better chance of it
1541 ending up as a single packet. */
1542
1543 ss = store_get(size);
1544 ptr = 0;
1545
1546 p = s;
1547 do       /* At least once, in case we have an empty string */
1548   {
1549   int len;
1550   uschar *linebreak = Ustrchr(p, '\n');
1551   if (linebreak == NULL)
1552     {
1553     len = Ustrlen(p);
1554     ss = string_cat(ss, &size, &ptr, US"220 ", 4);
1555     }
1556   else
1557     {
1558     len = linebreak - p;
1559     ss = string_cat(ss, &size, &ptr, US"220-", 4);
1560     }
1561   ss = string_cat(ss, &size, &ptr, p, len);
1562   ss = string_cat(ss, &size, &ptr, US"\r\n", 2);
1563   p += len;
1564   if (linebreak != NULL) p++;
1565   }
1566 while (*p != 0);
1567
1568 ss[ptr] = 0;  /* string_cat leaves room for this */
1569
1570 /* Before we write the banner, check that there is no input pending, unless
1571 this synchronisation check is disabled. */
1572
1573 if (smtp_enforce_sync && sender_host_address != NULL && !sender_host_notsocket)
1574   {
1575   fd_set fds;
1576   struct timeval tzero;
1577   tzero.tv_sec = 0;
1578   tzero.tv_usec = 0;
1579   FD_ZERO(&fds);
1580   FD_SET(fileno(smtp_in), &fds);
1581   if (select(fileno(smtp_in) + 1, (SELECT_ARG2_TYPE *)&fds, NULL, NULL,
1582       &tzero) > 0)
1583     {
1584     log_write(0, LOG_MAIN|LOG_REJECT, "SMTP protocol violation: "
1585       "synchronization error (input sent without waiting for greeting): "
1586       "rejected connection from %s", host_and_ident(TRUE));
1587     smtp_printf("554 SMTP synchronization error\r\n");
1588     return FALSE;
1589     }
1590   }
1591
1592 /* Now output the banner */
1593
1594 smtp_printf("%s", ss);
1595 return TRUE;
1596 }
1597
1598
1599
1600
1601
1602 /*************************************************
1603 *     Handle SMTP syntax and protocol errors     *
1604 *************************************************/
1605
1606 /* Write to the log for SMTP syntax errors in incoming commands, if configured
1607 to do so. Then transmit the error response. The return value depends on the
1608 number of syntax and protocol errors in this SMTP session.
1609
1610 Arguments:
1611   type      error type, given as a log flag bit
1612   code      response code; <= 0 means don't send a response
1613   data      data to reflect in the response (can be NULL)
1614   errmess   the error message
1615
1616 Returns:    -1   limit of syntax/protocol errors NOT exceeded
1617             +1   limit of syntax/protocol errors IS exceeded
1618
1619 These values fit in with the values of the "done" variable in the main
1620 processing loop in smtp_setup_msg(). */
1621
1622 static int
1623 synprot_error(int type, int code, uschar *data, uschar *errmess)
1624 {
1625 int yield = -1;
1626
1627 log_write(type, LOG_MAIN, "SMTP %s error in \"%s\" %s %s",
1628   (type == L_smtp_syntax_error)? "syntax" : "protocol",
1629   string_printing(cmd_buffer), host_and_ident(TRUE), errmess);
1630
1631 if (++synprot_error_count > smtp_max_synprot_errors)
1632   {
1633   yield = 1;
1634   log_write(0, LOG_MAIN|LOG_REJECT, "SMTP call from %s dropped: too many "
1635     "syntax or protocol errors (last command was \"%s\")",
1636     host_and_ident(FALSE), cmd_buffer);
1637   }
1638
1639 if (code > 0)
1640   {
1641   smtp_printf("%d%c%s%s%s\r\n", code, (yield == 1)? '-' : ' ',
1642     (data == NULL)? US"" : data, (data == NULL)? US"" : US": ", errmess);
1643   if (yield == 1)
1644     smtp_printf("%d Too many syntax or protocol errors\r\n", code);
1645   }
1646
1647 return yield;
1648 }
1649
1650
1651
1652
1653 /*************************************************
1654 *          Log incomplete transactions           *
1655 *************************************************/
1656
1657 /* This function is called after a transaction has been aborted by RSET, QUIT,
1658 connection drops or other errors. It logs the envelope information received
1659 so far in order to preserve address verification attempts.
1660
1661 Argument:   string to indicate what aborted the transaction
1662 Returns:    nothing
1663 */
1664
1665 static void
1666 incomplete_transaction_log(uschar *what)
1667 {
1668 if (sender_address == NULL ||                 /* No transaction in progress */
1669     (log_write_selector & L_smtp_incomplete_transaction) == 0  /* Not logging */
1670   ) return;
1671
1672 /* Build list of recipients for logging */
1673
1674 if (recipients_count > 0)
1675   {
1676   int i;
1677   raw_recipients = store_get(recipients_count * sizeof(uschar *));
1678   for (i = 0; i < recipients_count; i++)
1679     raw_recipients[i] = recipients_list[i].address;
1680   raw_recipients_count = recipients_count;
1681   }
1682
1683 log_write(L_smtp_incomplete_transaction, LOG_MAIN|LOG_SENDER|LOG_RECIPIENTS,
1684   "%s incomplete transaction (%s)", host_and_ident(TRUE), what);
1685 }
1686
1687
1688
1689
1690 /*************************************************
1691 *    Send SMTP response, possibly multiline      *
1692 *************************************************/
1693
1694 /* There are, it seems, broken clients out there that cannot handle multiline
1695 responses. If no_multiline_responses is TRUE (it can be set from an ACL), we
1696 output nothing for non-final calls, and only the first line for anything else.
1697
1698 Arguments:
1699   code          SMTP code
1700   final         FALSE if the last line isn't the final line
1701   msg           message text, possibly containing newlines
1702
1703 Returns:        nothing
1704 */
1705
1706 void
1707 smtp_respond(int code, BOOL final, uschar *msg)
1708 {
1709 if (!final && no_multiline_responses) return;
1710
1711 for (;;)
1712   {
1713   uschar *nl = Ustrchr(msg, '\n');
1714   if (nl == NULL)
1715     {
1716     smtp_printf("%d%c%s\r\n", code, final? ' ':'-', msg);
1717     return;
1718     }
1719   else if (nl[1] == 0 || no_multiline_responses)
1720     {
1721     smtp_printf("%d%c%.*s\r\n", code, final? ' ':'-', (int)(nl - msg), msg);
1722     return;
1723     }
1724   else
1725     {
1726     smtp_printf("%d-%.*s\r\n", code, (int)(nl - msg), msg);
1727     msg = nl + 1;
1728     while (isspace(*msg)) msg++;
1729     }
1730   }
1731 }
1732
1733
1734
1735
1736 /*************************************************
1737 *           Handle an ACL failure                *
1738 *************************************************/
1739
1740 /* This function is called when acl_check() fails. As well as calls from within
1741 this module, it is called from receive.c for an ACL after DATA. It sorts out
1742 logging the incident, and sets up the error response. A message containing
1743 newlines is turned into a multiline SMTP response, but for logging, only the
1744 first line is used.
1745
1746 There's a table of the response codes to use in globals.c, along with the table
1747 of names. VFRY is special. Despite RFC1123 it defaults disabled in Exim.
1748 However, discussion in connection with RFC 821bis (aka RFC 2821) has concluded
1749 that the response should be 252 in the disabled state, because there are broken
1750 clients that try VRFY before RCPT. A 5xx response should be given only when the
1751 address is positively known to be undeliverable. Sigh. Also, for ETRN, 458 is
1752 given on refusal, and for AUTH, 503.
1753
1754 Arguments:
1755   where      where the ACL was called from
1756   rc         the failure code
1757   user_msg   a message that can be included in an SMTP response
1758   log_msg    a message for logging
1759
1760 Returns:     0 in most cases
1761              2 if the failure code was FAIL_DROP, in which case the
1762                SMTP connection should be dropped (this value fits with the
1763                "done" variable in smtp_setup_msg() below)
1764 */
1765
1766 int
1767 smtp_handle_acl_fail(int where, int rc, uschar *user_msg, uschar *log_msg)
1768 {
1769 int code = acl_wherecodes[where];
1770 BOOL drop = rc == FAIL_DROP;
1771 uschar *lognl;
1772 uschar *sender_info = US"";
1773 uschar *what = (where == ACL_WHERE_PREDATA)? US"DATA" :
1774                (where == ACL_WHERE_DATA)? US"after DATA" :
1775   string_sprintf("%s %s", acl_wherenames[where], smtp_data);
1776
1777 if (drop) rc = FAIL;
1778
1779 /* We used to have sender_address here; however, there was a bug that was not
1780 updating sender_address after a rewrite during a verify. When this bug was
1781 fixed, sender_address at this point became the rewritten address. I'm not sure
1782 this is what should be logged, so I've changed to logging the unrewritten
1783 address to retain backward compatibility. */
1784
1785 if (where == ACL_WHERE_RCPT || where == ACL_WHERE_DATA)
1786   {
1787   sender_info = string_sprintf("F=<%s> ", (sender_address_unrewritten != NULL)?
1788     sender_address_unrewritten : sender_address);
1789   }
1790
1791 /* If there's been a sender verification failure with a specific message, and
1792 we have not sent a response about it yet, do so now, as a preliminary line for
1793 failures, but not defers. However, log it in both cases. */
1794
1795 if (sender_verified_failed != NULL &&
1796     !testflag(sender_verified_failed, af_sverify_told))
1797   {
1798   setflag(sender_verified_failed, af_sverify_told);
1799
1800   log_write(0, LOG_MAIN|LOG_REJECT, "%s sender verify %s for <%s>%s",
1801     host_and_ident(TRUE),
1802     ((sender_verified_failed->special_action & 255) == DEFER)? "defer" : "fail",
1803     sender_verified_failed->address,
1804     (sender_verified_failed->message == NULL)? US"" :
1805     string_sprintf(": %s", sender_verified_failed->message));
1806
1807   if (rc == FAIL && sender_verified_failed->user_message != NULL)
1808     smtp_respond(code, FALSE, string_sprintf(
1809         testflag(sender_verified_failed, af_verify_pmfail)?
1810           "Postmaster verification failed while checking <%s>\n%s\n"
1811           "Several RFCs state that you are required to have a postmaster\n"
1812           "mailbox for each mail domain. This host does not accept mail\n"
1813           "from domains whose servers reject the postmaster address."
1814           :
1815         testflag(sender_verified_failed, af_verify_nsfail)?
1816           "Callback setup failed while verifying <%s>\n%s\n"
1817           "The initial connection, or a HELO or MAIL FROM:<> command was\n"
1818           "rejected. Refusing MAIL FROM:<> does not help fight spam, disregards\n"
1819           "RFC requirements, and stops you from receiving standard bounce\n"
1820           "messages. This host does not accept mail from domains whose servers\n"
1821           "refuse bounces."
1822           :
1823           "Verification failed for <%s>\n%s",
1824         sender_verified_failed->address,
1825         sender_verified_failed->user_message));
1826   }
1827
1828 /* Sort out text for logging */
1829
1830 log_msg = (log_msg == NULL)? US"" : string_sprintf(": %s", log_msg);
1831 lognl = Ustrchr(log_msg, '\n');
1832 if (lognl != NULL) *lognl = 0;
1833
1834 /* Send permanent failure response to the command, but the code used isn't
1835 always a 5xx one - see comments at the start of this function. If the original
1836 rc was FAIL_DROP we drop the connection and yield 2. */
1837
1838 if (rc == FAIL) smtp_respond(code, TRUE, (user_msg == NULL)?
1839   US"Administrative prohibition" : user_msg);
1840
1841 /* Send temporary failure response to the command. Don't give any details,
1842 unless acl_temp_details is set. This is TRUE for a callout defer, a "defer"
1843 verb, and for a header verify when smtp_return_error_details is set.
1844
1845 This conditional logic is all somewhat of a mess because of the odd
1846 interactions between temp_details and return_error_details. One day it should
1847 be re-implemented in a tidier fashion. */
1848
1849 else
1850   {
1851   if (acl_temp_details && user_msg != NULL)
1852     {
1853     if (smtp_return_error_details &&
1854         sender_verified_failed != NULL &&
1855         sender_verified_failed->message != NULL)
1856       {
1857       smtp_respond(451, FALSE, sender_verified_failed->message);
1858       }
1859     smtp_respond(451, TRUE, user_msg);
1860     }
1861   else
1862     smtp_printf("451 Temporary local problem - please try later\r\n");
1863   }
1864
1865 /* Log the incident. If the connection is not forcibly to be dropped, return 0.
1866 Otherwise, log why it is closing if required and return 2.  */
1867
1868 log_write(0, LOG_MAIN|LOG_REJECT, "%s %s%srejected %s%s",
1869   host_and_ident(TRUE),
1870   sender_info, (rc == FAIL)? US"" : US"temporarily ", what, log_msg);
1871
1872 if (!drop) return 0;
1873
1874 log_write(L_smtp_connection, LOG_MAIN, "%s closed by DROP in ACL",
1875   smtp_get_connection_info());
1876 return 2;
1877 }
1878
1879
1880
1881
1882 /*************************************************
1883 *       Initialize for SMTP incoming message     *
1884 *************************************************/
1885
1886 /* This function conducts the initial dialogue at the start of an incoming SMTP
1887 message, and builds a list of recipients. However, if the incoming message
1888 is part of a batch (-bS option) a separate function is called since it would
1889 be messy having tests splattered about all over this function. This function
1890 therefore handles the case where interaction is occurring. The input and output
1891 files are set up in smtp_in and smtp_out.
1892
1893 The global recipients_list is set to point to a vector of recipient_item
1894 blocks, whose number is given by recipients_count. This is extended by the
1895 receive_add_recipient() function. The global variable sender_address is set to
1896 the sender's address. The yield is +1 if a message has been successfully
1897 started, 0 if a QUIT command was encountered or the connection was refused from
1898 the particular host, or -1 if the connection was lost.
1899
1900 Argument: none
1901
1902 Returns:  > 0 message successfully started (reached DATA)
1903           = 0 QUIT read or end of file reached or call refused
1904           < 0 lost connection
1905 */
1906
1907 int
1908 smtp_setup_msg(void)
1909 {
1910 int done = 0;
1911 BOOL toomany = FALSE;
1912 BOOL discarded = FALSE;
1913 BOOL last_was_rej_mail = FALSE;
1914 BOOL last_was_rcpt = FALSE;
1915 void *reset_point = store_get(0);
1916
1917 DEBUG(D_receive) debug_printf("smtp_setup_msg entered\n");
1918
1919 /* Reset for start of new message. We allow one RSET not to be counted as a
1920 nonmail command, for those MTAs that insist on sending it between every
1921 message. Ditto for EHLO/HELO and for STARTTLS, to allow for going in and out of
1922 TLS between messages (an Exim client may do this if it has messages queued up
1923 for the host). Note: we do NOT reset AUTH at this point. */
1924
1925 smtp_reset(reset_point);
1926 message_ended = END_NOTSTARTED;
1927
1928 cmd_list[CMD_LIST_RSET].is_mail_cmd = TRUE;
1929 cmd_list[CMD_LIST_HELO].is_mail_cmd = TRUE;
1930 cmd_list[CMD_LIST_EHLO].is_mail_cmd = TRUE;
1931 #ifdef SUPPORT_TLS
1932 cmd_list[CMD_LIST_STARTTLS].is_mail_cmd = TRUE;
1933 #endif
1934
1935 /* Set the local signal handler for SIGTERM - it tries to end off tidily */
1936
1937 os_non_restarting_signal(SIGTERM, command_sigterm_handler);
1938
1939 /* Batched SMTP is handled in a different function. */
1940
1941 if (smtp_batched_input) return smtp_setup_batch_msg();
1942
1943 /* Deal with SMTP commands. This loop is exited by setting done to a POSITIVE
1944 value. The values are 2 larger than the required yield of the function. */
1945
1946 while (done <= 0)
1947   {
1948   uschar **argv;
1949   uschar *etrn_command;
1950   uschar *etrn_serialize_key;
1951   uschar *errmess;
1952   uschar *user_msg, *log_msg;
1953   uschar *recipient = NULL;
1954   uschar *hello = NULL;
1955   uschar *set_id = NULL;
1956   uschar *s, *ss;
1957   BOOL was_rej_mail = FALSE;
1958   BOOL was_rcpt = FALSE;
1959   void (*oldsignal)(int);
1960   pid_t pid;
1961   int start, end, sender_domain, recipient_domain;
1962   int ptr, size, rc;
1963   int c;
1964   auth_instance *au;
1965
1966   switch(smtp_read_command(TRUE))
1967     {
1968     /* The AUTH command is not permitted to occur inside a transaction, and may
1969     occur successfully only once per connection, and then only when we've
1970     advertised it. Actually, that isn't quite true. When TLS is started, all
1971     previous information about a connection must be discarded, so a new AUTH is
1972     permitted at that time.
1973
1974     AUTH is initially labelled as a "nonmail command" so that one occurrence
1975     doesn't get counted. We change the label here so that multiple failing
1976     AUTHS will eventually hit the nonmail threshold. */
1977
1978     case AUTH_CMD:
1979     authentication_failed = TRUE;
1980     cmd_list[CMD_LIST_AUTH].is_mail_cmd = FALSE;
1981
1982     if (!auth_advertised)
1983       {
1984       done = synprot_error(L_smtp_protocol_error, 503, NULL,
1985         US"AUTH command used when not advertised");
1986       break;
1987       }
1988     if (sender_host_authenticated != NULL)
1989       {
1990       done = synprot_error(L_smtp_protocol_error, 503, NULL,
1991         US"already authenticated");
1992       break;
1993       }
1994     if (sender_address != NULL)
1995       {
1996       done = synprot_error(L_smtp_protocol_error, 503, NULL,
1997         US"not permitted in mail transaction");
1998       break;
1999       }
2000
2001     /* Check the ACL */
2002
2003     if (acl_smtp_auth != NULL)
2004       {
2005       rc = acl_check(ACL_WHERE_AUTH, smtp_data, acl_smtp_auth, &user_msg,
2006         &log_msg);
2007       if (rc != OK)
2008         {
2009         done = smtp_handle_acl_fail(ACL_WHERE_AUTH, rc, user_msg, log_msg);
2010         break;
2011         }
2012       }
2013
2014     /* Find the name of the requested authentication mechanism. */
2015
2016     s = smtp_data;
2017     while ((c = *smtp_data) != 0 && !isspace(c))
2018       {
2019       if (!isalnum(c) && c != '-' && c != '_')
2020         {
2021         done = synprot_error(L_smtp_syntax_error, 501, NULL,
2022           US"invalid character in authentication mechanism name");
2023         goto COMMAND_LOOP;
2024         }
2025       smtp_data++;
2026       }
2027
2028     /* If not at the end of the line, we must be at white space. Terminate the
2029     name and move the pointer on to any data that may be present. */
2030
2031     if (*smtp_data != 0)
2032       {
2033       *smtp_data++ = 0;
2034       while (isspace(*smtp_data)) smtp_data++;
2035       }
2036
2037     /* Search for an authentication mechanism which is configured for use
2038     as a server and which has been advertised. */
2039
2040     for (au = auths; au != NULL; au = au->next)
2041       {
2042       if (strcmpic(s, au->public_name) == 0 && au->server &&
2043           au->advertised) break;
2044       }
2045
2046     if (au == NULL)
2047       {
2048       done = synprot_error(L_smtp_protocol_error, 504, NULL,
2049         string_sprintf("%s authentication mechanism not supported", s));
2050       break;
2051       }
2052
2053     /* Run the checking code, passing the remainder of the command
2054     line as data. Initialize $0 empty. The authenticator may set up
2055     other numeric variables. Afterwards, have a go at expanding the set_id
2056     string, even if authentication failed - for bad passwords it can be useful
2057     to log the userid. On success, require set_id to expand and exist, and
2058     put it in authenticated_id. Save this in permanent store, as the working
2059     store gets reset at HELO, RSET, etc. */
2060
2061     expand_nmax = 0;
2062     expand_nlength[0] = 0;   /* $0 contains nothing */
2063
2064     c = (au->info->servercode)(au, smtp_data);
2065     if (au->set_id != NULL) set_id = expand_string(au->set_id);
2066     expand_nmax = -1;        /* Reset numeric variables */
2067
2068     /* For the non-OK cases, set up additional logging data if set_id
2069     is not empty. */
2070
2071     if (c != OK)
2072       {
2073       if (set_id != NULL && *set_id != 0)
2074         set_id = string_sprintf(" (set_id=%s)", set_id);
2075       else set_id = US"";
2076       }
2077
2078     /* Switch on the result */
2079
2080     switch(c)
2081       {
2082       case OK:
2083       if (au->set_id == NULL || set_id != NULL)    /* Complete success */
2084         {
2085         if (set_id != NULL) authenticated_id = string_copy_malloc(set_id);
2086         sender_host_authenticated = au->name;
2087         authentication_failed = FALSE;
2088         received_protocol =
2089           protocols[pextend + pauthed + ((tls_active >= 0)? pcrpted:0)] +
2090             ((sender_host_address != NULL)? pnlocal : 0);
2091         s = ss = US"235 Authentication succeeded";
2092         authenticated_by = au;
2093         break;
2094         }
2095
2096       /* Authentication succeeded, but we failed to expand the set_id string.
2097       Treat this as a temporary error. */
2098
2099       auth_defer_msg = expand_string_message;
2100       /* Fall through */
2101
2102       case DEFER:
2103       s = string_sprintf("435 Unable to authenticate at present%s",
2104         auth_defer_user_msg);
2105       ss = string_sprintf("435 Unable to authenticate at present%s: %s",
2106         set_id, auth_defer_msg);
2107       break;
2108
2109       case BAD64:
2110       s = ss = US"501 Invalid base64 data";
2111       break;
2112
2113       case CANCELLED:
2114       s = ss = US"501 Authentication cancelled";
2115       break;
2116
2117       case UNEXPECTED:
2118       s = ss = US"553 Initial data not expected";
2119       break;
2120
2121       case FAIL:
2122       s = US"535 Incorrect authentication data";
2123       ss = string_sprintf("535 Incorrect authentication data%s", set_id);
2124       break;
2125
2126       default:
2127       s = US"435 Internal error";
2128       ss = string_sprintf("435 Internal error%s: return %d from authentication "
2129         "check", set_id, c);
2130       break;
2131       }
2132
2133     smtp_printf("%s\r\n", s);
2134     if (c != OK)
2135       log_write(0, LOG_MAIN|LOG_REJECT, "%s authenticator failed for %s: %s",
2136         au->name, host_and_ident(FALSE), ss);
2137
2138     break;  /* AUTH_CMD */
2139
2140     /* The HELO/EHLO commands are permitted to appear in the middle of a
2141     session as well as at the beginning. They have the effect of a reset in
2142     addition to their other functions. Their absence at the start cannot be
2143     taken to be an error.
2144
2145     RFC 2821 says:
2146
2147       If the EHLO command is not acceptable to the SMTP server, 501, 500,
2148       or 502 failure replies MUST be returned as appropriate.  The SMTP
2149       server MUST stay in the same state after transmitting these replies
2150       that it was in before the EHLO was received.
2151
2152     Therefore, we do not do the reset until after checking the command for
2153     acceptability. This change was made for Exim release 4.11. Previously
2154     it did the reset first. */
2155
2156     case HELO_CMD:
2157     hello = US"HELO";
2158     esmtp = FALSE;
2159     goto HELO_EHLO;
2160
2161     case EHLO_CMD:
2162     hello = US"EHLO";
2163     esmtp = TRUE;
2164
2165     HELO_EHLO:      /* Common code for HELO and EHLO */
2166     cmd_list[CMD_LIST_HELO].is_mail_cmd = FALSE;
2167     cmd_list[CMD_LIST_EHLO].is_mail_cmd = FALSE;
2168
2169     /* Reject the HELO if its argument was invalid or non-existent. A
2170     successful check causes the argument to be saved in malloc store. */
2171
2172     if (!check_helo(smtp_data))
2173       {
2174       smtp_printf("501 Syntactically invalid %s argument(s)\r\n", hello);
2175
2176       log_write(0, LOG_MAIN|LOG_REJECT, "rejected %s from %s: syntactically "
2177         "invalid argument(s): %s", hello, host_and_ident(FALSE),
2178         (*smtp_data == 0)? US"(no argument given)" :
2179                            string_printing(smtp_data));
2180
2181       if (++synprot_error_count > smtp_max_synprot_errors)
2182         {
2183         log_write(0, LOG_MAIN|LOG_REJECT, "SMTP call from %s dropped: too many "
2184           "syntax or protocol errors (last command was \"%s\")",
2185           host_and_ident(FALSE), cmd_buffer);
2186         done = 1;
2187         }
2188
2189       break;
2190       }
2191
2192     /* If sender_host_unknown is true, we have got here via the -bs interface,
2193     not called from inetd. Otherwise, we are running an IP connection and the
2194     host address will be set. If the helo name is the primary name of this
2195     host and we haven't done a reverse lookup, force one now. If helo_required
2196     is set, ensure that the HELO name matches the actual host. If helo_verify
2197     is set, do the same check, but softly. */
2198
2199     if (!sender_host_unknown)
2200       {
2201       BOOL old_helo_verified = helo_verified;
2202       uschar *p = smtp_data;
2203
2204       while (*p != 0 && !isspace(*p)) { *p = tolower(*p); p++; }
2205       *p = 0;
2206
2207       /* Force a reverse lookup if HELO quoted something in helo_lookup_domains
2208       because otherwise the log can be confusing. */
2209
2210       if (sender_host_name == NULL &&
2211            (deliver_domain = sender_helo_name,  /* set $domain */
2212             match_isinlist(sender_helo_name, &helo_lookup_domains, 0,
2213               &domainlist_anchor, NULL, MCL_DOMAIN, TRUE, NULL)) == OK)
2214         (void)host_name_lookup();
2215
2216       /* Rebuild the fullhost info to include the HELO name (and the real name
2217       if it was looked up.) */
2218
2219       host_build_sender_fullhost();  /* Rebuild */
2220       set_process_info("handling%s incoming connection from %s",
2221         (tls_active >= 0)? " TLS" : "", host_and_ident(FALSE));
2222
2223       /* Verify if configured. This doesn't give much security, but it does
2224       make some people happy to be able to do it. Note that HELO is legitimately
2225       allowed to quote an address literal. Allow for IPv6 ::ffff: literals. */
2226
2227       helo_verified = FALSE;
2228       if (helo_required || helo_verify)
2229         {
2230         BOOL tempfail = FALSE;
2231
2232         HDEBUG(D_receive) debug_printf("verifying %s %s\n", hello,
2233           sender_helo_name);
2234         if (sender_helo_name[0] == '[')
2235           {
2236           helo_verified = Ustrncmp(sender_helo_name+1, sender_host_address,
2237             Ustrlen(sender_host_address)) == 0;
2238
2239           #if HAVE_IPV6
2240           if (!helo_verified)
2241             {
2242             if (strncmpic(sender_host_address, US"::ffff:", 7) == 0)
2243               helo_verified = Ustrncmp(sender_helo_name + 1,
2244                 sender_host_address + 7, Ustrlen(sender_host_address) - 7) == 0;
2245             }
2246           #endif
2247
2248           HDEBUG(D_receive)
2249             { if (helo_verified) debug_printf("matched host address\n"); }
2250           }
2251
2252         /* Do a reverse lookup if one hasn't already given a positive or
2253         negative response. If that fails, or the name doesn't match, try
2254         checking with a forward lookup. */
2255
2256         else
2257           {
2258           if (sender_host_name == NULL && !host_lookup_failed)
2259             tempfail = host_name_lookup() == DEFER;
2260
2261           /* If a host name is known, check it and all its aliases. */
2262
2263           if (sender_host_name != NULL)
2264             {
2265             helo_verified = strcmpic(sender_host_name, sender_helo_name) == 0;
2266
2267             if (helo_verified)
2268               {
2269               HDEBUG(D_receive) debug_printf("matched host name\n");
2270               }
2271             else
2272               {
2273               uschar **aliases = sender_host_aliases;
2274               while (*aliases != NULL)
2275                 {
2276                 helo_verified = strcmpic(*aliases++, sender_helo_name) == 0;
2277                 if (helo_verified) break;
2278                 }
2279               HDEBUG(D_receive)
2280                 {
2281                 if (helo_verified)
2282                   debug_printf("matched alias %s\n", *(--aliases));
2283                 }
2284               }
2285             }
2286
2287           /* Final attempt: try a forward lookup of the helo name */
2288
2289           if (!helo_verified)
2290             {
2291             int rc;
2292             host_item h;
2293             h.name = sender_helo_name;
2294             h.address = NULL;
2295             h.mx = MX_NONE;
2296             h.next = NULL;
2297             HDEBUG(D_receive) debug_printf("getting IP address for %s\n",
2298               sender_helo_name);
2299             rc = host_find_byname(&h, NULL, NULL, TRUE);
2300             if (rc == HOST_FOUND || rc == HOST_FOUND_LOCAL)
2301               {
2302               host_item *hh = &h;
2303               while (hh != NULL)
2304                 {
2305                 if (Ustrcmp(hh->address, sender_host_address) == 0)
2306                   {
2307                   helo_verified = TRUE;
2308                   HDEBUG(D_receive)
2309                     debug_printf("IP address for %s matches calling address\n",
2310                       sender_helo_name);
2311                   break;
2312                   }
2313                 hh = hh->next;
2314                 }
2315               }
2316             }
2317           }
2318
2319         /* Verification failed. A temporary lookup failure gives a temporary
2320         error. */
2321
2322         if (!helo_verified)
2323           {
2324           if (helo_required)
2325             {
2326             smtp_printf("%d %s argument does not match calling host\r\n",
2327               tempfail? 451 : 550, hello);
2328             log_write(0, LOG_MAIN|LOG_REJECT, "%srejected \"%s %s\" from %s",
2329               tempfail? "temporarily " : "",
2330               hello, sender_helo_name, host_and_ident(FALSE));
2331             helo_verified = old_helo_verified;
2332             break;                   /* End of HELO/EHLO processing */
2333             }
2334           HDEBUG(D_all) debug_printf("%s verification failed but host is in "
2335             "helo_try_verify_hosts\n", hello);
2336           }
2337         }
2338       }
2339
2340     /* Apply an ACL check if one is defined */
2341
2342     if (acl_smtp_helo != NULL)
2343       {
2344       rc = acl_check(ACL_WHERE_HELO, smtp_data, acl_smtp_helo, &user_msg,
2345         &log_msg);
2346       if (rc != OK)
2347         {
2348         done = smtp_handle_acl_fail(ACL_WHERE_HELO, rc, user_msg, log_msg);
2349         sender_helo_name = NULL;
2350         host_build_sender_fullhost();  /* Rebuild */
2351         break;
2352         }
2353       }
2354
2355     /* The EHLO/HELO command is acceptable. Reset the protocol and the state,
2356     abandoning any previous message. */
2357
2358     received_protocol = (esmtp?
2359       protocols[pextend +
2360         ((sender_host_authenticated != NULL)? pauthed : 0) +
2361         ((tls_active >= 0)? pcrpted : 0)]
2362       :
2363       protocols[pnormal])
2364       +
2365       ((sender_host_address != NULL)? pnlocal : 0);
2366
2367     smtp_reset(reset_point);
2368     toomany = FALSE;
2369
2370     /* Generate an OK reply, including the ident if present, and also
2371     the IP address if present. Reflecting back the ident is intended
2372     as a deterrent to mail forgers. For maximum efficiency, and also
2373     because some broken systems expect each response to be in a single
2374     packet, arrange that it is sent in one write(). */
2375
2376     auth_advertised = FALSE;
2377     pipelining_advertised = FALSE;
2378     #ifdef SUPPORT_TLS
2379     tls_advertised = FALSE;
2380     #endif
2381
2382     s = string_sprintf("250 %s Hello %s%s%s",
2383       smtp_active_hostname,
2384       (sender_ident == NULL)?  US"" : sender_ident,
2385       (sender_ident == NULL)?  US"" : US" at ",
2386       (sender_host_name == NULL)? sender_helo_name : sender_host_name);
2387
2388     ptr = Ustrlen(s);
2389     size = ptr + 1;
2390
2391     if (sender_host_address != NULL)
2392       {
2393       s = string_cat(s, &size, &ptr, US" [", 2);
2394       s = string_cat(s, &size, &ptr, sender_host_address,
2395         Ustrlen(sender_host_address));
2396       s = string_cat(s, &size, &ptr, US"]", 1);
2397       }
2398
2399     s = string_cat(s, &size, &ptr, US"\r\n", 2);
2400
2401     /* If we received EHLO, we must create a multiline response which includes
2402     the functions supported. */
2403
2404     if (esmtp)
2405       {
2406       s[3] = '-';
2407
2408       /* I'm not entirely happy with this, as an MTA is supposed to check
2409       that it has enough room to accept a message of maximum size before
2410       it sends this. However, there seems little point in not sending it.
2411       The actual size check happens later at MAIL FROM time. By postponing it
2412       till then, VRFY and EXPN can be used after EHLO when space is short. */
2413
2414       if (thismessage_size_limit > 0)
2415         {
2416         sprintf(CS big_buffer, "250-SIZE %d\r\n", thismessage_size_limit);
2417         s = string_cat(s, &size, &ptr, big_buffer, Ustrlen(big_buffer));
2418         }
2419       else
2420         {
2421         s = string_cat(s, &size, &ptr, US"250-SIZE\r\n", 10);
2422         }
2423
2424       /* Exim does not do protocol conversion or data conversion. It is 8-bit
2425       clean; if it has an 8-bit character in its hand, it just sends it. It
2426       cannot therefore specify 8BITMIME and remain consistent with the RFCs.
2427       However, some users want this option simply in order to stop MUAs
2428       mangling messages that contain top-bit-set characters. It is therefore
2429       provided as an option. */
2430
2431       if (accept_8bitmime)
2432         s = string_cat(s, &size, &ptr, US"250-8BITMIME\r\n", 14);
2433
2434       /* Advertise ETRN if there's an ACL checking whether a host is
2435       permitted to issue it; a check is made when any host actually tries. */
2436
2437       if (acl_smtp_etrn != NULL)
2438         {
2439         s = string_cat(s, &size, &ptr, US"250-ETRN\r\n", 10);
2440         }
2441
2442       /* Advertise EXPN if there's an ACL checking whether a host is
2443       permitted to issue it; a check is made when any host actually tries. */
2444
2445       if (acl_smtp_expn != NULL)
2446         {
2447         s = string_cat(s, &size, &ptr, US"250-EXPN\r\n", 10);
2448         }
2449
2450       /* Exim is quite happy with pipelining, so let the other end know that
2451       it is safe to use it, unless advertising is disabled. */
2452
2453       if (verify_check_host(&pipelining_advertise_hosts) == OK)
2454         {
2455         s = string_cat(s, &size, &ptr, US"250-PIPELINING\r\n", 16);
2456         sync_cmd_limit = NON_SYNC_CMD_PIPELINING;
2457         pipelining_advertised = TRUE;
2458         }
2459
2460       /* If any server authentication mechanisms are configured, advertise
2461       them if the current host is in auth_advertise_hosts. The problem with
2462       advertising always is that some clients then require users to
2463       authenticate (and aren't configurable otherwise) even though it may not
2464       be necessary (e.g. if the host is in host_accept_relay).
2465
2466       RFC 2222 states that SASL mechanism names contain only upper case
2467       letters, so output the names in upper case, though we actually recognize
2468       them in either case in the AUTH command. */
2469
2470       if (auths != NULL)
2471         {
2472         if (verify_check_host(&auth_advertise_hosts) == OK)
2473           {
2474           auth_instance *au;
2475           BOOL first = TRUE;
2476           for (au = auths; au != NULL; au = au->next)
2477             {
2478             if (au->server && (au->advertise_condition == NULL ||
2479                 expand_check_condition(au->advertise_condition, au->name,
2480                 US"authenticator")))
2481               {
2482               int saveptr;
2483               if (first)
2484                 {
2485                 s = string_cat(s, &size, &ptr, US"250-AUTH", 8);
2486                 first = FALSE;
2487                 auth_advertised = TRUE;
2488                 }
2489               saveptr = ptr;
2490               s = string_cat(s, &size, &ptr, US" ", 1);
2491               s = string_cat(s, &size, &ptr, au->public_name,
2492                 Ustrlen(au->public_name));
2493               while (++saveptr < ptr) s[saveptr] = toupper(s[saveptr]);
2494               au->advertised = TRUE;
2495               }
2496             else au->advertised = FALSE;
2497             }
2498           if (!first) s = string_cat(s, &size, &ptr, US"\r\n", 2);
2499           }
2500         }
2501
2502       /* Advertise TLS (Transport Level Security) aka SSL (Secure Socket Layer)
2503       if it has been included in the binary, and the host matches
2504       tls_advertise_hosts. We must *not* advertise if we are already in a
2505       secure connection. */
2506
2507       #ifdef SUPPORT_TLS
2508       if (tls_active < 0 &&
2509           verify_check_host(&tls_advertise_hosts) != FAIL)
2510         {
2511         s = string_cat(s, &size, &ptr, US"250-STARTTLS\r\n", 14);
2512         tls_advertised = TRUE;
2513         }
2514       #endif
2515
2516       /* Finish off the multiline reply with one that is always available. */
2517
2518       s = string_cat(s, &size, &ptr, US"250 HELP\r\n", 10);
2519       }
2520
2521     /* Terminate the string (for debug), write it, and note that HELO/EHLO
2522     has been seen. */
2523
2524     s[ptr] = 0;
2525
2526     #ifdef SUPPORT_TLS
2527     if (tls_active >= 0) (void)tls_write(s, ptr); else
2528     #endif
2529
2530     fwrite(s, 1, ptr, smtp_out);
2531     DEBUG(D_receive) debug_printf("SMTP>> %s", s);
2532     helo_seen = TRUE;
2533     break;   /* HELO/EHLO */
2534
2535
2536     /* The MAIL command requires an address as an operand. All we do
2537     here is to parse it for syntactic correctness. The form "<>" is
2538     a special case which converts into an empty string. The start/end
2539     pointers in the original are not used further for this address, as
2540     it is the canonical extracted address which is all that is kept. */
2541
2542     case MAIL_CMD:
2543     smtp_mailcmd_count++;              /* Count for limit and ratelimit */
2544     was_rej_mail = TRUE;               /* Reset if accepted */
2545
2546     if (helo_required && !helo_seen)
2547       {
2548       smtp_printf("503 HELO or EHLO required\r\n");
2549       log_write(0, LOG_MAIN|LOG_REJECT, "rejected MAIL from %s: no "
2550         "HELO/EHLO given", host_and_ident(FALSE));
2551       break;
2552       }
2553
2554     if (sender_address != NULL)
2555       {
2556       done = synprot_error(L_smtp_protocol_error, 503, NULL,
2557         US"sender already given");
2558       break;
2559       }
2560
2561     if (smtp_data[0] == 0)
2562       {
2563       done = synprot_error(L_smtp_protocol_error, 501, NULL,
2564         US"MAIL must have an address operand");
2565       break;
2566       }
2567
2568     /* Check to see if the limit for messages per connection would be
2569     exceeded by accepting further messages. */
2570
2571     if (smtp_accept_max_per_connection > 0 &&
2572         smtp_mailcmd_count > smtp_accept_max_per_connection)
2573       {
2574       smtp_printf("421 too many messages in this connection\r\n");
2575       log_write(0, LOG_MAIN|LOG_REJECT, "rejected MAIL command %s: too many "
2576         "messages in one connection", host_and_ident(TRUE));
2577       break;
2578       }
2579
2580     /* Reset for start of message - even if this is going to fail, we
2581     obviously need to throw away any previous data. */
2582
2583     smtp_reset(reset_point);
2584     toomany = FALSE;
2585     sender_data = recipient_data = NULL;
2586
2587     /* Loop, checking for ESMTP additions to the MAIL FROM command. */
2588
2589     if (esmtp) for(;;)
2590       {
2591       uschar *name, *value, *end;
2592       unsigned long int size;
2593
2594       if (!extract_option(&name, &value)) break;
2595
2596       /* Handle SIZE= by reading the value. We don't do the check till later,
2597       in order to be able to log the sender address on failure. */
2598
2599       if (strcmpic(name, US"SIZE") == 0 &&
2600           ((size = (int)Ustrtoul(value, &end, 10)), *end == 0))
2601         {
2602         if ((size == ULONG_MAX && errno == ERANGE) || size > INT_MAX)
2603           size = INT_MAX;
2604         message_size = (int)size;
2605         }
2606
2607       /* If this session was initiated with EHLO and accept_8bitmime is set,
2608       Exim will have indicated that it supports the BODY=8BITMIME option. In
2609       fact, it does not support this according to the RFCs, in that it does not
2610       take any special action for forwarding messages containing 8-bit
2611       characters. That is why accept_8bitmime is not the default setting, but
2612       some sites want the action that is provided. We recognize both "8BITMIME"
2613       and "7BIT" as body types, but take no action. */
2614
2615       else if (accept_8bitmime && strcmpic(name, US"BODY") == 0 &&
2616           (strcmpic(value, US"8BITMIME") == 0 ||
2617            strcmpic(value, US"7BIT") == 0)) {}
2618
2619       /* Handle the AUTH extension. If the value given is not "<>" and either
2620       the ACL says "yes" or there is no ACL but the sending host is
2621       authenticated, we set it up as the authenticated sender. However, if the
2622       authenticator set a condition to be tested, we ignore AUTH on MAIL unless
2623       the condition is met. The value of AUTH is an xtext, which means that +,
2624       = and cntrl chars are coded in hex; however "<>" is unaffected by this
2625       coding. */
2626
2627       else if (strcmpic(name, US"AUTH") == 0)
2628         {
2629         if (Ustrcmp(value, "<>") != 0)
2630           {
2631           int rc;
2632           uschar *ignore_msg;
2633
2634           if (auth_xtextdecode(value, &authenticated_sender) < 0)
2635             {
2636             /* Put back terminator overrides for error message */
2637             name[-1] = ' ';
2638             value[-1] = '=';
2639             done = synprot_error(L_smtp_syntax_error, 501, NULL,
2640               US"invalid data for AUTH");
2641             goto COMMAND_LOOP;
2642             }
2643
2644           if (acl_smtp_mailauth == NULL)
2645             {
2646             ignore_msg = US"client not authenticated";
2647             rc = (sender_host_authenticated != NULL)? OK : FAIL;
2648             }
2649           else
2650             {
2651             ignore_msg = US"rejected by ACL";
2652             rc = acl_check(ACL_WHERE_MAILAUTH, NULL, acl_smtp_mailauth,
2653               &user_msg, &log_msg);
2654             }
2655
2656           switch (rc)
2657             {
2658             case OK:
2659             if (authenticated_by == NULL ||
2660                 authenticated_by->mail_auth_condition == NULL ||
2661                 expand_check_condition(authenticated_by->mail_auth_condition,
2662                     authenticated_by->name, US"authenticator"))
2663               break;     /* Accept the AUTH */
2664
2665             ignore_msg = US"server_mail_auth_condition failed";
2666             if (authenticated_id != NULL)
2667               ignore_msg = string_sprintf("%s: authenticated ID=\"%s\"",
2668                 ignore_msg, authenticated_id);
2669
2670             /* Fall through */
2671
2672             case FAIL:
2673             authenticated_sender = NULL;
2674             log_write(0, LOG_MAIN, "ignoring AUTH=%s from %s (%s)",
2675               value, host_and_ident(TRUE), ignore_msg);
2676             break;
2677
2678             /* Should only get DEFER or ERROR here. Put back terminator
2679             overrides for error message */
2680
2681             default:
2682             name[-1] = ' ';
2683             value[-1] = '=';
2684             (void)smtp_handle_acl_fail(ACL_WHERE_MAILAUTH, rc, user_msg,
2685               log_msg);
2686             goto COMMAND_LOOP;
2687             }
2688           }
2689         }
2690
2691       /* Unknown option. Stick back the terminator characters and break
2692       the loop. An error for a malformed address will occur. */
2693
2694       else
2695         {
2696         name[-1] = ' ';
2697         value[-1] = '=';
2698         break;
2699         }
2700       }
2701
2702     /* If we have passed the threshold for rate limiting, apply the current
2703     delay, and update it for next time, provided this is a limited host. */
2704
2705     if (smtp_mailcmd_count > smtp_rlm_threshold &&
2706         verify_check_host(&smtp_ratelimit_hosts) == OK)
2707       {
2708       DEBUG(D_receive) debug_printf("rate limit MAIL: delay %.3g sec\n",
2709         smtp_delay_mail/1000.0);
2710       millisleep((int)smtp_delay_mail);
2711       smtp_delay_mail *= smtp_rlm_factor;
2712       if (smtp_delay_mail > (double)smtp_rlm_limit)
2713         smtp_delay_mail = (double)smtp_rlm_limit;
2714       }
2715
2716     /* Now extract the address, first applying any SMTP-time rewriting. The
2717     TRUE flag allows "<>" as a sender address. */
2718
2719     raw_sender = ((rewrite_existflags & rewrite_smtp) != 0)?
2720       rewrite_one(smtp_data, rewrite_smtp, NULL, FALSE, US"",
2721         global_rewrite_rules) : smtp_data;
2722
2723     /* rfc821_domains = TRUE; << no longer needed */
2724     raw_sender =
2725       parse_extract_address(raw_sender, &errmess, &start, &end, &sender_domain,
2726         TRUE);
2727     /* rfc821_domains = FALSE; << no longer needed */
2728
2729     if (raw_sender == NULL)
2730       {
2731       done = synprot_error(L_smtp_syntax_error, 501, smtp_data, errmess);
2732       break;
2733       }
2734
2735     sender_address = raw_sender;
2736
2737     /* If there is a configured size limit for mail, check that this message
2738     doesn't exceed it. The check is postponed to this point so that the sender
2739     can be logged. */
2740
2741     if (thismessage_size_limit > 0 && message_size > thismessage_size_limit)
2742       {
2743       smtp_printf("552 Message size exceeds maximum permitted\r\n");
2744       log_write(L_size_reject,
2745           LOG_MAIN|LOG_REJECT, "rejected MAIL FROM:<%s> %s: "
2746           "message too big: size%s=%d max=%d",
2747           sender_address,
2748           host_and_ident(TRUE),
2749           (message_size == INT_MAX)? ">" : "",
2750           message_size,
2751           thismessage_size_limit);
2752       sender_address = NULL;
2753       break;
2754       }
2755
2756     /* Check there is enough space on the disk unless configured not to.
2757     When smtp_check_spool_space is set, the check is for thismessage_size_limit
2758     plus the current message - i.e. we accept the message only if it won't
2759     reduce the space below the threshold. Add 5000 to the size to allow for
2760     overheads such as the Received: line and storing of recipients, etc.
2761     By putting the check here, even when SIZE is not given, it allow VRFY
2762     and EXPN etc. to be used when space is short. */
2763
2764     if (!receive_check_fs(
2765          (smtp_check_spool_space && message_size >= 0)?
2766             message_size + 5000 : 0))
2767       {
2768       smtp_printf("452 Space shortage, please try later\r\n");
2769       sender_address = NULL;
2770       break;
2771       }
2772
2773     /* If sender_address is unqualified, reject it, unless this is a locally
2774     generated message, or the sending host or net is permitted to send
2775     unqualified addresses - typically local machines behaving as MUAs -
2776     in which case just qualify the address. The flag is set above at the start
2777     of the SMTP connection. */
2778
2779     if (sender_domain == 0 && sender_address[0] != 0)
2780       {
2781       if (allow_unqualified_sender)
2782         {
2783         sender_domain = Ustrlen(sender_address) + 1;
2784         sender_address = rewrite_address_qualify(sender_address, FALSE);
2785         DEBUG(D_receive) debug_printf("unqualified address %s accepted\n",
2786           raw_sender);
2787         }
2788       else
2789         {
2790         smtp_printf("501 %s: sender address must contain a domain\r\n",
2791           smtp_data);
2792         log_write(L_smtp_syntax_error,
2793           LOG_MAIN|LOG_REJECT,
2794           "unqualified sender rejected: <%s> %s%s",
2795           raw_sender,
2796           host_and_ident(TRUE),
2797           host_lookup_msg);
2798         sender_address = NULL;
2799         break;
2800         }
2801       }
2802
2803     /* Apply an ACL check if one is defined, before responding */
2804
2805     rc = (acl_smtp_mail == NULL)? OK :
2806       acl_check(ACL_WHERE_MAIL, NULL, acl_smtp_mail, &user_msg, &log_msg);
2807
2808     if (rc == OK || rc == DISCARD)
2809       {
2810       smtp_printf("250 OK\r\n");
2811       smtp_delay_rcpt = smtp_rlr_base;
2812       recipients_discarded = (rc == DISCARD);
2813       was_rej_mail = FALSE;
2814       }
2815
2816     else
2817       {
2818       done = smtp_handle_acl_fail(ACL_WHERE_MAIL, rc, user_msg, log_msg);
2819       sender_address = NULL;
2820       }
2821     break;
2822
2823
2824     /* The RCPT command requires an address as an operand. All we do
2825     here is to parse it for syntactic correctness. There may be any number
2826     of RCPT commands, specifying multiple senders. We build them all into
2827     a data structure that is in argc/argv format. The start/end values
2828     given by parse_extract_address are not used, as we keep only the
2829     extracted address. */
2830
2831     case RCPT_CMD:
2832     rcpt_count++;
2833     was_rcpt = TRUE;
2834
2835     /* There must be a sender address; if the sender was rejected and
2836     pipelining was advertised, we assume the client was pipelining, and do not
2837     count this as a protocol error. Reset was_rej_mail so that further RCPTs
2838     get the same treatment. */
2839
2840     if (sender_address == NULL)
2841       {
2842       if (pipelining_advertised && last_was_rej_mail)
2843         {
2844         smtp_printf("503 sender not yet given\r\n");
2845         was_rej_mail = TRUE;
2846         }
2847       else
2848         {
2849         done = synprot_error(L_smtp_protocol_error, 503, NULL,
2850           US"sender not yet given");
2851         was_rcpt = FALSE;             /* Not a valid RCPT */
2852         }
2853       rcpt_fail_count++;
2854       break;
2855       }
2856
2857     /* Check for an operand */
2858
2859     if (smtp_data[0] == 0)
2860       {
2861       done = synprot_error(L_smtp_syntax_error, 501, NULL,
2862         US"RCPT must have an address operand");
2863       rcpt_fail_count++;
2864       break;
2865       }
2866
2867     /* Apply SMTP rewriting then extract the working address. Don't allow "<>"
2868     as a recipient address */
2869
2870     recipient = ((rewrite_existflags & rewrite_smtp) != 0)?
2871       rewrite_one(smtp_data, rewrite_smtp, NULL, FALSE, US"",
2872         global_rewrite_rules) : smtp_data;
2873
2874     /* rfc821_domains = TRUE; << no longer needed */
2875     recipient = parse_extract_address(recipient, &errmess, &start, &end,
2876       &recipient_domain, FALSE);
2877     /* rfc821_domains = FALSE; << no longer needed */
2878
2879     if (recipient == NULL)
2880       {
2881       done = synprot_error(L_smtp_syntax_error, 501, smtp_data, errmess);
2882       rcpt_fail_count++;
2883       break;
2884       }
2885
2886     /* If the recipient address is unqualified, reject it, unless this is a
2887     locally generated message. However, unqualified addresses are permitted
2888     from a configured list of hosts and nets - typically when behaving as
2889     MUAs rather than MTAs. Sad that SMTP is used for both types of traffic,
2890     really. The flag is set at the start of the SMTP connection.
2891
2892     RFC 1123 talks about supporting "the reserved mailbox postmaster"; I always
2893     assumed this meant "reserved local part", but the revision of RFC 821 and
2894     friends now makes it absolutely clear that it means *mailbox*. Consequently
2895     we must always qualify this address, regardless. */
2896
2897     if (recipient_domain == 0)
2898       {
2899       if (allow_unqualified_recipient ||
2900           strcmpic(recipient, US"postmaster") == 0)
2901         {
2902         DEBUG(D_receive) debug_printf("unqualified address %s accepted\n",
2903           recipient);
2904         recipient_domain = Ustrlen(recipient) + 1;
2905         recipient = rewrite_address_qualify(recipient, TRUE);
2906         }
2907       else
2908         {
2909         rcpt_fail_count++;
2910         smtp_printf("501 %s: recipient address must contain a domain\r\n",
2911           smtp_data);
2912         log_write(L_smtp_syntax_error,
2913           LOG_MAIN|LOG_REJECT, "unqualified recipient rejected: "
2914           "<%s> %s%s", recipient, host_and_ident(TRUE),
2915           host_lookup_msg);
2916         break;
2917         }
2918       }
2919
2920     /* Check maximum allowed */
2921
2922     if (rcpt_count > recipients_max && recipients_max > 0)
2923       {
2924       if (recipients_max_reject)
2925         {
2926         rcpt_fail_count++;
2927         smtp_printf("552 too many recipients\r\n");
2928         if (!toomany)
2929           log_write(0, LOG_MAIN|LOG_REJECT, "too many recipients: message "
2930             "rejected: sender=<%s> %s", sender_address, host_and_ident(TRUE));
2931         }
2932       else
2933         {
2934         rcpt_defer_count++;
2935         smtp_printf("452 too many recipients\r\n");
2936         if (!toomany)
2937           log_write(0, LOG_MAIN|LOG_REJECT, "too many recipients: excess "
2938             "temporarily rejected: sender=<%s> %s", sender_address,
2939             host_and_ident(TRUE));
2940         }
2941
2942       toomany = TRUE;
2943       break;
2944       }
2945
2946     /* If we have passed the threshold for rate limiting, apply the current
2947     delay, and update it for next time, provided this is a limited host. */
2948
2949     if (rcpt_count > smtp_rlr_threshold &&
2950         verify_check_host(&smtp_ratelimit_hosts) == OK)
2951       {
2952       DEBUG(D_receive) debug_printf("rate limit RCPT: delay %.3g sec\n",
2953         smtp_delay_rcpt/1000.0);
2954       millisleep((int)smtp_delay_rcpt);
2955       smtp_delay_rcpt *= smtp_rlr_factor;
2956       if (smtp_delay_rcpt > (double)smtp_rlr_limit)
2957         smtp_delay_rcpt = (double)smtp_rlr_limit;
2958       }
2959
2960     /* If the MAIL ACL discarded all the recipients, we bypass ACL checking
2961     for them. Otherwise, check the access control list for this recipient. */
2962
2963     rc = recipients_discarded? DISCARD :
2964       acl_check(ACL_WHERE_RCPT, recipient, acl_smtp_rcpt, &user_msg, &log_msg);
2965
2966     /* The ACL was happy */
2967
2968     if (rc == OK)
2969       {
2970       smtp_printf("250 Accepted\r\n");
2971       receive_add_recipient(recipient, -1);
2972       }
2973
2974     /* The recipient was discarded */
2975
2976     else if (rc == DISCARD)
2977       {
2978       smtp_printf("250 Accepted\r\n");
2979       rcpt_fail_count++;
2980       discarded = TRUE;
2981       log_write(0, LOG_MAIN|LOG_REJECT, "%s F=<%s> rejected RCPT %s: "
2982         "discarded by %s ACL%s%s", host_and_ident(TRUE),
2983         (sender_address_unrewritten != NULL)?
2984         sender_address_unrewritten : sender_address,
2985         smtp_data, recipients_discarded? "MAIL" : "RCPT",
2986         (log_msg == NULL)? US"" : US": ",
2987         (log_msg == NULL)? US"" : log_msg);
2988       }
2989
2990     /* Either the ACL failed the address, or it was deferred. */
2991
2992     else
2993       {
2994       if (rc == FAIL) rcpt_fail_count++; else rcpt_defer_count++;
2995       done = smtp_handle_acl_fail(ACL_WHERE_RCPT, rc, user_msg, log_msg);
2996       }
2997     break;
2998
2999
3000     /* The DATA command is legal only if it follows successful MAIL FROM
3001     and RCPT TO commands. However, if pipelining is advertised, a bad DATA is
3002     not counted as a protocol error if it follows RCPT (which must have been
3003     rejected if there are no recipients.) This function is complete when a
3004     valid DATA command is encountered.
3005
3006     Note concerning the code used: RFC 2821 says this:
3007
3008      -  If there was no MAIL, or no RCPT, command, or all such commands
3009         were rejected, the server MAY return a "command out of sequence"
3010         (503) or "no valid recipients" (554) reply in response to the
3011         DATA command.
3012
3013     The example in the pipelining RFC 2920 uses 554, but I use 503 here
3014     because it is the same whether pipelining is in use or not. */
3015
3016     case DATA_CMD:
3017     if (!discarded && recipients_count <= 0)
3018       {
3019       if (pipelining_advertised && last_was_rcpt)
3020         smtp_printf("503 valid RCPT command must precede DATA\r\n");
3021       else
3022         done = synprot_error(L_smtp_protocol_error, 503, NULL,
3023           US"valid RCPT command must precede DATA");
3024       break;
3025       }
3026
3027     if (toomany && recipients_max_reject)
3028       {
3029       sender_address = NULL;  /* This will allow a new MAIL without RSET */
3030       sender_address_unrewritten = NULL;
3031       smtp_printf("554 Too many recipients\r\n");
3032       break;
3033       }
3034
3035     rc = (acl_smtp_predata == NULL)? OK :
3036       acl_check(ACL_WHERE_PREDATA, NULL, acl_smtp_predata, &user_msg, &log_msg);
3037
3038     if (rc == OK)
3039       {
3040       smtp_printf("354 Enter message, ending with \".\" on a line by itself\r\n");
3041       done = 3;
3042       message_ended = END_NOTENDED;   /* Indicate in middle of data */
3043       }
3044
3045     /* Either the ACL failed the address, or it was deferred. */
3046
3047     else
3048       done = smtp_handle_acl_fail(ACL_WHERE_PREDATA, rc, user_msg, log_msg);
3049
3050     break;
3051
3052
3053     case VRFY_CMD:
3054     rc = acl_check(ACL_WHERE_VRFY, smtp_data, acl_smtp_vrfy, &user_msg,
3055       &log_msg);
3056     if (rc != OK)
3057       done = smtp_handle_acl_fail(ACL_WHERE_VRFY, rc, user_msg, log_msg);
3058     else
3059       {
3060       uschar *address;
3061       uschar *s = NULL;
3062
3063       /* rfc821_domains = TRUE; << no longer needed */
3064       address = parse_extract_address(smtp_data, &errmess, &start, &end,
3065         &recipient_domain, FALSE);
3066       /* rfc821_domains = FALSE; << no longer needed */
3067
3068       if (address == NULL)
3069         s = string_sprintf("501 %s", errmess);
3070       else
3071         {
3072         address_item *addr = deliver_make_addr(address, FALSE);
3073         switch(verify_address(addr, NULL, vopt_is_recipient | vopt_qualify, -1,
3074                -1, NULL, NULL, NULL))
3075           {
3076           case OK:
3077           s = string_sprintf("250 <%s> is deliverable", address);
3078           break;
3079
3080           case DEFER:
3081           s = (addr->message != NULL)?
3082             string_sprintf("451 <%s> %s", address, addr->message) :
3083             string_sprintf("451 Cannot resolve <%s> at this time", address);
3084           break;
3085
3086           case FAIL:
3087           s = (addr->message != NULL)?
3088             string_sprintf("550 <%s> %s", address, addr->message) :
3089             string_sprintf("550 <%s> is not deliverable", address);
3090           log_write(0, LOG_MAIN, "VRFY failed for %s %s",
3091             smtp_data, host_and_ident(TRUE));
3092           break;
3093           }
3094         }
3095
3096       smtp_printf("%s\r\n", s);
3097       }
3098     break;
3099
3100
3101     case EXPN_CMD:
3102     rc = acl_check(ACL_WHERE_EXPN, smtp_data, acl_smtp_expn, &user_msg,
3103       &log_msg);
3104     if (rc != OK)
3105       done = smtp_handle_acl_fail(ACL_WHERE_EXPN, rc, user_msg, log_msg);
3106     else
3107       {
3108       BOOL save_log_testing_mode = log_testing_mode;
3109       address_test_mode = log_testing_mode = TRUE;
3110       (void) verify_address(deliver_make_addr(smtp_data, FALSE), smtp_out,
3111         vopt_is_recipient | vopt_qualify | vopt_expn, -1, -1, NULL, NULL, NULL);
3112       address_test_mode = FALSE;
3113       log_testing_mode = save_log_testing_mode;    /* true for -bh */
3114       }
3115     break;
3116
3117
3118     #ifdef SUPPORT_TLS
3119
3120     case STARTTLS_CMD:
3121     if (!tls_advertised)
3122       {
3123       done = synprot_error(L_smtp_protocol_error, 503, NULL,
3124         US"STARTTLS command used when not advertised");
3125       break;
3126       }
3127
3128     /* Apply an ACL check if one is defined */
3129
3130     if (acl_smtp_starttls != NULL)
3131       {
3132       rc = acl_check(ACL_WHERE_STARTTLS, NULL, acl_smtp_starttls, &user_msg,
3133         &log_msg);
3134       if (rc != OK)
3135         {
3136         done = smtp_handle_acl_fail(ACL_WHERE_STARTTLS, rc, user_msg, log_msg);
3137         break;
3138         }
3139       }
3140
3141     /* RFC 2487 is not clear on when this command may be sent, though it
3142     does state that all information previously obtained from the client
3143     must be discarded if a TLS session is started. It seems reasonble to
3144     do an implied RSET when STARTTLS is received. */
3145
3146     incomplete_transaction_log(US"STARTTLS");
3147     smtp_reset(reset_point);
3148     toomany = FALSE;
3149     cmd_list[CMD_LIST_STARTTLS].is_mail_cmd = FALSE;
3150
3151     /* Attempt to start up a TLS session, and if successful, discard all
3152     knowledge that was obtained previously. At least, that's what the RFC says,
3153     and that's what happens by default. However, in order to work round YAEB,
3154     there is an option to remember the esmtp state. Sigh.
3155
3156     We must allow for an extra EHLO command and an extra AUTH command after
3157     STARTTLS that don't add to the nonmail command count. */
3158
3159     if ((rc = tls_server_start(tls_require_ciphers)) == OK)
3160       {
3161       if (!tls_remember_esmtp)
3162         helo_seen = esmtp = auth_advertised = pipelining_advertised = FALSE;
3163       cmd_list[CMD_LIST_EHLO].is_mail_cmd = TRUE;
3164       cmd_list[CMD_LIST_AUTH].is_mail_cmd = TRUE;
3165       if (sender_helo_name != NULL)
3166         {
3167         store_free(sender_helo_name);
3168         sender_helo_name = NULL;
3169         host_build_sender_fullhost();  /* Rebuild */
3170         set_process_info("handling incoming TLS connection from %s",
3171           host_and_ident(FALSE));
3172         }
3173       received_protocol = (esmtp?
3174         protocols[pextend + pcrpted +
3175           ((sender_host_authenticated != NULL)? pauthed : 0)]
3176         :
3177         protocols[pnormal])
3178         +
3179         ((sender_host_address != NULL)? pnlocal : 0);
3180
3181       sender_host_authenticated = NULL;
3182       authenticated_id = NULL;
3183       sync_cmd_limit = NON_SYNC_CMD_NON_PIPELINING;
3184       DEBUG(D_tls) debug_printf("TLS active\n");
3185       break;     /* Successful STARTTLS */
3186       }
3187
3188     /* Some local configuration problem was discovered before actually trying
3189     to do a TLS handshake; give a temporary error. */
3190
3191     else if (rc == DEFER)
3192       {
3193       smtp_printf("454 TLS currently unavailable\r\n");
3194       break;
3195       }
3196
3197     /* Hard failure. Reject everything except QUIT or closed connection. One
3198     cause for failure is a nested STARTTLS, in which case tls_active remains
3199     set, but we must still reject all incoming commands. */
3200
3201     DEBUG(D_tls) debug_printf("TLS failed to start\n");
3202     while (done <= 0)
3203       {
3204       switch(smtp_read_command(FALSE))
3205         {
3206         case EOF_CMD:
3207         log_write(L_smtp_connection, LOG_MAIN, "%s closed by EOF",
3208           smtp_get_connection_info());
3209         done = 2;
3210         break;
3211
3212         case QUIT_CMD:
3213         smtp_printf("221 %s closing connection\r\n", smtp_active_hostname);
3214         log_write(L_smtp_connection, LOG_MAIN, "%s closed by QUIT",
3215           smtp_get_connection_info());
3216         done = 2;
3217         break;
3218
3219         default:
3220         smtp_printf("554 Security failure\r\n");
3221         break;
3222         }
3223       }
3224     tls_close(TRUE);
3225     break;
3226     #endif
3227
3228
3229     /* The ACL for QUIT is provided for gathering statistical information or
3230     similar; it does not affect the response code, but it can supply a custom
3231     message. */
3232
3233     case QUIT_CMD:
3234     incomplete_transaction_log(US"QUIT");
3235
3236     if (acl_smtp_quit != NULL)
3237       {
3238       rc = acl_check(ACL_WHERE_QUIT, US"", acl_smtp_quit,&user_msg,&log_msg);
3239       if (rc == ERROR)
3240         log_write(0, LOG_MAIN|LOG_PANIC, "ACL for QUIT returned ERROR: %s",
3241           log_msg);
3242       }
3243     else user_msg = NULL;
3244
3245     if (user_msg == NULL)
3246       smtp_printf("221 %s closing connection\r\n", smtp_active_hostname);
3247     else
3248       smtp_printf("221 %s\r\n", user_msg);
3249
3250     #ifdef SUPPORT_TLS
3251     tls_close(TRUE);
3252     #endif
3253
3254     done = 2;
3255     log_write(L_smtp_connection, LOG_MAIN, "%s closed by QUIT",
3256       smtp_get_connection_info());
3257     break;
3258
3259
3260     case RSET_CMD:
3261     incomplete_transaction_log(US"RSET");
3262     smtp_reset(reset_point);
3263     toomany = FALSE;
3264     smtp_printf("250 Reset OK\r\n");
3265     cmd_list[CMD_LIST_RSET].is_mail_cmd = FALSE;
3266     break;
3267
3268
3269     case NOOP_CMD:
3270     smtp_printf("250 OK\r\n");
3271     break;
3272
3273
3274     /* Show ETRN/EXPN/VRFY if there's
3275     an ACL for checking hosts; if actually used, a check will be done for
3276     permitted hosts. */
3277
3278     case HELP_CMD:
3279     smtp_printf("214-Commands supported:\r\n");
3280       {
3281       uschar buffer[256];
3282       buffer[0] = 0;
3283       Ustrcat(buffer, " AUTH");
3284       #ifdef SUPPORT_TLS
3285       Ustrcat(buffer, " STARTTLS");
3286       #endif
3287       Ustrcat(buffer, " HELO EHLO MAIL RCPT DATA");
3288       Ustrcat(buffer, " NOOP QUIT RSET HELP");
3289       if (acl_smtp_etrn != NULL) Ustrcat(buffer, " ETRN");
3290       if (acl_smtp_expn != NULL) Ustrcat(buffer, " EXPN");
3291       if (acl_smtp_vrfy != NULL) Ustrcat(buffer, " VRFY");
3292       smtp_printf("214%s\r\n", buffer);
3293       }
3294     break;
3295
3296
3297     case EOF_CMD:
3298     incomplete_transaction_log(US"connection lost");
3299     smtp_printf("421 %s lost input connection\r\n", smtp_active_hostname);
3300
3301     /* Don't log by default unless in the middle of a message, as some mailers
3302     just drop the call rather than sending QUIT, and it clutters up the logs.
3303     */
3304
3305     if (sender_address != NULL || recipients_count > 0)
3306       log_write(L_lost_incoming_connection,
3307           LOG_MAIN,
3308           "unexpected %s while reading SMTP command from %s%s",
3309           sender_host_unknown? "EOF" : "disconnection",
3310           host_and_ident(FALSE), smtp_read_error);
3311
3312     else log_write(L_smtp_connection, LOG_MAIN, "%s lost%s",
3313       smtp_get_connection_info(), smtp_read_error);
3314
3315     done = 1;
3316     break;
3317
3318
3319     case ETRN_CMD:
3320     if (sender_address != NULL)
3321       {
3322       done = synprot_error(L_smtp_protocol_error, 503, NULL,
3323         US"ETRN is not permitted inside a transaction");
3324       break;
3325       }
3326
3327     log_write(L_etrn, LOG_MAIN, "ETRN %s received from %s", smtp_data,
3328       host_and_ident(FALSE));
3329
3330     rc = acl_check(ACL_WHERE_ETRN, smtp_data, acl_smtp_etrn, &user_msg,
3331       &log_msg);
3332     if (rc != OK)
3333       {
3334       done = smtp_handle_acl_fail(ACL_WHERE_ETRN, rc, user_msg, log_msg);
3335       break;
3336       }
3337
3338     /* Compute the serialization key for this command. */
3339
3340     etrn_serialize_key = string_sprintf("etrn-%s\n", smtp_data);
3341
3342     /* If a command has been specified for running as a result of ETRN, we
3343     permit any argument to ETRN. If not, only the # standard form is permitted,
3344     since that is strictly the only kind of ETRN that can be implemented
3345     according to the RFC. */
3346
3347     if (smtp_etrn_command != NULL)
3348       {
3349       uschar *error;
3350       BOOL rc;
3351       etrn_command = smtp_etrn_command;
3352       deliver_domain = smtp_data;
3353       rc = transport_set_up_command(&argv, smtp_etrn_command, TRUE, 0, NULL,
3354         US"ETRN processing", &error);
3355       deliver_domain = NULL;
3356       if (!rc)
3357         {
3358         log_write(0, LOG_MAIN|LOG_PANIC, "failed to set up ETRN command: %s",
3359           error);
3360         smtp_printf("458 Internal failure\r\n");
3361         break;
3362         }
3363       }
3364
3365     /* Else set up to call Exim with the -R option. */
3366
3367     else
3368       {
3369       if (*smtp_data++ != '#')
3370         {
3371         done = synprot_error(L_smtp_syntax_error, 501, NULL,
3372           US"argument must begin with #");
3373         break;
3374         }
3375       etrn_command = US"exim -R";
3376       argv = child_exec_exim(CEE_RETURN_ARGV, TRUE, NULL, TRUE, 2, US"-R",
3377         smtp_data);
3378       }
3379
3380     /* If we are host-testing, don't actually do anything. */
3381
3382     if (host_checking)
3383       {
3384       HDEBUG(D_any)
3385         {
3386         debug_printf("ETRN command is: %s\n", etrn_command);
3387         debug_printf("ETRN command execution skipped\n");
3388         }
3389       smtp_printf("250 OK\r\n");
3390       break;
3391       }
3392
3393
3394     /* If ETRN queue runs are to be serialized, check the database to
3395     ensure one isn't already running. */
3396
3397     if (smtp_etrn_serialize && !enq_start(etrn_serialize_key))
3398       {
3399       smtp_printf("458 Already processing %s\r\n", smtp_data);
3400       break;
3401       }
3402
3403     /* Fork a child process and run the command. We don't want to have to
3404     wait for the process at any point, so set SIGCHLD to SIG_IGN before
3405     forking. It should be set that way anyway for external incoming SMTP,
3406     but we save and restore to be tidy. If serialization is required, we
3407     actually run the command in yet another process, so we can wait for it
3408     to complete and then remove the serialization lock. */
3409
3410     oldsignal = signal(SIGCHLD, SIG_IGN);
3411
3412     if ((pid = fork()) == 0)
3413       {
3414       smtp_input = FALSE;    /* This process is not associated with the */
3415       fclose(smtp_in);       /* SMTP call any more. */
3416       fclose(smtp_out);
3417
3418       signal(SIGCHLD, SIG_DFL);      /* Want to catch child */
3419
3420       /* If not serializing, do the exec right away. Otherwise, fork down
3421       into another process. */
3422
3423       if (!smtp_etrn_serialize || (pid = fork()) == 0)
3424         {
3425         DEBUG(D_exec) debug_print_argv(argv);
3426         exim_nullstd();                   /* Ensure std{in,out,err} exist */
3427         execv(CS argv[0], (char *const *)argv);
3428         log_write(0, LOG_MAIN|LOG_PANIC_DIE, "exec of \"%s\" (ETRN) failed: %s",
3429           etrn_command, strerror(errno));
3430         _exit(EXIT_FAILURE);         /* paranoia */
3431         }
3432
3433       /* Obey this if smtp_serialize and the 2nd fork yielded non-zero. That
3434       is, we are in the first subprocess, after forking again. All we can do
3435       for a failing fork is to log it. Otherwise, wait for the 2nd process to
3436       complete, before removing the serialization. */
3437
3438       if (pid < 0)
3439         log_write(0, LOG_MAIN|LOG_PANIC, "2nd fork for serialized ETRN "
3440           "failed: %s", strerror(errno));
3441       else
3442         {
3443         int status;
3444         DEBUG(D_any) debug_printf("waiting for serialized ETRN process %d\n",
3445           (int)pid);
3446         (void)wait(&status);
3447         DEBUG(D_any) debug_printf("serialized ETRN process %d ended\n",
3448           (int)pid);
3449         }
3450
3451       enq_end(etrn_serialize_key);
3452       _exit(EXIT_SUCCESS);
3453       }
3454
3455     /* Back in the top level SMTP process. Check that we started a subprocess
3456     and restore the signal state. */
3457
3458     if (pid < 0)
3459       {
3460       log_write(0, LOG_MAIN|LOG_PANIC, "fork of process for ETRN failed: %s",
3461         strerror(errno));
3462       smtp_printf("458 Unable to fork process\r\n");
3463       if (smtp_etrn_serialize) enq_end(etrn_serialize_key);
3464       }
3465     else smtp_printf("250 OK\r\n");
3466
3467     signal(SIGCHLD, oldsignal);
3468     break;
3469
3470
3471     case BADARG_CMD:
3472     done = synprot_error(L_smtp_syntax_error, 501, NULL,
3473       US"unexpected argument data");
3474     break;
3475
3476
3477     /* This currently happens only for NULLs, but could be extended. */
3478
3479     case BADCHAR_CMD:
3480     done = synprot_error(L_smtp_syntax_error, 0, NULL,       /* Just logs */
3481       US"NULL character(s) present (shown as '?')");
3482     smtp_printf("501 NULL characters are not allowed in SMTP commands\r\n");
3483     break;
3484
3485
3486     case BADSYN_CMD:
3487     if (smtp_inend >= smtp_inbuffer + in_buffer_size)
3488       smtp_inend = smtp_inbuffer + in_buffer_size - 1;
3489     c = smtp_inend - smtp_inptr;
3490     if (c > 150) c = 150;
3491     smtp_inptr[c] = 0;
3492     incomplete_transaction_log(US"sync failure");
3493     log_write(0, LOG_MAIN|LOG_REJECT, "SMTP protocol violation: "
3494       "synchronization error "
3495       "(next input sent too soon: pipelining was%s advertised): "
3496       "rejected \"%s\" %s next input=\"%s\"",
3497       pipelining_advertised? "" : " not",
3498       cmd_buffer, host_and_ident(TRUE),
3499       string_printing(smtp_inptr));
3500     smtp_printf("554 SMTP synchronization error\r\n");
3501     done = 1;   /* Pretend eof - drops connection */
3502     break;
3503
3504
3505     case TOO_MANY_NONMAIL_CMD:
3506     incomplete_transaction_log(US"too many non-mail commands");
3507     log_write(0, LOG_MAIN|LOG_REJECT, "SMTP call from %s dropped: too many "
3508       "nonmail commands (last was \"%.*s\")",  host_and_ident(FALSE),
3509       smtp_data - cmd_buffer, cmd_buffer);
3510     smtp_printf("554 Too many nonmail commands\r\n");
3511     done = 1;   /* Pretend eof - drops connection */
3512     break;
3513
3514
3515     default:
3516     if (unknown_command_count++ >= smtp_max_unknown_commands)
3517       {
3518       log_write(L_smtp_syntax_error, LOG_MAIN,
3519         "SMTP syntax error in \"%s\" %s %s",
3520         string_printing(cmd_buffer), host_and_ident(TRUE),
3521         US"unrecognized command");
3522       incomplete_transaction_log(US"unrecognized command");
3523       smtp_printf("500 Too many unrecognized commands\r\n");
3524       done = 2;
3525       log_write(0, LOG_MAIN|LOG_REJECT, "SMTP call from %s dropped: too many "
3526         "unrecognized commands (last was \"%s\")", host_and_ident(FALSE),
3527         cmd_buffer);
3528       }
3529     else
3530       done = synprot_error(L_smtp_syntax_error, 500, NULL,
3531         US"unrecognized command");
3532     break;
3533     }
3534
3535   /* This label is used by goto's inside loops that want to break out to
3536   the end of the command-processing loop. */
3537
3538   COMMAND_LOOP:
3539   last_was_rej_mail = was_rej_mail;     /* Remember some last commands for */
3540   last_was_rcpt = was_rcpt;             /* protocol error handling */
3541   continue;
3542   }
3543
3544 return done - 2;  /* Convert yield values */
3545 }
3546
3547 /* End of smtp_in.c */