src/src/smtp_in.c

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