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