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