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