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