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