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