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