src/src/smtp_in.c

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