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