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