src/src/smtp_in.c

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