src/src/smtp_in.c

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