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