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