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