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