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