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