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