src/src/smtp_in.c

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