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