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