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