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