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