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