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