src/src/smtp_in.c

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