a0ab1b873875ed1db1c778037dfee0f5eee61419
[users/heiko/exim.git] / src / src / verify.c
1 /*************************************************
2 *     Exim - an Internet mail transport agent    *
3 *************************************************/
4
5 /* Copyright (c) University of Cambridge 1995 - 2018 */
6 /* Copyright (c) The Exim Maintainers 2020 */
7 /* See the file NOTICE for conditions of use and distribution. */
8
9 /* Functions concerned with verifying things. The original code for callout
10 caching was contributed by Kevin Fleming (but I hacked it around a bit). */
11
12
13 #include "exim.h"
14 #include "transports/smtp.h"
15
16 #define CUTTHROUGH_CMD_TIMEOUT  30      /* timeout for cutthrough-routing calls */
17 #define CUTTHROUGH_DATA_TIMEOUT 60      /* timeout for cutthrough-routing calls */
18 static smtp_context ctctx;
19 uschar ctbuffer[8192];
20
21
22 /* Structure for caching DNSBL lookups */
23
24 typedef struct dnsbl_cache_block {
25   time_t expiry;
26   dns_address *rhs;
27   uschar *text;
28   int rc;
29   BOOL text_set;
30 } dnsbl_cache_block;
31
32
33 /* Anchor for DNSBL cache */
34
35 static tree_node *dnsbl_cache = NULL;
36
37
38 /* Bits for match_type in one_check_dnsbl() */
39
40 #define MT_NOT 1
41 #define MT_ALL 2
42
43 static uschar cutthrough_response(client_conn_ctx *, char, uschar **, int);
44
45
46
47 /*************************************************
48 *          Retrieve a callout cache record       *
49 *************************************************/
50
51 /* If a record exists, check whether it has expired.
52
53 Arguments:
54   dbm_file          an open hints file
55   key               the record key
56   type              "address" or "domain"
57   positive_expire   expire time for positive records
58   negative_expire   expire time for negative records
59
60 Returns:            the cache record if a non-expired one exists, else NULL
61 */
62
63 static dbdata_callout_cache *
64 get_callout_cache_record(open_db *dbm_file, const uschar *key, uschar *type,
65   int positive_expire, int negative_expire)
66 {
67 BOOL negative;
68 int length, expire;
69 time_t now;
70 dbdata_callout_cache *cache_record;
71
72 if (!(cache_record = dbfn_read_with_length(dbm_file, key, &length)))
73   {
74   HDEBUG(D_verify) debug_printf_indent("callout cache: no %s record found for %s\n", type, key);
75   return NULL;
76   }
77
78 /* We treat a record as "negative" if its result field is not positive, or if
79 it is a domain record and the postmaster field is negative. */
80
81 negative = cache_record->result != ccache_accept ||
82   (type[0] == 'd' && cache_record->postmaster_result == ccache_reject);
83 expire = negative? negative_expire : positive_expire;
84 now = time(NULL);
85
86 if (now - cache_record->time_stamp > expire)
87   {
88   HDEBUG(D_verify) debug_printf_indent("callout cache: %s record expired for %s\n", type, key);
89   return NULL;
90   }
91
92 /* If this is a non-reject domain record, check for the obsolete format version
93 that doesn't have the postmaster and random timestamps, by looking at the
94 length. If so, copy it to a new-style block, replicating the record's
95 timestamp. Then check the additional timestamps. (There's no point wasting
96 effort if connections are rejected.) */
97
98 if (type[0] == 'd' && cache_record->result != ccache_reject)
99   {
100   if (length == sizeof(dbdata_callout_cache_obs))
101     {
102     dbdata_callout_cache *new = store_get(sizeof(dbdata_callout_cache), FALSE);
103     memcpy(new, cache_record, length);
104     new->postmaster_stamp = new->random_stamp = new->time_stamp;
105     cache_record = new;
106     }
107
108   if (now - cache_record->postmaster_stamp > expire)
109     cache_record->postmaster_result = ccache_unknown;
110
111   if (now - cache_record->random_stamp > expire)
112     cache_record->random_result = ccache_unknown;
113   }
114
115 HDEBUG(D_verify) debug_printf_indent("callout cache: found %s record for %s\n", type, key);
116 return cache_record;
117 }
118
119
120
121 /* Check the callout cache.
122 Options * pm_mailfrom may be modified by cache partial results.
123
124 Return: TRUE if result found
125 */
126
127 static BOOL
128 cached_callout_lookup(address_item * addr, uschar * address_key,
129   uschar * from_address, int * opt_ptr, uschar ** pm_ptr,
130   int * yield, uschar ** failure_ptr,
131   dbdata_callout_cache * new_domain_record, int * old_domain_res)
132 {
133 int options = *opt_ptr;
134 open_db dbblock;
135 open_db *dbm_file = NULL;
136
137 /* Open the callout cache database, it it exists, for reading only at this
138 stage, unless caching has been disabled. */
139
140 if (options & vopt_callout_no_cache)
141   {
142   HDEBUG(D_verify) debug_printf_indent("callout cache: disabled by no_cache\n");
143   }
144 else if (!(dbm_file = dbfn_open(US"callout", O_RDWR, &dbblock, FALSE, TRUE)))
145   {
146   HDEBUG(D_verify) debug_printf_indent("callout cache: not available\n");
147   }
148 else
149   {
150   /* If a cache database is available see if we can avoid the need to do an
151   actual callout by making use of previously-obtained data. */
152
153   dbdata_callout_cache_address * cache_address_record;
154   dbdata_callout_cache * cache_record = get_callout_cache_record(dbm_file,
155       addr->domain, US"domain",
156       callout_cache_domain_positive_expire, callout_cache_domain_negative_expire);
157
158   /* If an unexpired cache record was found for this domain, see if the callout
159   process can be short-circuited. */
160
161   if (cache_record)
162     {
163     /* In most cases, if an early command (up to and including MAIL FROM:<>)
164     was rejected, there is no point carrying on. The callout fails. However, if
165     we are doing a recipient verification with use_sender or use_postmaster
166     set, a previous failure of MAIL FROM:<> doesn't count, because this time we
167     will be using a non-empty sender. We have to remember this situation so as
168     not to disturb the cached domain value if this whole verification succeeds
169     (we don't want it turning into "accept"). */
170
171     *old_domain_res = cache_record->result;
172
173     if (  cache_record->result == ccache_reject
174        || *from_address == 0 && cache_record->result == ccache_reject_mfnull)
175       {
176       HDEBUG(D_verify)
177         debug_printf_indent("callout cache: domain gave initial rejection, or "
178           "does not accept HELO or MAIL FROM:<>\n");
179       setflag(addr, af_verify_nsfail);
180       addr->user_message = US"(result of an earlier callout reused).";
181       *yield = FAIL;
182       *failure_ptr = US"mail";
183       dbfn_close(dbm_file);
184       return TRUE;
185       }
186
187     /* If a previous check on a "random" local part was accepted, we assume
188     that the server does not do any checking on local parts. There is therefore
189     no point in doing the callout, because it will always be successful. If a
190     random check previously failed, arrange not to do it again, but preserve
191     the data in the new record. If a random check is required but hasn't been
192     done, skip the remaining cache processing. */
193
194     if (options & vopt_callout_random) switch(cache_record->random_result)
195       {
196       case ccache_accept:
197         HDEBUG(D_verify)
198           debug_printf_indent("callout cache: domain accepts random addresses\n");
199         *failure_ptr = US"random";
200         dbfn_close(dbm_file);
201         return TRUE;     /* Default yield is OK */
202
203       case ccache_reject:
204         HDEBUG(D_verify)
205           debug_printf_indent("callout cache: domain rejects random addresses\n");
206         *opt_ptr = options & ~vopt_callout_random;
207         new_domain_record->random_result = ccache_reject;
208         new_domain_record->random_stamp = cache_record->random_stamp;
209         break;
210
211       default:
212         HDEBUG(D_verify)
213           debug_printf_indent("callout cache: need to check random address handling "
214             "(not cached or cache expired)\n");
215         dbfn_close(dbm_file);
216         return FALSE;
217       }
218
219     /* If a postmaster check is requested, but there was a previous failure,
220     there is again no point in carrying on. If a postmaster check is required,
221     but has not been done before, we are going to have to do a callout, so skip
222     remaining cache processing. */
223
224     if (*pm_ptr)
225       {
226       if (cache_record->postmaster_result == ccache_reject)
227         {
228         setflag(addr, af_verify_pmfail);
229         HDEBUG(D_verify)
230           debug_printf_indent("callout cache: domain does not accept "
231             "RCPT TO:<postmaster@domain>\n");
232         *yield = FAIL;
233         *failure_ptr = US"postmaster";
234         setflag(addr, af_verify_pmfail);
235         addr->user_message = US"(result of earlier verification reused).";
236         dbfn_close(dbm_file);
237         return TRUE;
238         }
239       if (cache_record->postmaster_result == ccache_unknown)
240         {
241         HDEBUG(D_verify)
242           debug_printf_indent("callout cache: need to check RCPT "
243             "TO:<postmaster@domain> (not cached or cache expired)\n");
244         dbfn_close(dbm_file);
245         return FALSE;
246         }
247
248       /* If cache says OK, set pm_mailfrom NULL to prevent a redundant
249       postmaster check if the address itself has to be checked. Also ensure
250       that the value in the cache record is preserved (with its old timestamp).
251       */
252
253       HDEBUG(D_verify) debug_printf_indent("callout cache: domain accepts RCPT "
254         "TO:<postmaster@domain>\n");
255       *pm_ptr = NULL;
256       new_domain_record->postmaster_result = ccache_accept;
257       new_domain_record->postmaster_stamp = cache_record->postmaster_stamp;
258       }
259     }
260
261   /* We can't give a result based on information about the domain. See if there
262   is an unexpired cache record for this specific address (combined with the
263   sender address if we are doing a recipient callout with a non-empty sender).
264   */
265
266   if (!(cache_address_record = (dbdata_callout_cache_address *)
267     get_callout_cache_record(dbm_file, address_key, US"address",
268       callout_cache_positive_expire, callout_cache_negative_expire)))
269     {
270     dbfn_close(dbm_file);
271     return FALSE;
272     }
273
274   if (cache_address_record->result == ccache_accept)
275     {
276     HDEBUG(D_verify)
277       debug_printf_indent("callout cache: address record is positive\n");
278     }
279   else
280     {
281     HDEBUG(D_verify)
282       debug_printf_indent("callout cache: address record is negative\n");
283     addr->user_message = US"Previous (cached) callout verification failure";
284     *failure_ptr = US"recipient";
285     *yield = FAIL;
286     }
287
288   /* Close the cache database while we actually do the callout for real. */
289
290   dbfn_close(dbm_file);
291   return TRUE;
292   }
293 return FALSE;
294 }
295
296
297 /* Write results to callout cache
298 */
299 static void
300 cache_callout_write(dbdata_callout_cache * dom_rec, const uschar * domain,
301   int done, dbdata_callout_cache_address * addr_rec, uschar * address_key)
302 {
303 open_db dbblock;
304 open_db *dbm_file = NULL;
305
306 /* If we get here with done == TRUE, a successful callout happened, and yield
307 will be set OK or FAIL according to the response to the RCPT command.
308 Otherwise, we looped through the hosts but couldn't complete the business.
309 However, there may be domain-specific information to cache in both cases.
310
311 The value of the result field in the new_domain record is ccache_unknown if
312 there was an error before or with MAIL FROM:, and errno was not zero,
313 implying some kind of I/O error. We don't want to write the cache in that case.
314 Otherwise the value is ccache_accept, ccache_reject, or ccache_reject_mfnull. */
315
316 if (dom_rec->result != ccache_unknown)
317   if (!(dbm_file = dbfn_open(US"callout", O_RDWR|O_CREAT, &dbblock, FALSE, TRUE)))
318     {
319     HDEBUG(D_verify) debug_printf_indent("callout cache: not available\n");
320     }
321   else
322     {
323     (void)dbfn_write(dbm_file, domain, dom_rec,
324       (int)sizeof(dbdata_callout_cache));
325     HDEBUG(D_verify) debug_printf_indent("wrote callout cache domain record for %s:\n"
326       "  result=%d postmaster=%d random=%d\n",
327       domain,
328       dom_rec->result,
329       dom_rec->postmaster_result,
330       dom_rec->random_result);
331     }
332
333 /* If a definite result was obtained for the callout, cache it unless caching
334 is disabled. */
335
336 if (done  &&  addr_rec->result != ccache_unknown)
337   {
338   if (!dbm_file)
339     dbm_file = dbfn_open(US"callout", O_RDWR|O_CREAT, &dbblock, FALSE, TRUE);
340   if (!dbm_file)
341     {
342     HDEBUG(D_verify) debug_printf_indent("no callout cache available\n");
343     }
344   else
345     {
346     (void)dbfn_write(dbm_file, address_key, addr_rec,
347       (int)sizeof(dbdata_callout_cache_address));
348     HDEBUG(D_verify) debug_printf_indent("wrote %s callout cache address record for %s\n",
349       addr_rec->result == ccache_accept ? "positive" : "negative",
350       address_key);
351     }
352   }
353
354 if (dbm_file) dbfn_close(dbm_file);
355 }
356
357
358 /* Cutthrough-multi.  If the existing cached cutthrough connection matches
359 the one we would make for a subsequent recipient, use it.  Send the RCPT TO
360 and check the result, nonpipelined as it may be wanted immediately for
361 recipient-verification.
362
363 It seems simpler to deal with this case separately from the main callout loop.
364 We will need to remember it has sent, or not, so that rcpt-acl tail code
365 can do it there for the non-rcpt-verify case.  For this we keep an addresscount.
366
367 Return: TRUE for a definitive result for the recipient
368 */
369 static int
370 cutthrough_multi(address_item * addr, host_item * host_list,
371   transport_feedback * tf, int * yield)
372 {
373 BOOL done = FALSE;
374
375 if (addr->transport == cutthrough.addr.transport)
376   for (host_item * host = host_list; host; host = host->next)
377     if (Ustrcmp(host->address, cutthrough.host.address) == 0)
378       {
379       int host_af;
380       uschar *interface = NULL;  /* Outgoing interface to use; NULL => any */
381       int port = 25;
382
383       deliver_host = host->name;
384       deliver_host_address = host->address;
385       deliver_host_port = host->port;
386       deliver_domain = addr->domain;
387       transport_name = addr->transport->name;
388
389       host_af = Ustrchr(host->address, ':') ? AF_INET6 : AF_INET;
390
391       if (  !smtp_get_interface(tf->interface, host_af, addr, &interface,
392               US"callout")
393          || !smtp_get_port(tf->port, addr, &port, US"callout")
394          )
395         log_write(0, LOG_MAIN|LOG_PANIC, "<%s>: %s", addr->address,
396           addr->message);
397
398       smtp_port_for_connect(host, port);
399
400       if (  (  interface == cutthrough.interface
401             || (  interface
402                && cutthrough.interface
403                && Ustrcmp(interface, cutthrough.interface) == 0
404             )  )
405          && host->port == cutthrough.host.port
406          )
407         {
408         uschar * resp = NULL;
409
410         /* Match!  Send the RCPT TO, set done from the response */
411         done =
412              smtp_write_command(&ctctx, SCMD_FLUSH, "RCPT TO:<%.1000s>\r\n",
413               transport_rcpt_address(addr,
414                  addr->transport->rcpt_include_affixes)) >= 0
415           && cutthrough_response(&cutthrough.cctx, '2', &resp,
416               CUTTHROUGH_DATA_TIMEOUT) == '2';
417
418         /* This would go horribly wrong if a callout fail was ignored by ACL.
419         We punt by abandoning cutthrough on a reject, like the
420         first-rcpt does. */
421
422         if (done)
423           {
424           address_item * na = store_get(sizeof(address_item), FALSE);
425           *na = cutthrough.addr;
426           cutthrough.addr = *addr;
427           cutthrough.addr.host_used = &cutthrough.host;
428           cutthrough.addr.next = na;
429
430           cutthrough.nrcpt++;
431           }
432         else
433           {
434           cancel_cutthrough_connection(TRUE, US"recipient rejected");
435           if (!resp || errno == ETIMEDOUT)
436             {
437             HDEBUG(D_verify) debug_printf("SMTP timeout\n");
438             }
439           else if (errno == 0)
440             {
441             if (*resp == 0)
442               Ustrcpy(resp, US"connection dropped");
443
444             addr->message =
445               string_sprintf("response to \"%s\" was: %s",
446                 big_buffer, string_printing(resp));
447
448             addr->user_message =
449               string_sprintf("Callout verification failed:\n%s", resp);
450
451             /* Hard rejection ends the process */
452
453             if (resp[0] == '5')   /* Address rejected */
454               {
455               *yield = FAIL;
456               done = TRUE;
457               }
458             }
459           }
460         }
461       break;    /* host_list */
462       }
463 if (!done)
464   cancel_cutthrough_connection(TRUE, US"incompatible connection");
465 return done;
466 }
467
468
469 /*************************************************
470 *      Do callout verification for an address    *
471 *************************************************/
472
473 /* This function is called from verify_address() when the address has routed to
474 a host list, and a callout has been requested. Callouts are expensive; that is
475 why a cache is used to improve the efficiency.
476
477 Arguments:
478   addr              the address that's been routed
479   host_list         the list of hosts to try
480   tf                the transport feedback block
481
482   ifstring          "interface" option from transport, or NULL
483   portstring        "port" option from transport, or NULL
484   protocolstring    "protocol" option from transport, or NULL
485   callout           the per-command callout timeout
486   callout_overall   the overall callout timeout (if < 0 use 4*callout)
487   callout_connect   the callout connection timeout (if < 0 use callout)
488   options           the verification options - these bits are used:
489                       vopt_is_recipient => this is a recipient address
490                       vopt_callout_no_cache => don't use callout cache
491                       vopt_callout_fullpm => if postmaster check, do full one
492                       vopt_callout_random => do the "random" thing
493                       vopt_callout_recipsender => use real sender for recipient
494                       vopt_callout_recippmaster => use postmaster for recipient
495                       vopt_callout_hold         => lazy close connection
496   se_mailfrom         MAIL FROM address for sender verify; NULL => ""
497   pm_mailfrom         if non-NULL, do the postmaster check with this sender
498
499 Returns:            OK/FAIL/DEFER
500 */
501
502 static int
503 do_callout(address_item *addr, host_item *host_list, transport_feedback *tf,
504   int callout, int callout_overall, int callout_connect, int options,
505   uschar *se_mailfrom, uschar *pm_mailfrom)
506 {
507 int yield = OK;
508 int old_domain_cache_result = ccache_accept;
509 BOOL done = FALSE;
510 uschar *address_key;
511 uschar *from_address;
512 uschar *random_local_part = NULL;
513 const uschar *save_deliver_domain = deliver_domain;
514 uschar **failure_ptr = options & vopt_is_recipient
515   ? &recipient_verify_failure : &sender_verify_failure;
516 dbdata_callout_cache new_domain_record;
517 dbdata_callout_cache_address new_address_record;
518 time_t callout_start_time;
519
520 new_domain_record.result = ccache_unknown;
521 new_domain_record.postmaster_result = ccache_unknown;
522 new_domain_record.random_result = ccache_unknown;
523
524 memset(&new_address_record, 0, sizeof(new_address_record));
525
526 /* For a recipient callout, the key used for the address cache record must
527 include the sender address if we are using the real sender in the callout,
528 because that may influence the result of the callout. */
529
530 if (options & vopt_is_recipient)
531   if (options & vopt_callout_recipsender)
532     {
533     from_address = sender_address;
534     address_key = string_sprintf("%s/<%s>", addr->address, sender_address);
535     if (cutthrough.delivery) options |= vopt_callout_no_cache;
536     }
537   else if (options & vopt_callout_recippmaster)
538     {
539     from_address = string_sprintf("postmaster@%s", qualify_domain_sender);
540     address_key = string_sprintf("%s/<postmaster@%s>", addr->address,
541       qualify_domain_sender);
542     }
543   else
544     {
545     from_address = US"";
546     address_key = addr->address;
547     }
548
549 /* For a sender callout, we must adjust the key if the mailfrom address is not
550 empty. */
551
552 else
553   {
554   from_address = se_mailfrom ? se_mailfrom : US"";
555   address_key = *from_address
556     ? string_sprintf("%s/<%s>", addr->address, from_address) : addr->address;
557   }
558
559 if (cached_callout_lookup(addr, address_key, from_address,
560       &options, &pm_mailfrom, &yield, failure_ptr,
561       &new_domain_record, &old_domain_cache_result))
562   {
563   cancel_cutthrough_connection(TRUE, US"cache-hit");
564   goto END_CALLOUT;
565   }
566
567 if (!addr->transport)
568   {
569   HDEBUG(D_verify) debug_printf("cannot callout via null transport\n");
570   }
571
572 else if (Ustrcmp(addr->transport->driver_name, "smtp") != 0)
573   log_write(0, LOG_MAIN|LOG_PANIC|LOG_CONFIG_FOR, "callout transport '%s': %s is non-smtp",
574     addr->transport->name, addr->transport->driver_name);
575 else
576   {
577   smtp_transport_options_block *ob =
578     (smtp_transport_options_block *)addr->transport->options_block;
579   smtp_context * sx = NULL;
580
581   /* The information wasn't available in the cache, so we have to do a real
582   callout and save the result in the cache for next time, unless no_cache is set,
583   or unless we have a previously cached negative random result. If we are to test
584   with a random local part, ensure that such a local part is available. If not,
585   log the fact, but carry on without randomising. */
586
587   if (options & vopt_callout_random  &&  callout_random_local_part)
588     if (!(random_local_part = expand_string(callout_random_local_part)))
589       log_write(0, LOG_MAIN|LOG_PANIC, "failed to expand "
590         "callout_random_local_part: %s", expand_string_message);
591
592   /* Compile regex' used by client-side smtp */
593
594   smtp_deliver_init();
595
596   /* Default the connect and overall callout timeouts if not set, and record the
597   time we are starting so that we can enforce it. */
598
599   if (callout_overall < 0) callout_overall = 4 * callout;
600   if (callout_connect < 0) callout_connect = callout;
601   callout_start_time = time(NULL);
602
603   /* Before doing a real callout, if this is an SMTP connection, flush the SMTP
604   output because a callout might take some time. When PIPELINING is active and
605   there are many recipients, the total time for doing lots of callouts can add up
606   and cause the client to time out. So in this case we forgo the PIPELINING
607   optimization. */
608
609   if (smtp_out && !f.disable_callout_flush) mac_smtp_fflush();
610
611   clearflag(addr, af_verify_pmfail);  /* postmaster callout flag */
612   clearflag(addr, af_verify_nsfail);  /* null sender callout flag */
613
614 /* cutthrough-multi: if a nonfirst rcpt has the same routing as the first,
615 and we are holding a cutthrough conn open, we can just append the rcpt to
616 that conn for verification purposes (and later delivery also).  Simplest
617 coding means skipping this whole loop and doing the append separately.  */
618
619   /* Can we re-use an open cutthrough connection? */
620   if (  cutthrough.cctx.sock >= 0
621      && (options & (vopt_callout_recipsender | vopt_callout_recippmaster))
622         == vopt_callout_recipsender
623      && !random_local_part
624      && !pm_mailfrom
625      )
626     done = cutthrough_multi(addr, host_list, tf, &yield);
627
628   /* If we did not use a cached connection, make connections to the hosts
629   and do real callouts. The list of hosts is passed in as an argument. */
630
631   for (host_item * host = host_list; host && !done; host = host->next)
632     {
633     int host_af;
634     int port = 25;
635     uschar * interface = NULL;  /* Outgoing interface to use; NULL => any */
636
637     if (!host->address)
638       {
639       DEBUG(D_verify) debug_printf("no IP address for host name %s: skipping\n",
640         host->name);
641       continue;
642       }
643
644     /* Check the overall callout timeout */
645
646     if (time(NULL) - callout_start_time >= callout_overall)
647       {
648       HDEBUG(D_verify) debug_printf("overall timeout for callout exceeded\n");
649       break;
650       }
651
652     /* Set IPv4 or IPv6 */
653
654     host_af = Ustrchr(host->address, ':') ? AF_INET6 : AF_INET;
655
656     /* Expand and interpret the interface and port strings. The latter will not
657     be used if there is a host-specific port (e.g. from a manualroute router).
658     This has to be delayed till now, because they may expand differently for
659     different hosts. If there's a failure, log it, but carry on with the
660     defaults. */
661
662     deliver_host = host->name;
663     deliver_host_address = host->address;
664     deliver_host_port = host->port;
665     deliver_domain = addr->domain;
666     transport_name = addr->transport->name;
667
668     if (  !smtp_get_interface(tf->interface, host_af, addr, &interface,
669             US"callout")
670        || !smtp_get_port(tf->port, addr, &port, US"callout")
671        )
672       log_write(0, LOG_MAIN|LOG_PANIC, "<%s>: %s", addr->address,
673         addr->message);
674
675     if (!sx) sx = store_get(sizeof(*sx), TRUE); /* tainted buffers */
676     memset(sx, 0, sizeof(*sx));
677
678     sx->addrlist = addr;
679     sx->conn_args.host = host;
680     sx->conn_args.host_af = host_af,
681     sx->port = port;
682     sx->conn_args.interface = interface;
683     sx->helo_data = tf->helo_data;
684     sx->conn_args.tblock = addr->transport;
685     sx->verify = TRUE;
686
687 tls_retry_connection:
688     /* Set the address state so that errors are recorded in it */
689
690     addr->transport_return = PENDING_DEFER;
691     ob->connect_timeout = callout_connect;
692     ob->command_timeout = callout;
693
694     /* Get the channel set up ready for a message (MAIL FROM being the next
695     SMTP command to send.  If we tried TLS but it failed, try again without
696     if permitted */
697
698     yield = smtp_setup_conn(sx, FALSE);
699 #ifndef DISABLE_TLS
700     if (  yield == DEFER
701        && addr->basic_errno == ERRNO_TLSFAILURE
702        && ob->tls_tempfail_tryclear
703        && verify_check_given_host(CUSS &ob->hosts_require_tls, host) != OK
704        )
705       {
706       log_write(0, LOG_MAIN,
707         "%s: callout unencrypted to %s [%s] (not in hosts_require_tls)",
708         addr->message, host->name, host->address);
709       addr->transport_return = PENDING_DEFER;
710       yield = smtp_setup_conn(sx, TRUE);
711       }
712 #endif
713     if (yield != OK)
714       {
715       errno = addr->basic_errno;
716       transport_name = NULL;
717       deliver_host = deliver_host_address = NULL;
718       deliver_domain = save_deliver_domain;
719
720       /* Failure to accept HELO is cached; this blocks the whole domain for all
721       senders. I/O errors and defer responses are not cached. */
722
723       if (yield == FAIL && (errno == 0 || errno == ERRNO_SMTPCLOSED))
724         {
725         setflag(addr, af_verify_nsfail);
726         new_domain_record.result = ccache_reject;
727         done = TRUE;
728         }
729       else
730         done = FALSE;
731       goto no_conn;
732       }
733
734     /* If we needed to authenticate, smtp_setup_conn() did that.  Copy
735     the AUTH info for logging */
736
737     addr->authenticator = client_authenticator;
738     addr->auth_id = client_authenticated_id;
739
740     sx->from_addr = from_address;
741     sx->first_addr = sx->sync_addr = addr;
742     sx->ok = FALSE;                     /*XXX these 3 last might not be needed for verify? */
743     sx->send_rset = TRUE;
744     sx->completed_addr = FALSE;
745
746     new_domain_record.result = old_domain_cache_result == ccache_reject_mfnull
747       ? ccache_reject_mfnull : ccache_accept;
748
749     /* Do the random local part check first. Temporarily replace the recipient
750     with the "random" value */
751
752     if (random_local_part)
753       {
754       uschar * main_address = addr->address;
755       const uschar * rcpt_domain = addr->domain;
756
757 #ifdef SUPPORT_I18N
758       uschar * errstr = NULL;
759       if (  testflag(addr, af_utf8_downcvt)
760          && (rcpt_domain = string_domain_utf8_to_alabel(rcpt_domain,
761                                     &errstr), errstr)
762          )
763         {
764         addr->message = errstr;
765         errno = ERRNO_EXPANDFAIL;
766         setflag(addr, af_verify_nsfail);
767         done = FALSE;
768         rcpt_domain = US"";  /*XXX errorhandling! */
769         }
770 #endif
771
772       /* This would be ok for 1st rcpt of a cutthrough (the case handled here;
773       subsequents are done in cutthrough_multi()), but no way to
774       handle a subsequent because of the RSET vaporising the MAIL FROM.
775       So refuse to support any.  Most cutthrough use will not involve
776       random_local_part, so no loss. */
777       cancel_cutthrough_connection(TRUE, US"random-recipient");
778
779       addr->address = string_sprintf("%s@%.1000s",
780                                     random_local_part, rcpt_domain);
781       done = FALSE;
782
783       /* If accepted, we aren't going to do any further tests below.
784       Otherwise, cache a real negative response, and get back to the right
785       state to send RCPT. Unless there's some problem such as a dropped
786       connection, we expect to succeed, because the commands succeeded above.
787       However, some servers drop the connection after responding to an
788       invalid recipient, so on (any) error we drop and remake the connection.
789       XXX We don't care about that for postmaster_full.  Should we?
790
791       XXX could we add another flag to the context, and have the common
792       code emit the RSET too?  Even pipelined after the RCPT...
793       Then the main-verify call could use it if there's to be a subsequent
794       postmaster-verify.
795       The sync_responses() would need to be taught about it and we'd
796       need another return code filtering out to here.
797
798       Avoid using a SIZE option on the MAIL for all random-rcpt checks.
799       */
800
801       sx->avoid_option = OPTION_SIZE;
802
803       /* Remember when we last did a random test */
804       new_domain_record.random_stamp = time(NULL);
805
806       if (smtp_write_mail_and_rcpt_cmds(sx, &yield) == 0)
807         switch(addr->transport_return)
808           {
809           case PENDING_OK:      /* random was accepted, unfortunately */
810             new_domain_record.random_result = ccache_accept;
811             yield = OK;         /* Only usable verify result we can return */
812             done = TRUE;
813             *failure_ptr = US"random";
814             goto no_conn;
815           case FAIL:            /* rejected: the preferred result */
816             new_domain_record.random_result = ccache_reject;
817             sx->avoid_option = 0;
818
819             /* Between each check, issue RSET, because some servers accept only
820             one recipient after MAIL FROM:<>.
821             XXX We don't care about that for postmaster_full.  Should we? */
822
823             if ((done =
824               smtp_write_command(sx, SCMD_FLUSH, "RSET\r\n") >= 0 &&
825               smtp_read_response(sx, sx->buffer, sizeof(sx->buffer), '2', callout)))
826               break;
827
828             HDEBUG(D_acl|D_v)
829               debug_printf_indent("problem after random/rset/mfrom; reopen conn\n");
830             random_local_part = NULL;
831 #ifndef DISABLE_TLS
832             tls_close(sx->cctx.tls_ctx, TLS_SHUTDOWN_NOWAIT);
833 #endif
834             HDEBUG(D_transport|D_acl|D_v) debug_printf_indent("  SMTP(close)>>\n");
835             (void)close(sx->cctx.sock);
836             sx->cctx.sock = -1;
837 #ifndef DISABLE_EVENT
838             (void) event_raise(addr->transport->event_action,
839                               US"tcp:close", NULL);
840 #endif
841             addr->address = main_address;
842             addr->transport_return = PENDING_DEFER;
843             sx->first_addr = sx->sync_addr = addr;
844             sx->ok = FALSE;
845             sx->send_rset = TRUE;
846             sx->completed_addr = FALSE;
847             goto tls_retry_connection;
848           case DEFER:           /* 4xx response to random */
849             break;              /* Just to be clear. ccache_unknown, !done. */
850           }
851
852       /* Re-setup for main verify, or for the error message when failing */
853       addr->address = main_address;
854       addr->transport_return = PENDING_DEFER;
855       sx->first_addr = sx->sync_addr = addr;
856       sx->ok = FALSE;
857       sx->send_rset = TRUE;
858       sx->completed_addr = FALSE;
859       }
860     else
861       done = TRUE;
862
863     /* Main verify.  For rcpt-verify use SIZE if we know it and we're not cacheing;
864     for sndr-verify never use it. */
865
866     if (done)
867       {
868       if (!(options & vopt_is_recipient  &&  options & vopt_callout_no_cache))
869         sx->avoid_option = OPTION_SIZE;
870
871       done = FALSE;
872       switch(smtp_write_mail_and_rcpt_cmds(sx, &yield))
873         {
874         case 0:  switch(addr->transport_return) /* ok so far */
875                     {
876                     case PENDING_OK:  done = TRUE;
877                                       new_address_record.result = ccache_accept;
878                                       break;
879                     case FAIL:        done = TRUE;
880                                       yield = FAIL;
881                                       *failure_ptr = US"recipient";
882                                       new_address_record.result = ccache_reject;
883                                       break;
884                     default:          break;
885                     }
886                   break;
887
888         case -1:                                /* MAIL response error */
889                   *failure_ptr = US"mail";
890                   if (errno == 0 && sx->buffer[0] == '5')
891                     {
892                     setflag(addr, af_verify_nsfail);
893                     if (from_address[0] == 0)
894                       new_domain_record.result = ccache_reject_mfnull;
895                     }
896                   break;
897                                                 /* non-MAIL read i/o error */
898                                                 /* non-MAIL response timeout */
899                                                 /* internal error; channel still usable */
900         default:  break;                        /* transmit failed */
901         }
902       }
903
904     addr->auth_sndr = client_authenticated_sender;
905
906     deliver_host = deliver_host_address = NULL;
907     deliver_domain = save_deliver_domain;
908
909     /* Do postmaster check if requested; if a full check is required, we
910     check for RCPT TO:<postmaster> (no domain) in accordance with RFC 821. */
911
912     if (done && pm_mailfrom)
913       {
914       /* Could possibly shift before main verify, just above, and be ok
915       for cutthrough.  But no way to handle a subsequent rcpt, so just
916       refuse any */
917       cancel_cutthrough_connection(TRUE, US"postmaster verify");
918       HDEBUG(D_acl|D_v) debug_printf_indent("Cutthrough cancelled by presence of postmaster verify\n");
919
920       done = smtp_write_command(sx, SCMD_FLUSH, "RSET\r\n") >= 0
921           && smtp_read_response(sx, sx->buffer, sizeof(sx->buffer), '2', callout);
922
923       if (done)
924         {
925         uschar * main_address = addr->address;
926
927         /*XXX oops, affixes */
928         addr->address = string_sprintf("postmaster@%.1000s", addr->domain);
929         addr->transport_return = PENDING_DEFER;
930
931         sx->from_addr = pm_mailfrom;
932         sx->first_addr = sx->sync_addr = addr;
933         sx->ok = FALSE;
934         sx->send_rset = TRUE;
935         sx->completed_addr = FALSE;
936         sx->avoid_option = OPTION_SIZE;
937
938         if(  smtp_write_mail_and_rcpt_cmds(sx, &yield) == 0
939           && addr->transport_return == PENDING_OK
940           )
941           done = TRUE;
942         else
943           done = (options & vopt_callout_fullpm) != 0
944               && smtp_write_command(sx, SCMD_FLUSH,
945                             "RCPT TO:<postmaster>\r\n") >= 0
946               && smtp_read_response(sx, sx->buffer,
947                             sizeof(sx->buffer), '2', callout);
948
949         /* Sort out the cache record */
950
951         new_domain_record.postmaster_stamp = time(NULL);
952
953         if (done)
954           new_domain_record.postmaster_result = ccache_accept;
955         else if (errno == 0 && sx->buffer[0] == '5')
956           {
957           *failure_ptr = US"postmaster";
958           setflag(addr, af_verify_pmfail);
959           new_domain_record.postmaster_result = ccache_reject;
960           }
961
962         addr->address = main_address;
963         }
964       }
965     /* For any failure of the main check, other than a negative response, we just
966     close the connection and carry on. We can identify a negative response by the
967     fact that errno is zero. For I/O errors it will be non-zero
968
969     Set up different error texts for logging and for sending back to the caller
970     as an SMTP response. Log in all cases, using a one-line format. For sender
971     callouts, give a full response to the caller, but for recipient callouts,
972     don't give the IP address because this may be an internal host whose identity
973     is not to be widely broadcast. */
974
975 no_conn:
976     switch(errno)
977       {
978       case ETIMEDOUT:
979         HDEBUG(D_verify) debug_printf("SMTP timeout\n");
980         sx->send_quit = FALSE;
981         break;
982
983 #ifdef SUPPORT_I18N
984       case ERRNO_UTF8_FWD:
985         {
986         extern int acl_where;   /* src/acl.c */
987         errno = 0;
988         addr->message = US"response to \"EHLO\" did not include SMTPUTF8";
989         addr->user_message = acl_where == ACL_WHERE_RCPT
990           ? US"533 no support for internationalised mailbox name"
991           : US"550 mailbox unavailable";
992         yield = FAIL;
993         done = TRUE;
994         }
995         break;
996 #endif
997       case ECONNREFUSED:
998         sx->send_quit = FALSE;
999         break;
1000
1001       case 0:
1002         if (*sx->buffer == 0) Ustrcpy(sx->buffer, US"connection dropped");
1003
1004         /*XXX test here is ugly; seem to have a split of responsibility for
1005         building this message.  Need to rationalise.  Where is it done
1006         before here, and when not?
1007         Not == 5xx resp to MAIL on main-verify
1008         */
1009         if (!addr->message) addr->message =
1010           string_sprintf("response to \"%s\" was: %s",
1011                           big_buffer, string_printing(sx->buffer));
1012
1013         /* RFC 5321 section 4.2: the text portion of the response may have only
1014         HT, SP, Printable US-ASCII.  Deal with awkward chars by cutting the
1015         received message off before passing it onward.  Newlines are ok; they
1016         just become a multiline response (but wrapped in the error code we
1017         produce). */
1018
1019         for (uschar * s = sx->buffer;
1020              *s && s < sx->buffer + sizeof(sx->buffer);
1021              s++)
1022           {
1023           uschar c = *s;
1024           if (c != '\t' && c != '\n' && (c < ' ' || c > '~'))
1025             {
1026             if (s - sx->buffer < sizeof(sx->buffer) - 12)
1027               memcpy(s, "(truncated)", 12);
1028             else
1029               *s = '\0';
1030             break;
1031             }
1032           }
1033         addr->user_message = options & vopt_is_recipient
1034           ? string_sprintf("Callout verification failed:\n%s", sx->buffer)
1035           : string_sprintf("Called:   %s\nSent:     %s\nResponse: %s",
1036             host->address, big_buffer, sx->buffer);
1037
1038         /* Hard rejection ends the process */
1039
1040         if (sx->buffer[0] == '5')   /* Address rejected */
1041           {
1042           yield = FAIL;
1043           done = TRUE;
1044           }
1045         break;
1046       }
1047
1048     /* End the SMTP conversation and close the connection. */
1049
1050     /* Cutthrough - on a successful connect and recipient-verify with
1051     use-sender and we are 1st rcpt and have no cutthrough conn so far
1052     here is where we want to leave the conn open.  Ditto for a lazy-close
1053     verify. */
1054
1055     if (cutthrough.delivery)
1056       {
1057       if (addr->transport->filter_command)
1058         {
1059         cutthrough.delivery= FALSE;
1060         HDEBUG(D_acl|D_v) debug_printf("Cutthrough cancelled by presence of transport filter\n");
1061         }
1062 #ifndef DISABLE_DKIM
1063       if (ob->dkim.dkim_domain)
1064         {
1065         cutthrough.delivery= FALSE;
1066         HDEBUG(D_acl|D_v) debug_printf("Cutthrough cancelled by presence of DKIM signing\n");
1067         }
1068 #endif
1069 #ifdef EXPERIMENTAL_ARC
1070       if (ob->arc_sign)
1071         {
1072         cutthrough.delivery= FALSE;
1073         HDEBUG(D_acl|D_v) debug_printf("Cutthrough cancelled by presence of ARC signing\n");
1074         }
1075 #endif
1076       }
1077
1078     if (  (cutthrough.delivery || options & vopt_callout_hold)
1079        && rcpt_count == 1
1080        && done
1081        && yield == OK
1082        &&    (options & (vopt_callout_recipsender|vopt_callout_recippmaster|vopt_success_on_redirect))
1083            == vopt_callout_recipsender
1084        && !random_local_part
1085        && !pm_mailfrom
1086        && cutthrough.cctx.sock < 0
1087        && !sx->lmtp
1088        )
1089       {
1090       HDEBUG(D_acl|D_v) debug_printf_indent("holding verify callout open for %s\n",
1091         cutthrough.delivery
1092         ? "cutthrough delivery" : "potential further verifies and delivery");
1093
1094       cutthrough.callout_hold_only = !cutthrough.delivery;
1095       cutthrough.is_tls =       tls_out.active.sock >= 0;
1096       /* We assume no buffer in use in the outblock */
1097       cutthrough.cctx =         sx->cctx;
1098       cutthrough.nrcpt =        1;
1099       cutthrough.transport =    addr->transport->name;
1100       cutthrough.interface =    interface;
1101       cutthrough.snd_port =     sending_port;
1102       cutthrough.peer_options = smtp_peer_options;
1103       cutthrough.host =         *host;
1104         {
1105         int oldpool = store_pool;
1106         store_pool = POOL_PERM;
1107         cutthrough.snd_ip = string_copy(sending_ip_address);
1108         cutthrough.host.name = string_copy(host->name);
1109         cutthrough.host.address = string_copy(host->address);
1110         store_pool = oldpool;
1111         }
1112
1113       /* Save the address_item and parent chain for later logging */
1114       cutthrough.addr =         *addr;
1115       cutthrough.addr.next =    NULL;
1116       cutthrough.addr.host_used = &cutthrough.host;
1117       for (address_item * caddr = &cutthrough.addr, * parent = addr->parent;
1118            parent;
1119            caddr = caddr->parent, parent = parent->parent)
1120         *(caddr->parent = store_get(sizeof(address_item), FALSE)) = *parent;
1121
1122       ctctx.outblock.buffer = ctbuffer;
1123       ctctx.outblock.buffersize = sizeof(ctbuffer);
1124       ctctx.outblock.ptr = ctbuffer;
1125       /* ctctx.outblock.cmd_count = 0; ctctx.outblock.authenticating = FALSE; */
1126       ctctx.outblock.cctx = &cutthrough.cctx;
1127       }
1128     else
1129       {
1130       /* Ensure no cutthrough on multiple verifies that were incompatible */
1131       if (options & vopt_callout_recipsender)
1132         cancel_cutthrough_connection(TRUE, US"not usable for cutthrough");
1133       if (sx->send_quit)
1134         if (smtp_write_command(sx, SCMD_FLUSH, "QUIT\r\n") != -1)
1135           /* Wait a short time for response, and discard it */
1136           smtp_read_response(sx, sx->buffer, sizeof(sx->buffer), '2', 1);
1137
1138       if (sx->cctx.sock >= 0)
1139         {
1140 #ifndef DISABLE_TLS
1141         if (sx->cctx.tls_ctx)
1142           {
1143           tls_close(sx->cctx.tls_ctx, TLS_SHUTDOWN_NOWAIT);
1144           sx->cctx.tls_ctx = NULL;
1145           }
1146 #endif
1147         HDEBUG(D_transport|D_acl|D_v) debug_printf_indent("  SMTP(close)>>\n");
1148         (void)close(sx->cctx.sock);
1149         sx->cctx.sock = -1;
1150 #ifndef DISABLE_EVENT
1151         (void) event_raise(addr->transport->event_action, US"tcp:close", NULL);
1152 #endif
1153         }
1154       }
1155
1156     if (!done || yield != OK)
1157       addr->message = string_sprintf("%s [%s] : %s", host->name, host->address,
1158                                     addr->message);
1159     }    /* Loop through all hosts, while !done */
1160   }
1161
1162 /* If we get here with done == TRUE, a successful callout happened, and yield
1163 will be set OK or FAIL according to the response to the RCPT command.
1164 Otherwise, we looped through the hosts but couldn't complete the business.
1165 However, there may be domain-specific information to cache in both cases. */
1166
1167 if (!(options & vopt_callout_no_cache))
1168   cache_callout_write(&new_domain_record, addr->domain,
1169     done, &new_address_record, address_key);
1170
1171 /* Failure to connect to any host, or any response other than 2xx or 5xx is a
1172 temporary error. If there was only one host, and a response was received, leave
1173 it alone if supplying details. Otherwise, give a generic response. */
1174
1175 if (!done)
1176   {
1177   uschar * dullmsg = string_sprintf("Could not complete %s verify callout",
1178     options & vopt_is_recipient ? "recipient" : "sender");
1179   yield = DEFER;
1180
1181   addr->message = host_list->next || !addr->message
1182     ? dullmsg : string_sprintf("%s: %s", dullmsg, addr->message);
1183
1184   addr->user_message = smtp_return_error_details
1185     ? string_sprintf("%s for <%s>.\n"
1186       "The mail server(s) for the domain may be temporarily unreachable, or\n"
1187       "they may be permanently unreachable from this server. In the latter case,\n%s",
1188       dullmsg, addr->address,
1189       options & vopt_is_recipient
1190         ? "the address will never be accepted."
1191         : "you need to change the address or create an MX record for its domain\n"
1192           "if it is supposed to be generally accessible from the Internet.\n"
1193           "Talk to your mail administrator for details.")
1194     : dullmsg;
1195
1196   /* Force a specific error code */
1197
1198   addr->basic_errno = ERRNO_CALLOUTDEFER;
1199   }
1200
1201 /* Come here from within the cache-reading code on fast-track exit. */
1202
1203 END_CALLOUT:
1204 tls_modify_variables(&tls_in);  /* return variables to inbound values */
1205 return yield;
1206 }
1207
1208
1209
1210 /* Called after recipient-acl to get a cutthrough connection open when
1211    one was requested and a recipient-verify wasn't subsequently done.
1212 */
1213 int
1214 open_cutthrough_connection(address_item * addr)
1215 {
1216 address_item addr2;
1217 int rc;
1218
1219 /* Use a recipient-verify-callout to set up the cutthrough connection. */
1220 /* We must use a copy of the address for verification, because it might
1221 get rewritten. */
1222
1223 addr2 = *addr;
1224 HDEBUG(D_acl) debug_printf_indent("----------- %s cutthrough setup ------------\n",
1225   rcpt_count > 1 ? "more" : "start");
1226 rc = verify_address(&addr2, NULL,
1227         vopt_is_recipient | vopt_callout_recipsender | vopt_callout_no_cache,
1228         CUTTHROUGH_CMD_TIMEOUT, -1, -1,
1229         NULL, NULL, NULL);
1230 addr->message = addr2.message;
1231 addr->user_message = addr2.user_message;
1232 HDEBUG(D_acl) debug_printf_indent("----------- end cutthrough setup ------------\n");
1233 return rc;
1234 }
1235
1236
1237
1238 /* Send given number of bytes from the buffer */
1239 static BOOL
1240 cutthrough_send(int n)
1241 {
1242 if(cutthrough.cctx.sock < 0)
1243   return TRUE;
1244
1245 if(
1246 #ifndef DISABLE_TLS
1247    cutthrough.is_tls
1248    ? tls_write(cutthrough.cctx.tls_ctx, ctctx.outblock.buffer, n, FALSE)
1249    :
1250 #endif
1251      send(cutthrough.cctx.sock, ctctx.outblock.buffer, n, 0) > 0
1252   )
1253 {
1254   transport_count += n;
1255   ctctx.outblock.ptr= ctctx.outblock.buffer;
1256   return TRUE;
1257 }
1258
1259 HDEBUG(D_transport|D_acl) debug_printf_indent("cutthrough_send failed: %s\n", strerror(errno));
1260 return FALSE;
1261 }
1262
1263
1264
1265 static BOOL
1266 _cutthrough_puts(uschar * cp, int n)
1267 {
1268 while(n--)
1269  {
1270  if(ctctx.outblock.ptr >= ctctx.outblock.buffer+ctctx.outblock.buffersize)
1271    if(!cutthrough_send(ctctx.outblock.buffersize))
1272      return FALSE;
1273
1274  *ctctx.outblock.ptr++ = *cp++;
1275  }
1276 return TRUE;
1277 }
1278
1279 /* Buffered output of counted data block.   Return boolean success */
1280 static BOOL
1281 cutthrough_puts(uschar * cp, int n)
1282 {
1283 if (cutthrough.cctx.sock < 0) return TRUE;
1284 if (_cutthrough_puts(cp, n))  return TRUE;
1285 cancel_cutthrough_connection(TRUE, US"transmit failed");
1286 return FALSE;
1287 }
1288
1289 void
1290 cutthrough_data_puts(uschar * cp, int n)
1291 {
1292 if (cutthrough.delivery) (void) cutthrough_puts(cp, n);
1293 return;
1294 }
1295
1296
1297 static BOOL
1298 _cutthrough_flush_send(void)
1299 {
1300 int n = ctctx.outblock.ptr - ctctx.outblock.buffer;
1301
1302 if(n>0)
1303   if(!cutthrough_send(n))
1304     return FALSE;
1305 return TRUE;
1306 }
1307
1308
1309 /* Send out any bufferred output.  Return boolean success. */
1310 BOOL
1311 cutthrough_flush_send(void)
1312 {
1313 if (_cutthrough_flush_send()) return TRUE;
1314 cancel_cutthrough_connection(TRUE, US"transmit failed");
1315 return FALSE;
1316 }
1317
1318
1319 static BOOL
1320 cutthrough_put_nl(void)
1321 {
1322 return cutthrough_puts(US"\r\n", 2);
1323 }
1324
1325
1326 void
1327 cutthrough_data_put_nl(void)
1328 {
1329 cutthrough_data_puts(US"\r\n", 2);
1330 }
1331
1332
1333 /* Get and check response from cutthrough target */
1334 static uschar
1335 cutthrough_response(client_conn_ctx * cctx, char expect, uschar ** copy, int timeout)
1336 {
1337 smtp_context sx = {0};
1338 uschar inbuffer[4096];
1339 uschar responsebuffer[4096];
1340
1341 sx.inblock.buffer = inbuffer;
1342 sx.inblock.buffersize = sizeof(inbuffer);
1343 sx.inblock.ptr = inbuffer;
1344 sx.inblock.ptrend = inbuffer;
1345 sx.inblock.cctx = cctx;
1346 if(!smtp_read_response(&sx, responsebuffer, sizeof(responsebuffer), expect, timeout))
1347   cancel_cutthrough_connection(TRUE, US"target timeout on read");
1348
1349 if(copy)
1350   {
1351   uschar * cp;
1352   *copy = cp = string_copy(responsebuffer);
1353   /* Trim the trailing end of line */
1354   cp += Ustrlen(responsebuffer);
1355   if(cp > *copy  &&  cp[-1] == '\n') *--cp = '\0';
1356   if(cp > *copy  &&  cp[-1] == '\r') *--cp = '\0';
1357   }
1358
1359 return responsebuffer[0];
1360 }
1361
1362
1363 /* Negotiate dataphase with the cutthrough target, returning success boolean */
1364 BOOL
1365 cutthrough_predata(void)
1366 {
1367 if(cutthrough.cctx.sock < 0 || cutthrough.callout_hold_only)
1368   return FALSE;
1369
1370 HDEBUG(D_transport|D_acl|D_v) debug_printf_indent("  SMTP>> DATA\n");
1371 cutthrough_puts(US"DATA\r\n", 6);
1372 cutthrough_flush_send();
1373
1374 /* Assume nothing buffered.  If it was it gets ignored. */
1375 return cutthrough_response(&cutthrough.cctx, '3', NULL, CUTTHROUGH_DATA_TIMEOUT) == '3';
1376 }
1377
1378
1379 /* tctx arg only to match write_chunk() */
1380 static BOOL
1381 cutthrough_write_chunk(transport_ctx * tctx, uschar * s, int len)
1382 {
1383 uschar * s2;
1384 while(s && (s2 = Ustrchr(s, '\n')))
1385  {
1386  if(!cutthrough_puts(s, s2-s) || !cutthrough_put_nl())
1387   return FALSE;
1388  s = s2+1;
1389  }
1390 return TRUE;
1391 }
1392
1393
1394 /* Buffered send of headers.  Return success boolean. */
1395 /* Expands newlines to wire format (CR,NL).           */
1396 /* Also sends header-terminating blank line.          */
1397 BOOL
1398 cutthrough_headers_send(void)
1399 {
1400 transport_ctx tctx;
1401
1402 if(cutthrough.cctx.sock < 0 || cutthrough.callout_hold_only)
1403   return FALSE;
1404
1405 /* We share a routine with the mainline transport to handle header add/remove/rewrites,
1406    but having a separate buffered-output function (for now)
1407 */
1408 HDEBUG(D_acl) debug_printf_indent("----------- start cutthrough headers send -----------\n");
1409
1410 tctx.u.fd = cutthrough.cctx.sock;
1411 tctx.tblock = cutthrough.addr.transport;
1412 tctx.addr = &cutthrough.addr;
1413 tctx.check_string = US".";
1414 tctx.escape_string = US"..";
1415 /*XXX check under spool_files_wireformat.  Might be irrelevant */
1416 tctx.options = topt_use_crlf;
1417
1418 if (!transport_headers_send(&tctx, &cutthrough_write_chunk))
1419   return FALSE;
1420
1421 HDEBUG(D_acl) debug_printf_indent("----------- done cutthrough headers send ------------\n");
1422 return TRUE;
1423 }
1424
1425
1426 static void
1427 close_cutthrough_connection(const uschar * why)
1428 {
1429 int fd = cutthrough.cctx.sock;
1430 if(fd >= 0)
1431   {
1432   /* We could be sending this after a bunch of data, but that is ok as
1433      the only way to cancel the transfer in dataphase is to drop the tcp
1434      conn before the final dot.
1435   */
1436   client_conn_ctx tmp_ctx = cutthrough.cctx;
1437   ctctx.outblock.ptr = ctbuffer;
1438   HDEBUG(D_transport|D_acl|D_v) debug_printf_indent("  SMTP>> QUIT\n");
1439   _cutthrough_puts(US"QUIT\r\n", 6);    /* avoid recursion */
1440   _cutthrough_flush_send();
1441   cutthrough.cctx.sock = -1;            /* avoid recursion via read timeout */
1442   cutthrough.nrcpt = 0;                 /* permit re-cutthrough on subsequent message */
1443
1444   /* Wait a short time for response, and discard it */
1445   cutthrough_response(&tmp_ctx, '2', NULL, 1);
1446
1447 #ifndef DISABLE_TLS
1448   if (cutthrough.is_tls)
1449     {
1450     tls_close(cutthrough.cctx.tls_ctx, TLS_SHUTDOWN_NOWAIT);
1451     cutthrough.cctx.tls_ctx = NULL;
1452     cutthrough.is_tls = FALSE;
1453     }
1454 #endif
1455   HDEBUG(D_transport|D_acl|D_v) debug_printf_indent("  SMTP(close)>>\n");
1456   (void)close(fd);
1457   HDEBUG(D_acl) debug_printf_indent("----------- cutthrough shutdown (%s) ------------\n", why);
1458   }
1459 ctctx.outblock.ptr = ctbuffer;
1460 }
1461
1462 void
1463 cancel_cutthrough_connection(BOOL close_noncutthrough_verifies, const uschar * why)
1464 {
1465 if (cutthrough.delivery || close_noncutthrough_verifies)
1466   close_cutthrough_connection(why);
1467 cutthrough.delivery = cutthrough.callout_hold_only = FALSE;
1468 }
1469
1470
1471 void
1472 release_cutthrough_connection(const uschar * why)
1473 {
1474 if (cutthrough.cctx.sock < 0) return;
1475 HDEBUG(D_acl) debug_printf_indent("release cutthrough conn: %s\n", why);
1476 cutthrough.cctx.sock = -1;
1477 cutthrough.cctx.tls_ctx = NULL;
1478 cutthrough.delivery = cutthrough.callout_hold_only = FALSE;
1479 }
1480
1481
1482
1483
1484 /* Have senders final-dot.  Send one to cutthrough target, and grab the response.
1485    Log an OK response as a transmission.
1486    Close the connection.
1487    Return smtp response-class digit.
1488 */
1489 uschar *
1490 cutthrough_finaldot(void)
1491 {
1492 uschar res;
1493 HDEBUG(D_transport|D_acl|D_v) debug_printf_indent("  SMTP>> .\n");
1494
1495 /* Assume data finshed with new-line */
1496 if(  !cutthrough_puts(US".", 1)
1497   || !cutthrough_put_nl()
1498   || !cutthrough_flush_send()
1499   )
1500   return cutthrough.addr.message;
1501
1502 res = cutthrough_response(&cutthrough.cctx, '2', &cutthrough.addr.message,
1503         CUTTHROUGH_DATA_TIMEOUT);
1504 for (address_item * addr = &cutthrough.addr; addr; addr = addr->next)
1505   {
1506   addr->message = cutthrough.addr.message;
1507   switch(res)
1508     {
1509     case '2':
1510       delivery_log(LOG_MAIN, addr, (int)'>', NULL);
1511       close_cutthrough_connection(US"delivered");
1512       break;
1513
1514     case '4':
1515       delivery_log(LOG_MAIN, addr, 0,
1516         US"tmp-reject from cutthrough after DATA:");
1517       break;
1518
1519     case '5':
1520       delivery_log(LOG_MAIN|LOG_REJECT, addr, 0,
1521         US"rejected after DATA:");
1522       break;
1523
1524     default:
1525       break;
1526     }
1527   }
1528 return cutthrough.addr.message;
1529 }
1530
1531
1532
1533 /*************************************************
1534 *           Copy error to toplevel address       *
1535 *************************************************/
1536
1537 /* This function is used when a verify fails or defers, to ensure that the
1538 failure or defer information is in the original toplevel address. This applies
1539 when an address is redirected to a single new address, and the failure or
1540 deferral happens to the child address.
1541
1542 Arguments:
1543   vaddr       the verify address item
1544   addr        the final address item
1545   yield       FAIL or DEFER
1546
1547 Returns:      the value of YIELD
1548 */
1549
1550 static int
1551 copy_error(address_item *vaddr, address_item *addr, int yield)
1552 {
1553 if (addr != vaddr)
1554   {
1555   vaddr->message = addr->message;
1556   vaddr->user_message = addr->user_message;
1557   vaddr->basic_errno = addr->basic_errno;
1558   vaddr->more_errno = addr->more_errno;
1559   vaddr->prop.address_data = addr->prop.address_data;
1560   vaddr->prop.variables = NULL;
1561   tree_dup((tree_node **)&vaddr->prop.variables, addr->prop.variables);
1562   copyflag(vaddr, addr, af_pass_message);
1563   }
1564 return yield;
1565 }
1566
1567
1568
1569
1570 /**************************************************
1571 * printf that automatically handles TLS if needed *
1572 ***************************************************/
1573
1574 /* This function is used by verify_address() as a substitute for all fprintf()
1575 calls; a direct fprintf() will not produce output in a TLS SMTP session, such
1576 as a response to an EXPN command.  smtp_in.c makes smtp_printf available but
1577 that assumes that we always use the smtp_out FILE* when not using TLS or the
1578 ssl buffer when we are.  Instead we take a FILE* parameter and check to see if
1579 that is smtp_out; if so, smtp_printf() with TLS support, otherwise regular
1580 fprintf().
1581
1582 Arguments:
1583   f           the candidate FILE* to write to
1584   format      format string
1585   ...         optional arguments
1586
1587 Returns:
1588               nothing
1589 */
1590
1591 static void PRINTF_FUNCTION(2,3)
1592 respond_printf(FILE *f, const char *format, ...)
1593 {
1594 va_list ap;
1595
1596 va_start(ap, format);
1597 if (smtp_out && (f == smtp_out))
1598   smtp_vprintf(format, FALSE, ap);
1599 else
1600   vfprintf(f, format, ap);
1601 va_end(ap);
1602 }
1603
1604
1605
1606 /*************************************************
1607 *            Verify an email address             *
1608 *************************************************/
1609
1610 /* This function is used both for verification (-bv and at other times) and
1611 address testing (-bt), which is indicated by address_test_mode being set.
1612
1613 Arguments:
1614   vaddr            contains the address to verify; the next field in this block
1615                      must be NULL
1616   fp               if not NULL, write the result to this file
1617   options          various option bits:
1618                      vopt_fake_sender => this sender verify is not for the real
1619                        sender (it was verify=sender=xxxx or an address from a
1620                        header line) - rewriting must not change sender_address
1621                      vopt_is_recipient => this is a recipient address, otherwise
1622                        it's a sender address - this affects qualification and
1623                        rewriting and messages from callouts
1624                      vopt_qualify => qualify an unqualified address; else error
1625                      vopt_expn => called from SMTP EXPN command
1626                      vopt_success_on_redirect => when a new address is generated
1627                        the verification instantly succeeds
1628
1629                      These ones are used by do_callout() -- the options variable
1630                        is passed to it.
1631
1632                      vopt_callout_fullpm => if postmaster check, do full one
1633                      vopt_callout_no_cache => don't use callout cache
1634                      vopt_callout_random => do the "random" thing
1635                      vopt_callout_recipsender => use real sender for recipient
1636                      vopt_callout_recippmaster => use postmaster for recipient
1637
1638   callout          if > 0, specifies that callout is required, and gives timeout
1639                      for individual commands
1640   callout_overall  if > 0, gives overall timeout for the callout function;
1641                    if < 0, a default is used (see do_callout())
1642   callout_connect  the connection timeout for callouts
1643   se_mailfrom      when callout is requested to verify a sender, use this
1644                      in MAIL FROM; NULL => ""
1645   pm_mailfrom      when callout is requested, if non-NULL, do the postmaster
1646                      thing and use this as the sender address (may be "")
1647
1648   routed           if not NULL, set TRUE if routing succeeded, so we can
1649                      distinguish between routing failed and callout failed
1650
1651 Returns:           OK      address verified
1652                    FAIL    address failed to verify
1653                    DEFER   can't tell at present
1654 */
1655
1656 int
1657 verify_address(address_item * vaddr, FILE * fp, int options, int callout,
1658   int callout_overall, int callout_connect, uschar * se_mailfrom,
1659   uschar *pm_mailfrom, BOOL *routed)
1660 {
1661 BOOL allok = TRUE;
1662 BOOL full_info = fp ? debug_selector != 0 : FALSE;
1663 BOOL expn         = (options & vopt_expn) != 0;
1664 BOOL success_on_redirect = (options & vopt_success_on_redirect) != 0;
1665 int i;
1666 int yield = OK;
1667 int verify_type = expn ? v_expn :
1668    f.address_test_mode ? v_none :
1669           options & vopt_is_recipient ? v_recipient : v_sender;
1670 address_item *addr_list;
1671 address_item *addr_new = NULL;
1672 address_item *addr_remote = NULL;
1673 address_item *addr_local = NULL;
1674 address_item *addr_succeed = NULL;
1675 uschar **failure_ptr = options & vopt_is_recipient
1676   ? &recipient_verify_failure : &sender_verify_failure;
1677 uschar *ko_prefix, *cr;
1678 uschar *address = vaddr->address;
1679 uschar *save_sender;
1680 uschar null_sender[] = { 0 };             /* Ensure writeable memory */
1681
1682 /* Clear, just in case */
1683
1684 *failure_ptr = NULL;
1685
1686 /* Set up a prefix and suffix for error message which allow us to use the same
1687 output statements both in EXPN mode (where an SMTP response is needed) and when
1688 debugging with an output file. */
1689
1690 if (expn)
1691   {
1692   ko_prefix = US"553 ";
1693   cr = US"\r";
1694   }
1695 else ko_prefix = cr = US"";
1696
1697 /* Add qualify domain if permitted; otherwise an unqualified address fails. */
1698
1699 if (parse_find_at(address) == NULL)
1700   {
1701   if (!(options & vopt_qualify))
1702     {
1703     if (fp)
1704       respond_printf(fp, "%sA domain is required for \"%s\"%s\n",
1705         ko_prefix, address, cr);
1706     *failure_ptr = US"qualify";
1707     return FAIL;
1708     }
1709   address = rewrite_address_qualify(address, options & vopt_is_recipient);
1710   }
1711
1712 DEBUG(D_verify)
1713   {
1714   debug_printf(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n");
1715   debug_printf("%s %s\n", f.address_test_mode? "Testing" : "Verifying", address);
1716   }
1717
1718 /* Rewrite and report on it. Clear the domain and local part caches - these
1719 may have been set by domains and local part tests during an ACL. */
1720
1721 if (global_rewrite_rules)
1722   {
1723   uschar *old = address;
1724   address = rewrite_address(address, options & vopt_is_recipient, FALSE,
1725     global_rewrite_rules, rewrite_existflags);
1726   if (address != old)
1727     {
1728     for (int i = 0; i < (MAX_NAMED_LIST * 2)/32; i++) vaddr->localpart_cache[i] = 0;
1729     for (int i = 0; i < (MAX_NAMED_LIST * 2)/32; i++) vaddr->domain_cache[i] = 0;
1730     if (fp && !expn) fprintf(fp, "Address rewritten as: %s\n", address);
1731     }
1732   }
1733
1734 /* If this is the real sender address, we must update sender_address at
1735 this point, because it may be referred to in the routers. */
1736
1737 if (!(options & (vopt_fake_sender|vopt_is_recipient)))
1738   sender_address = address;
1739
1740 /* If the address was rewritten to <> no verification can be done, and we have
1741 to return OK. This rewriting is permitted only for sender addresses; for other
1742 addresses, such rewriting fails. */
1743
1744 if (!address[0]) return OK;
1745
1746 /* Flip the legacy TLS-related variables over to the outbound set in case
1747 they're used in the context of a transport used by verification. Reset them
1748 at exit from this routine (so no returns allowed from here on). */
1749
1750 tls_modify_variables(&tls_out);
1751
1752 /* Save a copy of the sender address for re-instating if we change it to <>
1753 while verifying a sender address (a nice bit of self-reference there). */
1754
1755 save_sender = sender_address;
1756
1757 /* Observability variable for router/transport use */
1758
1759 verify_mode = options & vopt_is_recipient ? US"R" : US"S";
1760
1761 /* Update the address structure with the possibly qualified and rewritten
1762 address. Set it up as the starting address on the chain of new addresses. */
1763
1764 vaddr->address = address;
1765 addr_new = vaddr;
1766
1767 /* We need a loop, because an address can generate new addresses. We must also
1768 cope with generated pipes and files at the top level. (See also the code and
1769 comment in deliver.c.) However, it is usually the case that the router for
1770 user's .forward files has its verify flag turned off.
1771
1772 If an address generates more than one child, the loop is used only when
1773 full_info is set, and this can only be set locally. Remote enquiries just get
1774 information about the top level address, not anything that it generated. */
1775
1776 while (addr_new)
1777   {
1778   int rc;
1779   address_item *addr = addr_new;
1780
1781   addr_new = addr->next;
1782   addr->next = NULL;
1783
1784   DEBUG(D_verify)
1785     {
1786     debug_printf(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n");
1787     debug_printf("Considering %s\n", addr->address);
1788     }
1789
1790   /* Handle generated pipe, file or reply addresses. We don't get these
1791   when handling EXPN, as it does only one level of expansion. */
1792
1793   if (testflag(addr, af_pfr))
1794     {
1795     allok = FALSE;
1796     if (fp)
1797       {
1798       BOOL allow;
1799
1800       if (addr->address[0] == '>')
1801         {
1802         allow = testflag(addr, af_allow_reply);
1803         fprintf(fp, "%s -> mail %s", addr->parent->address, addr->address + 1);
1804         }
1805       else
1806         {
1807         allow = addr->address[0] == '|'
1808           ? testflag(addr, af_allow_pipe) : testflag(addr, af_allow_file);
1809         fprintf(fp, "%s -> %s", addr->parent->address, addr->address);
1810         }
1811
1812       if (addr->basic_errno == ERRNO_BADTRANSPORT)
1813         fprintf(fp, "\n*** Error in setting up pipe, file, or autoreply:\n"
1814           "%s\n", addr->message);
1815       else if (allow)
1816         fprintf(fp, "\n  transport = %s\n", addr->transport->name);
1817       else
1818         fprintf(fp, " *** forbidden ***\n");
1819       }
1820     continue;
1821     }
1822
1823   /* Just in case some router parameter refers to it. */
1824
1825   return_path = addr->prop.errors_address
1826     ? addr->prop.errors_address : sender_address;
1827
1828   /* Split the address into domain and local part, handling the %-hack if
1829   necessary, and then route it. While routing a sender address, set
1830   $sender_address to <> because that is what it will be if we were trying to
1831   send a bounce to the sender. */
1832
1833   if (routed) *routed = FALSE;
1834   if ((rc = deliver_split_address(addr)) == OK)
1835     {
1836     if (!(options & vopt_is_recipient)) sender_address = null_sender;
1837     rc = route_address(addr, &addr_local, &addr_remote, &addr_new,
1838       &addr_succeed, verify_type);
1839     sender_address = save_sender;     /* Put back the real sender */
1840     }
1841
1842   /* If routing an address succeeded, set the flag that remembers, for use when
1843   an ACL cached a sender verify (in case a callout fails). Then if routing set
1844   up a list of hosts or the transport has a host list, and the callout option
1845   is set, and we aren't in a host checking run, do the callout verification,
1846   and set another flag that notes that a callout happened. */
1847
1848   if (rc == OK)
1849     {
1850     BOOL local_verify = FALSE;
1851
1852     if (routed) *routed = TRUE;
1853     if (callout > 0)
1854       {
1855       transport_instance * tp;
1856       host_item * host_list = addr->host_list;
1857
1858       /* Make up some data for use in the case where there is no remote
1859       transport. */
1860
1861       transport_feedback tf = {
1862         .interface =            NULL,                       /* interface (=> any) */
1863         .port =                 US"smtp",
1864         .protocol =             US"smtp",
1865         .hosts =                NULL,
1866         .helo_data =            US"$smtp_active_hostname",
1867         .hosts_override =       FALSE,
1868         .hosts_randomize =      FALSE,
1869         .gethostbyname =        FALSE,
1870         .qualify_single =       TRUE,
1871         .search_parents =       FALSE
1872         };
1873
1874       /* If verification yielded a remote transport, we want to use that
1875       transport's options, so as to mimic what would happen if we were really
1876       sending a message to this address. */
1877
1878       if ((tp = addr->transport))
1879         if (!tp->info->local)
1880           {
1881           (void)(tp->setup)(tp, addr, &tf, 0, 0, NULL);
1882
1883           /* If the transport has hosts and the router does not, or if the
1884           transport is configured to override the router's hosts, we must build a
1885           host list of the transport's hosts, and find the IP addresses */
1886
1887           if (tf.hosts && (!host_list || tf.hosts_override))
1888             {
1889             uschar *s;
1890             const uschar *save_deliver_domain = deliver_domain;
1891             uschar *save_deliver_localpart = deliver_localpart;
1892
1893             host_list = NULL;    /* Ignore the router's hosts */
1894
1895             deliver_domain = addr->domain;
1896             deliver_localpart = addr->local_part;
1897             s = expand_string(tf.hosts);
1898             deliver_domain = save_deliver_domain;
1899             deliver_localpart = save_deliver_localpart;
1900
1901             if (!s)
1902               {
1903               log_write(0, LOG_MAIN|LOG_PANIC, "failed to expand list of hosts "
1904                 "\"%s\" in %s transport for callout: %s", tf.hosts,
1905                 tp->name, expand_string_message);
1906               }
1907             else
1908               {
1909               int flags;
1910               host_build_hostlist(&host_list, s, tf.hosts_randomize);
1911
1912               /* Just ignore failures to find a host address. If we don't manage
1913               to find any addresses, the callout will defer. Note that more than
1914               one address may be found for a single host, which will result in
1915               additional host items being inserted into the chain. Hence we must
1916               save the next host first. */
1917
1918               flags = HOST_FIND_BY_A | HOST_FIND_BY_AAAA;
1919               if (tf.qualify_single) flags |= HOST_FIND_QUALIFY_SINGLE;
1920               if (tf.search_parents) flags |= HOST_FIND_SEARCH_PARENTS;
1921
1922               for (host_item * host = host_list, * nexthost; host; host = nexthost)
1923                 {
1924                 nexthost = host->next;
1925                 if (tf.gethostbyname ||
1926                     string_is_ip_address(host->name, NULL) != 0)
1927                   (void)host_find_byname(host, NULL, flags, NULL, TRUE);
1928                 else
1929                   {
1930                   const dnssec_domains * dsp = NULL;
1931                   if (Ustrcmp(tp->driver_name, "smtp") == 0)
1932                     {
1933                     smtp_transport_options_block * ob =
1934                         (smtp_transport_options_block *) tp->options_block;
1935                     dsp = &ob->dnssec;
1936                     }
1937
1938                   (void) host_find_bydns(host, NULL, flags, NULL, NULL, NULL,
1939                     dsp, NULL, NULL);
1940                   }
1941                 }
1942               }
1943             }
1944           }
1945         else if (  options & vopt_quota
1946                 && Ustrcmp(tp->driver_name, "appendfile") == 0)
1947           local_verify = TRUE;
1948
1949       /* Can only do a callout if we have at least one host! If the callout
1950       fails, it will have set ${sender,recipient}_verify_failure. */
1951
1952       if (host_list)
1953         {
1954         HDEBUG(D_verify) debug_printf("Attempting full verification using callout\n");
1955         if (host_checking && !f.host_checking_callout)
1956           {
1957           HDEBUG(D_verify)
1958             debug_printf("... callout omitted by default when host testing\n"
1959               "(Use -bhc if you want the callouts to happen.)\n");
1960           }
1961         else
1962           {
1963 #ifndef DISABLE_TLS
1964           deliver_set_expansions(addr);
1965 #endif
1966           rc = do_callout(addr, host_list, &tf, callout, callout_overall,
1967             callout_connect, options, se_mailfrom, pm_mailfrom);
1968 #ifndef DISABLE_TLS
1969           deliver_set_expansions(NULL);
1970 #endif
1971           }
1972         }
1973       else if (local_verify)
1974         {
1975         HDEBUG(D_verify) debug_printf("Attempting quota verification\n");
1976
1977         deliver_set_expansions(addr);
1978         deliver_local(addr, TRUE);
1979         rc = addr->transport_return;
1980         }
1981       else
1982         HDEBUG(D_verify) debug_printf("Cannot do callout: neither router nor "
1983           "transport provided a host list, or transport is not smtp\n");
1984       }
1985     }
1986
1987   /* Otherwise, any failure is a routing failure */
1988
1989   else *failure_ptr = US"route";
1990
1991   /* A router may return REROUTED if it has set up a child address as a result
1992   of a change of domain name (typically from widening). In this case we always
1993   want to continue to verify the new child. */
1994
1995   if (rc == REROUTED) continue;
1996
1997   /* Handle hard failures */
1998
1999   if (rc == FAIL)
2000     {
2001     allok = FALSE;
2002     if (fp)
2003       {
2004       address_item *p = addr->parent;
2005
2006       respond_printf(fp, "%s%s %s", ko_prefix,
2007         full_info ? addr->address : address,
2008         f.address_test_mode ? "is undeliverable" : "failed to verify");
2009       if (!expn && f.admin_user)
2010         {
2011         if (addr->basic_errno > 0)
2012           respond_printf(fp, ": %s", strerror(addr->basic_errno));
2013         if (addr->message)
2014           respond_printf(fp, ": %s", addr->message);
2015         }
2016
2017       /* Show parents iff doing full info */
2018
2019       if (full_info) while (p)
2020         {
2021         respond_printf(fp, "%s\n    <-- %s", cr, p->address);
2022         p = p->parent;
2023         }
2024       respond_printf(fp, "%s\n", cr);
2025       }
2026     cancel_cutthrough_connection(TRUE, US"routing hard fail");
2027
2028     if (!full_info)
2029       {
2030       yield = copy_error(vaddr, addr, FAIL);
2031       goto out;
2032       }
2033     yield = FAIL;
2034     }
2035
2036   /* Soft failure */
2037
2038   else if (rc == DEFER)
2039     {
2040     allok = FALSE;
2041     if (fp)
2042       {
2043       address_item *p = addr->parent;
2044       respond_printf(fp, "%s%s cannot be resolved at this time", ko_prefix,
2045         full_info? addr->address : address);
2046       if (!expn && f.admin_user)
2047         {
2048         if (addr->basic_errno > 0)
2049           respond_printf(fp, ": %s", strerror(addr->basic_errno));
2050         if (addr->message)
2051           respond_printf(fp, ": %s", addr->message);
2052         else if (addr->basic_errno <= 0)
2053           respond_printf(fp, ": unknown error");
2054         }
2055
2056       /* Show parents iff doing full info */
2057
2058       if (full_info) while (p)
2059         {
2060         respond_printf(fp, "%s\n    <-- %s", cr, p->address);
2061         p = p->parent;
2062         }
2063       respond_printf(fp, "%s\n", cr);
2064       }
2065     cancel_cutthrough_connection(TRUE, US"routing soft fail");
2066
2067     if (!full_info)
2068       {
2069       yield = copy_error(vaddr, addr, DEFER);
2070       goto out;
2071       }
2072     if (yield == OK) yield = DEFER;
2073     }
2074
2075   /* If we are handling EXPN, we do not want to continue to route beyond
2076   the top level (whose address is in "address"). */
2077
2078   else if (expn)
2079     {
2080     uschar *ok_prefix = US"250-";
2081
2082     if (!addr_new)
2083       if (!addr_local && !addr_remote)
2084         respond_printf(fp, "250 mail to <%s> is discarded\r\n", address);
2085       else
2086         respond_printf(fp, "250 <%s>\r\n", address);
2087
2088     else do
2089       {
2090       address_item *addr2 = addr_new;
2091       addr_new = addr2->next;
2092       if (!addr_new) ok_prefix = US"250 ";
2093       respond_printf(fp, "%s<%s>\r\n", ok_prefix, addr2->address);
2094       } while (addr_new);
2095     yield = OK;
2096     goto out;
2097     }
2098
2099   /* Successful routing other than EXPN. */
2100
2101   else
2102     {
2103     /* Handle successful routing when short info wanted. Otherwise continue for
2104     other (generated) addresses. Short info is the operational case. Full info
2105     can be requested only when debug_selector != 0 and a file is supplied.
2106
2107     There is a conflict between the use of aliasing as an alternate email
2108     address, and as a sort of mailing list. If an alias turns the incoming
2109     address into just one address (e.g. J.Caesar->jc44) you may well want to
2110     carry on verifying the generated address to ensure it is valid when
2111     checking incoming mail. If aliasing generates multiple addresses, you
2112     probably don't want to do this. Exim therefore treats the generation of
2113     just a single new address as a special case, and continues on to verify the
2114     generated address. */
2115
2116     if (  !full_info                    /* Stop if short info wanted AND */
2117        && (  (  !addr_new               /* No new address OR */
2118              || addr_new->next          /* More than one new address OR */
2119              || testflag(addr_new, af_pfr)      /* New address is pfr */
2120              )
2121           ||                            /* OR */
2122              (  addr_new                /* At least one new address AND */
2123              && success_on_redirect     /* success_on_redirect is set */
2124           )  )
2125        )
2126       {
2127       if (fp) fprintf(fp, "%s %s\n",
2128         address, f.address_test_mode ? "is deliverable" : "verified");
2129
2130       /* If we have carried on to verify a child address, we want the value
2131       of $address_data to be that of the child */
2132
2133       vaddr->prop.address_data = addr->prop.address_data;
2134       vaddr->prop.variables = NULL;
2135       tree_dup((tree_node **)&vaddr->prop.variables, addr->prop.variables);
2136
2137       /* If stopped because more than one new address, cannot cutthrough */
2138
2139       if (addr_new && addr_new->next)
2140         cancel_cutthrough_connection(TRUE, US"multiple addresses from routing");
2141
2142       yield = OK;
2143       goto out;
2144       }
2145     }
2146   }     /* Loop for generated addresses */
2147
2148 /* Display the full results of the successful routing, including any generated
2149 addresses. Control gets here only when full_info is set, which requires fp not
2150 to be NULL, and this occurs only when a top-level verify is called with the
2151 debugging switch on.
2152
2153 If there are no local and no remote addresses, and there were no pipes, files,
2154 or autoreplies, and there were no errors or deferments, the message is to be
2155 discarded, usually because of the use of :blackhole: in an alias file. */
2156
2157 if (allok && !addr_local && !addr_remote)
2158   {
2159   fprintf(fp, "mail to %s is discarded\n", address);
2160   goto out;
2161   }
2162
2163 for (addr_list = addr_local, i = 0; i < 2; addr_list = addr_remote, i++)
2164   while (addr_list)
2165     {
2166     address_item *addr = addr_list;
2167     transport_instance * tp = addr->transport;
2168
2169     addr_list = addr->next;
2170
2171     fprintf(fp, "%s", CS addr->address);
2172 #ifdef EXPERIMENTAL_SRS_ALT
2173     if(addr->prop.srs_sender)
2174       fprintf(fp, "    [srs = %s]", addr->prop.srs_sender);
2175 #endif
2176
2177     /* If the address is a duplicate, show something about it. */
2178
2179     if (!testflag(addr, af_pfr))
2180       {
2181       tree_node *tnode;
2182       if ((tnode = tree_search(tree_duplicates, addr->unique)))
2183         fprintf(fp, "   [duplicate, would not be delivered]");
2184       else tree_add_duplicate(addr->unique, addr);
2185       }
2186
2187     /* Now show its parents */
2188
2189     for (address_item * p = addr->parent; p; p = p->parent)
2190       fprintf(fp, "\n    <-- %s", p->address);
2191     fprintf(fp, "\n  ");
2192
2193     /* Show router, and transport */
2194
2195     fprintf(fp, "router = %s, transport = %s\n",
2196       addr->router->name, tp ? tp->name : US"unset");
2197
2198     /* Show any hosts that are set up by a router unless the transport
2199     is going to override them; fiddle a bit to get a nice format. */
2200
2201     if (addr->host_list && tp && !tp->overrides_hosts)
2202       {
2203       int maxlen = 0;
2204       int maxaddlen = 0;
2205       for (host_item * h = addr->host_list; h; h = h->next)
2206         {                               /* get max lengths of host names, addrs */
2207         int len = Ustrlen(h->name);
2208         if (len > maxlen) maxlen = len;
2209         len = h->address ? Ustrlen(h->address) : 7;
2210         if (len > maxaddlen) maxaddlen = len;
2211         }
2212       for (host_item * h = addr->host_list; h; h = h->next)
2213         {
2214         fprintf(fp, "  host %-*s ", maxlen, h->name);
2215
2216         if (h->address)
2217           fprintf(fp, "[%s%-*c", h->address, maxaddlen+1 - Ustrlen(h->address), ']');
2218         else if (tp->info->local)
2219           fprintf(fp, " %-*s ", maxaddlen, "");  /* Omit [unknown] for local */
2220         else
2221           fprintf(fp, "[%s%-*c", "unknown", maxaddlen+1 - 7, ']');
2222
2223         if (h->mx >= 0) fprintf(fp, " MX=%d", h->mx);
2224         if (h->port != PORT_NONE) fprintf(fp, " port=%d", h->port);
2225         if (f.running_in_test_harness  &&  h->dnssec == DS_YES) fputs(" AD", fp);
2226         if (h->status == hstatus_unusable) fputs(" ** unusable **", fp);
2227         fputc('\n', fp);
2228         }
2229       }
2230     }
2231
2232 /* Yield will be DEFER or FAIL if any one address has, only for full_info (which is
2233 the -bv or -bt case). */
2234
2235 out:
2236 verify_mode = NULL;
2237 tls_modify_variables(&tls_in);  /* return variables to inbound values */
2238
2239 return yield;
2240 }
2241
2242
2243
2244
2245 /*************************************************
2246 *      Check headers for syntax errors           *
2247 *************************************************/
2248
2249 /* This function checks those header lines that contain addresses, and verifies
2250 that all the addresses therein are 5322-syntactially correct.
2251
2252 Arguments:
2253   msgptr     where to put an error message
2254
2255 Returns:     OK
2256              FAIL
2257 */
2258
2259 int
2260 verify_check_headers(uschar **msgptr)
2261 {
2262 uschar *colon, *s;
2263 int yield = OK;
2264
2265 for (header_line * h = header_list; h && yield == OK; h = h->next)
2266   {
2267   if (h->type != htype_from &&
2268       h->type != htype_reply_to &&
2269       h->type != htype_sender &&
2270       h->type != htype_to &&
2271       h->type != htype_cc &&
2272       h->type != htype_bcc)
2273     continue;
2274
2275   colon = Ustrchr(h->text, ':');
2276   s = colon + 1;
2277   Uskip_whitespace(&s);
2278
2279   /* Loop for multiple addresses in the header, enabling group syntax. Note
2280   that we have to reset this after the header has been scanned. */
2281
2282   f.parse_allow_group = TRUE;
2283
2284   while (*s)
2285     {
2286     uschar *ss = parse_find_address_end(s, FALSE);
2287     uschar *recipient, *errmess;
2288     int terminator = *ss;
2289     int start, end, domain;
2290
2291     /* Temporarily terminate the string at this point, and extract the
2292     operative address within, allowing group syntax. */
2293
2294     *ss = 0;
2295     recipient = parse_extract_address(s,&errmess,&start,&end,&domain,FALSE);
2296     *ss = terminator;
2297
2298     /* Permit an unqualified address only if the message is local, or if the
2299     sending host is configured to be permitted to send them. */
2300
2301     if (recipient && !domain)
2302       {
2303       if (h->type == htype_from || h->type == htype_sender)
2304         {
2305         if (!f.allow_unqualified_sender) recipient = NULL;
2306         }
2307       else
2308         {
2309         if (!f.allow_unqualified_recipient) recipient = NULL;
2310         }
2311       if (!recipient) errmess = US"unqualified address not permitted";
2312       }
2313
2314     /* It's an error if no address could be extracted, except for the special
2315     case of an empty address. */
2316
2317     if (!recipient && Ustrcmp(errmess, "empty address") != 0)
2318       {
2319       uschar *verb = US"is";
2320       uschar *t = ss;
2321       uschar *tt = colon;
2322       int len;
2323
2324       /* Arrange not to include any white space at the end in the
2325       error message or the header name. */
2326
2327       while (t > s && isspace(t[-1])) t--;
2328       while (tt > h->text && isspace(tt[-1])) tt--;
2329
2330       /* Add the address that failed to the error message, since in a
2331       header with very many addresses it is sometimes hard to spot
2332       which one is at fault. However, limit the amount of address to
2333       quote - cases have been seen where, for example, a missing double
2334       quote in a humungous To: header creates an "address" that is longer
2335       than string_sprintf can handle. */
2336
2337       len = t - s;
2338       if (len > 1024)
2339         {
2340         len = 1024;
2341         verb = US"begins";
2342         }
2343
2344       /* deconst cast ok as we're passing a non-const to string_printing() */
2345       *msgptr = US string_printing(
2346         string_sprintf("%s: failing address in \"%.*s:\" header %s: %.*s",
2347           errmess, (int)(tt - h->text), h->text, verb, len, s));
2348
2349       yield = FAIL;
2350       break;          /* Out of address loop */
2351       }
2352
2353     /* Advance to the next address */
2354
2355     s = ss + (terminator ? 1 : 0);
2356     Uskip_whitespace(&s);
2357     }   /* Next address */
2358
2359   f.parse_allow_group = FALSE;
2360   f.parse_found_group = FALSE;
2361   }     /* Next header unless yield has been set FALSE */
2362
2363 return yield;
2364 }
2365
2366
2367 /*************************************************
2368 *      Check header names for 8-bit characters   *
2369 *************************************************/
2370
2371 /* This function checks for invalid characters in header names. See
2372 RFC 5322, 2.2. and RFC 6532, 3.
2373
2374 Arguments:
2375   msgptr     where to put an error message
2376
2377 Returns:     OK
2378              FAIL
2379 */
2380
2381 int
2382 verify_check_header_names_ascii(uschar **msgptr)
2383 {
2384 uschar *colon;
2385
2386 for (header_line * h = header_list; h; h = h->next)
2387   {
2388   colon = Ustrchr(h->text, ':');
2389   for(uschar * s = h->text; s < colon; s++)
2390     if ((*s < 33) || (*s > 126))
2391       {
2392       *msgptr = string_sprintf("Invalid character in header \"%.*s\" found",
2393                              (int)(colon - h->text), h->text);
2394       return FAIL;
2395       }
2396   }
2397 return OK;
2398 }
2399
2400 /*************************************************
2401 *          Check for blind recipients            *
2402 *************************************************/
2403
2404 /* This function checks that every (envelope) recipient is mentioned in either
2405 the To: or Cc: header lines, thus detecting blind carbon copies.
2406
2407 There are two ways of scanning that could be used: either scan the header lines
2408 and tick off the recipients, or scan the recipients and check the header lines.
2409 The original proposed patch did the former, but I have chosen to do the latter,
2410 because (a) it requires no memory and (b) will use fewer resources when there
2411 are many addresses in To: and/or Cc: and only one or two envelope recipients.
2412
2413 Arguments:   case_sensitive   true if case sensitive matching should be used
2414 Returns:     OK    if there are no blind recipients
2415              FAIL  if there is at least one blind recipient
2416 */
2417
2418 int
2419 verify_check_notblind(BOOL case_sensitive)
2420 {
2421 for (int i = 0; i < recipients_count; i++)
2422   {
2423   BOOL found = FALSE;
2424   uschar *address = recipients_list[i].address;
2425
2426   for (header_line * h = header_list; !found && h; h = h->next)
2427     {
2428     uschar *colon, *s;
2429
2430     if (h->type != htype_to && h->type != htype_cc) continue;
2431
2432     colon = Ustrchr(h->text, ':');
2433     s = colon + 1;
2434     Uskip_whitespace(&s);
2435
2436     /* Loop for multiple addresses in the header, enabling group syntax. Note
2437     that we have to reset this after the header has been scanned. */
2438
2439     f.parse_allow_group = TRUE;
2440
2441     while (*s)
2442       {
2443       uschar * ss = parse_find_address_end(s, FALSE);
2444       uschar * recipient, * errmess;
2445       int terminator = *ss;
2446       int start, end, domain;
2447
2448       /* Temporarily terminate the string at this point, and extract the
2449       operative address within, allowing group syntax. */
2450
2451       *ss = 0;
2452       recipient = parse_extract_address(s,&errmess,&start,&end,&domain,FALSE);
2453       *ss = terminator;
2454
2455       /* If we found a valid recipient that has a domain, compare it with the
2456       envelope recipient. Local parts are compared with case-sensitivity
2457       according to the routine arg, domains case-insensitively.
2458       By comparing from the start with length "domain", we include the "@" at
2459       the end, which ensures that we are comparing the whole local part of each
2460       address. */
2461
2462       if (recipient && domain != 0)
2463         if ((found = (case_sensitive
2464                 ? Ustrncmp(recipient, address, domain) == 0
2465                 : strncmpic(recipient, address, domain) == 0)
2466               && strcmpic(recipient + domain, address + domain) == 0))
2467           break;
2468
2469       /* Advance to the next address */
2470
2471       s = ss + (terminator ? 1:0);
2472       Uskip_whitespace(&s);
2473       }   /* Next address */
2474
2475     f.parse_allow_group = FALSE;
2476     f.parse_found_group = FALSE;
2477     }     /* Next header (if found is false) */
2478
2479   if (!found) return FAIL;
2480   }       /* Next recipient */
2481
2482 return OK;
2483 }
2484
2485
2486
2487 /*************************************************
2488 *          Find if verified sender               *
2489 *************************************************/
2490
2491 /* Usually, just a single address is verified as the sender of the message.
2492 However, Exim can be made to verify other addresses as well (often related in
2493 some way), and this is useful in some environments. There may therefore be a
2494 chain of such addresses that have previously been tested. This function finds
2495 whether a given address is on the chain.
2496
2497 Arguments:   the address to be verified
2498 Returns:     pointer to an address item, or NULL
2499 */
2500
2501 address_item *
2502 verify_checked_sender(uschar *sender)
2503 {
2504 for (address_item * addr = sender_verified_list; addr; addr = addr->next)
2505   if (Ustrcmp(sender, addr->address) == 0) return addr;
2506 return NULL;
2507 }
2508
2509
2510
2511
2512
2513 /*************************************************
2514 *             Get valid header address           *
2515 *************************************************/
2516
2517 /* Scan the originator headers of the message, looking for an address that
2518 verifies successfully. RFC 822 says:
2519
2520     o   The "Sender" field mailbox should be sent  notices  of
2521         any  problems in transport or delivery of the original
2522         messages.  If there is no  "Sender"  field,  then  the
2523         "From" field mailbox should be used.
2524
2525     o   If the "Reply-To" field exists, then the reply  should
2526         go to the addresses indicated in that field and not to
2527         the address(es) indicated in the "From" field.
2528
2529 So we check a Sender field if there is one, else a Reply_to field, else a From
2530 field. As some strange messages may have more than one of these fields,
2531 especially if they are resent- fields, check all of them if there is more than
2532 one.
2533
2534 Arguments:
2535   user_msgptr      points to where to put a user error message
2536   log_msgptr       points to where to put a log error message
2537   callout          timeout for callout check (passed to verify_address())
2538   callout_overall  overall callout timeout (ditto)
2539   callout_connect  connect callout timeout (ditto)
2540   se_mailfrom      mailfrom for verify; NULL => ""
2541   pm_mailfrom      sender for pm callout check (passed to verify_address())
2542   options          callout options (passed to verify_address())
2543   verrno           where to put the address basic_errno
2544
2545 If log_msgptr is set to something without setting user_msgptr, the caller
2546 normally uses log_msgptr for both things.
2547
2548 Returns:           result of the verification attempt: OK, FAIL, or DEFER;
2549                    FAIL is given if no appropriate headers are found
2550 */
2551
2552 int
2553 verify_check_header_address(uschar **user_msgptr, uschar **log_msgptr,
2554   int callout, int callout_overall, int callout_connect, uschar *se_mailfrom,
2555   uschar *pm_mailfrom, int options, int *verrno)
2556 {
2557 static int header_types[] = { htype_sender, htype_reply_to, htype_from };
2558 BOOL done = FALSE;
2559 int yield = FAIL;
2560
2561 for (int i = 0; i < 3 && !done; i++)
2562   for (header_line * h = header_list; h != NULL && !done; h = h->next)
2563     {
2564     int terminator, new_ok;
2565     uschar *s, *ss, *endname;
2566
2567     if (h->type != header_types[i]) continue;
2568     s = endname = Ustrchr(h->text, ':') + 1;
2569
2570     /* Scan the addresses in the header, enabling group syntax. Note that we
2571     have to reset this after the header has been scanned. */
2572
2573     f.parse_allow_group = TRUE;
2574
2575     while (*s != 0)
2576       {
2577       address_item *vaddr;
2578
2579       while (isspace(*s) || *s == ',') s++;
2580       if (*s == 0) break;        /* End of header */
2581
2582       ss = parse_find_address_end(s, FALSE);
2583
2584       /* The terminator is a comma or end of header, but there may be white
2585       space preceding it (including newline for the last address). Move back
2586       past any white space so we can check against any cached envelope sender
2587       address verifications. */
2588
2589       while (isspace(ss[-1])) ss--;
2590       terminator = *ss;
2591       *ss = 0;
2592
2593       HDEBUG(D_verify) debug_printf("verifying %.*s header address %s\n",
2594         (int)(endname - h->text), h->text, s);
2595
2596       /* See if we have already verified this address as an envelope sender,
2597       and if so, use the previous answer. */
2598
2599       vaddr = verify_checked_sender(s);
2600
2601       if (vaddr != NULL &&                   /* Previously checked */
2602            (callout <= 0 ||                  /* No callout needed; OR */
2603             vaddr->special_action > 256))    /* Callout was done */
2604         {
2605         new_ok = vaddr->special_action & 255;
2606         HDEBUG(D_verify) debug_printf("previously checked as envelope sender\n");
2607         *ss = terminator;  /* Restore shortened string */
2608         }
2609
2610       /* Otherwise we run the verification now. We must restore the shortened
2611       string before running the verification, so the headers are correct, in
2612       case there is any rewriting. */
2613
2614       else
2615         {
2616         int start, end, domain;
2617         uschar *address = parse_extract_address(s, log_msgptr, &start, &end,
2618           &domain, FALSE);
2619
2620         *ss = terminator;
2621
2622         /* If we found an empty address, just carry on with the next one, but
2623         kill the message. */
2624
2625         if (!address && Ustrcmp(*log_msgptr, "empty address") == 0)
2626           {
2627           *log_msgptr = NULL;
2628           s = ss;
2629           continue;
2630           }
2631
2632         /* If verification failed because of a syntax error, fail this
2633         function, and ensure that the failing address gets added to the error
2634         message. */
2635
2636         if (!address)
2637           {
2638           new_ok = FAIL;
2639           while (ss > s && isspace(ss[-1])) ss--;
2640           *log_msgptr = string_sprintf("syntax error in '%.*s' header when "
2641             "scanning for sender: %s in \"%.*s\"",
2642             (int)(endname - h->text), h->text, *log_msgptr, (int)(ss - s), s);
2643           yield = FAIL;
2644           done = TRUE;
2645           break;
2646           }
2647
2648         /* Else go ahead with the sender verification. But it isn't *the*
2649         sender of the message, so set vopt_fake_sender to stop sender_address
2650         being replaced after rewriting or qualification. */
2651
2652         else
2653           {
2654           vaddr = deliver_make_addr(address, FALSE);
2655           new_ok = verify_address(vaddr, NULL, options | vopt_fake_sender,
2656             callout, callout_overall, callout_connect, se_mailfrom,
2657             pm_mailfrom, NULL);
2658           }
2659         }
2660
2661       /* We now have the result, either newly found, or cached. If we are
2662       giving out error details, set a specific user error. This means that the
2663       last of these will be returned to the user if all three fail. We do not
2664       set a log message - the generic one below will be used. */
2665
2666       if (new_ok != OK)
2667         {
2668         *verrno = vaddr->basic_errno;
2669         if (smtp_return_error_details)
2670           *user_msgptr = string_sprintf("Rejected after DATA: "
2671             "could not verify \"%.*s\" header address\n%s: %s",
2672             (int)(endname - h->text), h->text, vaddr->address, vaddr->message);
2673         }
2674
2675       /* Success or defer */
2676
2677       if (new_ok == OK)
2678         {
2679         yield = OK;
2680         done = TRUE;
2681         break;
2682         }
2683
2684       if (new_ok == DEFER) yield = DEFER;
2685
2686       /* Move on to any more addresses in the header */
2687
2688       s = ss;
2689       }     /* Next address */
2690
2691     f.parse_allow_group = FALSE;
2692     f.parse_found_group = FALSE;
2693     }       /* Next header, unless done */
2694             /* Next header type unless done */
2695
2696 if (yield == FAIL && *log_msgptr == NULL)
2697   *log_msgptr = US"there is no valid sender in any header line";
2698
2699 if (yield == DEFER && *log_msgptr == NULL)
2700   *log_msgptr = US"all attempts to verify a sender in a header line deferred";
2701
2702 return yield;
2703 }
2704
2705
2706
2707
2708 /*************************************************
2709 *            Get RFC 1413 identification         *
2710 *************************************************/
2711
2712 /* Attempt to get an id from the sending machine via the RFC 1413 protocol. If
2713 the timeout is set to zero, then the query is not done. There may also be lists
2714 of hosts and nets which are exempt. To guard against malefactors sending
2715 non-printing characters which could, for example, disrupt a message's headers,
2716 make sure the string consists of printing characters only.
2717
2718 Argument:
2719   port    the port to connect to; usually this is IDENT_PORT (113), but when
2720           running in the test harness with -bh a different value is used.
2721
2722 Returns:  nothing
2723
2724 Side effect: any received ident value is put in sender_ident (NULL otherwise)
2725 */
2726
2727 void
2728 verify_get_ident(int port)
2729 {
2730 client_conn_ctx ident_conn_ctx = {0};
2731 int host_af, qlen;
2732 int received_sender_port, received_interface_port, n;
2733 uschar *p;
2734 blob early_data;
2735 uschar buffer[2048];
2736
2737 /* Default is no ident. Check whether we want to do an ident check for this
2738 host. */
2739
2740 sender_ident = NULL;
2741 if (rfc1413_query_timeout <= 0 || verify_check_host(&rfc1413_hosts) != OK)
2742   return;
2743
2744 DEBUG(D_ident) debug_printf("doing ident callback\n");
2745
2746 /* Set up a connection to the ident port of the remote host. Bind the local end
2747 to the incoming interface address. If the sender host address is an IPv6
2748 address, the incoming interface address will also be IPv6. */
2749
2750 host_af = Ustrchr(sender_host_address, ':') == NULL ? AF_INET : AF_INET6;
2751 if ((ident_conn_ctx.sock = ip_socket(SOCK_STREAM, host_af)) < 0) return;
2752
2753 if (ip_bind(ident_conn_ctx.sock, host_af, interface_address, 0) < 0)
2754   {
2755   DEBUG(D_ident) debug_printf("bind socket for ident failed: %s\n",
2756     strerror(errno));
2757   goto END_OFF;
2758   }
2759
2760 /* Construct and send the query. */
2761
2762 qlen = snprintf(CS buffer, sizeof(buffer), "%d , %d\r\n",
2763   sender_host_port, interface_port);
2764 early_data.data = buffer;
2765 early_data.len = qlen;
2766
2767 /*XXX we trust that the query is idempotent */
2768 if (ip_connect(ident_conn_ctx.sock, host_af, sender_host_address, port,
2769                 rfc1413_query_timeout, &early_data) < 0)
2770   {
2771   if (errno == ETIMEDOUT && LOGGING(ident_timeout))
2772     log_write(0, LOG_MAIN, "ident connection to %s timed out",
2773       sender_host_address);
2774   else
2775     DEBUG(D_ident) debug_printf("ident connection to %s failed: %s\n",
2776       sender_host_address, strerror(errno));
2777   goto END_OFF;
2778   }
2779
2780 /* Read a response line. We put it into the rest of the buffer, using several
2781 recv() calls if necessary. */
2782
2783 p = buffer + qlen;
2784
2785 for (;;)
2786   {
2787   uschar *pp;
2788   int count;
2789   int size = sizeof(buffer) - (p - buffer);
2790
2791   if (size <= 0) goto END_OFF;   /* Buffer filled without seeing \n. */
2792   count = ip_recv(&ident_conn_ctx, p, size, time(NULL) + rfc1413_query_timeout);
2793   if (count <= 0) goto END_OFF;  /* Read error or EOF */
2794
2795   /* Scan what we just read, to see if we have reached the terminating \r\n. Be
2796   generous, and accept a plain \n terminator as well. The only illegal
2797   character is 0. */
2798
2799   for (pp = p; pp < p + count; pp++)
2800     {
2801     if (*pp == 0) goto END_OFF;   /* Zero octet not allowed */
2802     if (*pp == '\n')
2803       {
2804       if (pp[-1] == '\r') pp--;
2805       *pp = 0;
2806       goto GOT_DATA;             /* Break out of both loops */
2807       }
2808     }
2809
2810   /* Reached the end of the data without finding \n. Let the loop continue to
2811   read some more, if there is room. */
2812
2813   p = pp;
2814   }
2815
2816 GOT_DATA:
2817
2818 /* We have received a line of data. Check it carefully. It must start with the
2819 same two port numbers that we sent, followed by data as defined by the RFC. For
2820 example,
2821
2822   12345 , 25 : USERID : UNIX :root
2823
2824 However, the amount of white space may be different to what we sent. In the
2825 "osname" field there may be several sub-fields, comma separated. The data we
2826 actually want to save follows the third colon. Some systems put leading spaces
2827 in it - we discard those. */
2828
2829 if (sscanf(CS buffer + qlen, "%d , %d%n", &received_sender_port,
2830       &received_interface_port, &n) != 2 ||
2831     received_sender_port != sender_host_port ||
2832     received_interface_port != interface_port)
2833   goto END_OFF;
2834
2835 p = buffer + qlen + n;
2836 while(isspace(*p)) p++;
2837 if (*p++ != ':') goto END_OFF;
2838 while(isspace(*p)) p++;
2839 if (Ustrncmp(p, "USERID", 6) != 0) goto END_OFF;
2840 p += 6;
2841 while(isspace(*p)) p++;
2842 if (*p++ != ':') goto END_OFF;
2843 while (*p != 0 && *p != ':') p++;
2844 if (*p++ == 0) goto END_OFF;
2845 while(isspace(*p)) p++;
2846 if (*p == 0) goto END_OFF;
2847
2848 /* The rest of the line is the data we want. We turn it into printing
2849 characters when we save it, so that it cannot mess up the format of any logging
2850 or Received: lines into which it gets inserted. We keep a maximum of 127
2851 characters. The deconst cast is ok as we fed a nonconst to string_printing() */
2852
2853 sender_ident = US string_printing(string_copyn(p, 127));
2854 DEBUG(D_ident) debug_printf("sender_ident = %s\n", sender_ident);
2855
2856 END_OFF:
2857 (void)close(ident_conn_ctx.sock);
2858 return;
2859 }
2860
2861
2862
2863
2864 /*************************************************
2865 *      Match host to a single host-list item     *
2866 *************************************************/
2867
2868 /* This function compares a host (name or address) against a single item
2869 from a host list. The host name gets looked up if it is needed and is not
2870 already known. The function is called from verify_check_this_host() via
2871 match_check_list(), which is why most of its arguments are in a single block.
2872
2873 Arguments:
2874   arg            the argument block (see below)
2875   ss             the host-list item
2876   valueptr       where to pass back looked up data, or NULL
2877   error          for error message when returning ERROR
2878
2879 The block contains:
2880   host_name      (a) the host name, or
2881                  (b) NULL, implying use sender_host_name and
2882                        sender_host_aliases, looking them up if required, or
2883                  (c) the empty string, meaning that only IP address matches
2884                        are permitted
2885   host_address   the host address
2886   host_ipv4      the IPv4 address taken from an IPv6 one
2887
2888 Returns:         OK      matched
2889                  FAIL    did not match
2890                  DEFER   lookup deferred
2891                  ERROR   (a) failed to find the host name or IP address, or
2892                          (b) unknown lookup type specified, or
2893                          (c) host name encountered when only IP addresses are
2894                                being matched
2895 */
2896
2897 int
2898 check_host(void *arg, const uschar *ss, const uschar **valueptr, uschar **error)
2899 {
2900 check_host_block *cb = (check_host_block *)arg;
2901 int mlen = -1;
2902 int maskoffset;
2903 BOOL iplookup = FALSE;
2904 BOOL isquery = FALSE;
2905 BOOL isiponly = cb->host_name != NULL && cb->host_name[0] == 0;
2906 const uschar *t;
2907 uschar * semicolon, * endname, * opts;
2908 uschar **aliases;
2909
2910 /* Optimize for the special case when the pattern is "*". */
2911
2912 if (*ss == '*' && ss[1] == 0) return OK;
2913
2914 /* If the pattern is empty, it matches only in the case when there is no host -
2915 this can occur in ACL checking for SMTP input using the -bs option. In this
2916 situation, the host address is the empty string. */
2917
2918 if (cb->host_address[0] == 0) return (*ss == 0)? OK : FAIL;
2919 if (*ss == 0) return FAIL;
2920
2921 /* If the pattern is precisely "@" then match against the primary host name,
2922 provided that host name matching is permitted; if it's "@[]" match against the
2923 local host's IP addresses. */
2924
2925 if (*ss == '@')
2926   if (ss[1] == 0)
2927     {
2928     if (isiponly) return ERROR;
2929     ss = primary_hostname;
2930     }
2931   else if (Ustrcmp(ss, "@[]") == 0)
2932     {
2933     for (ip_address_item * ip = host_find_interfaces(); ip; ip = ip->next)
2934       if (Ustrcmp(ip->address, cb->host_address) == 0) return OK;
2935     return FAIL;
2936     }
2937
2938 /* If the pattern is an IP address, optionally followed by a bitmask count, do
2939 a (possibly masked) comparison with the current IP address. */
2940
2941 if (string_is_ip_address(ss, &maskoffset) != 0)
2942   return (host_is_in_net(cb->host_address, ss, maskoffset)? OK : FAIL);
2943
2944 /* The pattern is not an IP address. A common error that people make is to omit
2945 one component of an IPv4 address, either by accident, or believing that, for
2946 example, 1.2.3/24 is the same as 1.2.3.0/24, or 1.2.3 is the same as 1.2.3.0,
2947 which it isn't. (Those applications that do accept 1.2.3 as an IP address
2948 interpret it as 1.2.0.3 because the final component becomes 16-bit - this is an
2949 ancient specification.) To aid in debugging these cases, we give a specific
2950 error if the pattern contains only digits and dots or contains a slash preceded
2951 only by digits and dots (a slash at the start indicates a file name and of
2952 course slashes may be present in lookups, but not preceded only by digits and
2953 dots). */
2954
2955 for (t = ss; isdigit(*t) || *t == '.'; ) t++;
2956 if (*t == 0 || (*t == '/' && t != ss))
2957   {
2958   *error = US"malformed IPv4 address or address mask";
2959   return ERROR;
2960   }
2961
2962 /* See if there is a semicolon in the pattern, separating a searchtype
2963 prefix.  If there is one then check for comma-sep options. */
2964
2965 if ((semicolon = Ustrchr(ss, ';')))
2966   if ((opts = Ustrchr(ss, ',')) && opts < semicolon)
2967     {
2968     endname = opts++;
2969     opts = string_copyn(opts, semicolon - opts);
2970     }
2971   else
2972     {
2973     endname = semicolon;
2974     opts = NULL;
2975     }
2976
2977 /* If we are doing an IP address only match, then all lookups must be IP
2978 address lookups, even if there is no "net-". */
2979
2980 if (isiponly)
2981   iplookup = semicolon != NULL;
2982
2983 /* Otherwise, if the item is of the form net[n]-lookup;<file|query> then it is
2984 a lookup on a masked IP network, in textual form. We obey this code even if we
2985 have already set iplookup, so as to skip over the "net-" prefix and to set the
2986 mask length. The net- stuff really only applies to single-key lookups where the
2987 key is implicit. For query-style lookups the key is specified in the query.
2988 From release 4.30, the use of net- for query style is no longer needed, but we
2989 retain it for backward compatibility. */
2990
2991 if (Ustrncmp(ss, "net", 3) == 0 && semicolon)
2992   {
2993   mlen = 0;
2994   for (t = ss + 3; isdigit(*t); t++) mlen = mlen * 10 + *t - '0';
2995   if (mlen == 0 && t == ss+3) mlen = -1;  /* No mask supplied */
2996   iplookup = *t++ == '-';
2997   }
2998 else
2999   t = ss;
3000
3001 /* Do the IP address lookup if that is indeed what we have */
3002
3003 if (iplookup)
3004   {
3005   int insize;
3006   int search_type;
3007   int incoming[4];
3008   void *handle;
3009   uschar *filename, *key, *result;
3010   uschar buffer[64];
3011
3012   /* Find the search type */
3013
3014   search_type = search_findtype(t, endname - t);
3015
3016   if (search_type < 0) log_write(0, LOG_MAIN|LOG_PANIC_DIE, "%s",
3017     search_error_message);
3018
3019   /* Adjust parameters for the type of lookup. For a query-style lookup, there
3020   is no file name, and the "key" is just the query. For query-style with a file
3021   name, we have to fish the file off the start of the query. For a single-key
3022   lookup, the key is the current IP address, masked appropriately, and
3023   reconverted to text form, with the mask appended. For IPv6 addresses, specify
3024   dot separators instead of colons, except when the lookup type is "iplsearch".
3025   */
3026
3027   if (mac_islookup(search_type, lookup_absfilequery))
3028     {
3029     filename = semicolon + 1;
3030     key = filename;
3031     while (*key != 0 && !isspace(*key)) key++;
3032     filename = string_copyn(filename, key - filename);
3033     while (isspace(*key)) key++;
3034     }
3035   else if (mac_islookup(search_type, lookup_querystyle))
3036     {
3037     filename = NULL;
3038     key = semicolon + 1;
3039     }
3040   else   /* Single-key style */
3041     {
3042     int sep = (Ustrcmp(lookup_list[search_type]->name, "iplsearch") == 0)?
3043       ':' : '.';
3044     insize = host_aton(cb->host_address, incoming);
3045     host_mask(insize, incoming, mlen);
3046     (void)host_nmtoa(insize, incoming, mlen, buffer, sep);
3047     key = buffer;
3048     filename = semicolon + 1;
3049     }
3050
3051   /* Now do the actual lookup; note that there is no search_close() because
3052   of the caching arrangements. */
3053
3054   if (!(handle = search_open(filename, search_type, 0, NULL, NULL)))
3055     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "%s", search_error_message);
3056
3057   result = search_find(handle, filename, key, -1, NULL, 0, 0, NULL, opts);
3058   if (valueptr) *valueptr = result;
3059   return result ? OK : f.search_find_defer ? DEFER: FAIL;
3060   }
3061
3062 /* The pattern is not an IP address or network reference of any kind. That is,
3063 it is a host name pattern. If this is an IP only match, there's an error in the
3064 host list. */
3065
3066 if (isiponly)
3067   {
3068   *error = US"cannot match host name in match_ip list";
3069   return ERROR;
3070   }
3071
3072 /* Check the characters of the pattern to see if they comprise only letters,
3073 digits, full stops, and hyphens (the constituents of domain names). Allow
3074 underscores, as they are all too commonly found. Sigh. Also, if
3075 allow_utf8_domains is set, allow top-bit characters. */
3076
3077 for (t = ss; *t != 0; t++)
3078   if (!isalnum(*t) && *t != '.' && *t != '-' && *t != '_' &&
3079       (!allow_utf8_domains || *t < 128)) break;
3080
3081 /* If the pattern is a complete domain name, with no fancy characters, look up
3082 its IP address and match against that. Note that a multi-homed host will add
3083 items to the chain. */
3084
3085 if (*t == 0)
3086   {
3087   int rc;
3088   host_item h;
3089   h.next = NULL;
3090   h.name = ss;
3091   h.address = NULL;
3092   h.mx = MX_NONE;
3093
3094   /* Using byname rather than bydns here means we cannot determine dnssec
3095   status.  On the other hand it is unclear how that could be either
3096   propagated up or enforced. */
3097
3098   rc = host_find_byname(&h, NULL, HOST_FIND_QUALIFY_SINGLE, NULL, FALSE);
3099   if (rc == HOST_FOUND || rc == HOST_FOUND_LOCAL)
3100     {
3101     for (host_item * hh = &h; hh; hh = hh->next)
3102       if (host_is_in_net(hh->address, cb->host_address, 0)) return OK;
3103     return FAIL;
3104     }
3105   if (rc == HOST_FIND_AGAIN) return DEFER;
3106   *error = string_sprintf("failed to find IP address for %s", ss);
3107   return ERROR;
3108   }
3109
3110 /* Almost all subsequent comparisons require the host name, and can be done
3111 using the general string matching function. When this function is called for
3112 outgoing hosts, the name is always given explicitly. If it is NULL, it means we
3113 must use sender_host_name and its aliases, looking them up if necessary. */
3114
3115 if (cb->host_name)   /* Explicit host name given */
3116   return match_check_string(cb->host_name, ss, -1, TRUE, TRUE, TRUE,
3117     valueptr);
3118
3119 /* Host name not given; in principle we need the sender host name and its
3120 aliases. However, for query-style lookups, we do not need the name if the
3121 query does not contain $sender_host_name. From release 4.23, a reference to
3122 $sender_host_name causes it to be looked up, so we don't need to do the lookup
3123 on spec. */
3124
3125 if ((semicolon = Ustrchr(ss, ';')))
3126   {
3127   const uschar * affix, * opts;
3128   int partial, affixlen, starflags, id;
3129
3130   *semicolon = 0;
3131   id = search_findtype_partial(ss, &partial, &affix, &affixlen, &starflags,
3132           &opts);
3133   *semicolon=';';
3134
3135   if (id < 0)                           /* Unknown lookup type */
3136     {
3137     log_write(0, LOG_MAIN|LOG_PANIC, "%s in host list item \"%s\"",
3138       search_error_message, ss);
3139     return DEFER;
3140     }
3141   isquery = mac_islookup(id, lookup_querystyle|lookup_absfilequery);
3142   }
3143
3144 if (isquery)
3145   {
3146   switch(match_check_string(US"", ss, -1, TRUE, TRUE, TRUE, valueptr))
3147     {
3148     case OK:    return OK;
3149     case DEFER: return DEFER;
3150     default:    return FAIL;
3151     }
3152   }
3153
3154 /* Not a query-style lookup; must ensure the host name is present, and then we
3155 do a check on the name and all its aliases. */
3156
3157 if (!sender_host_name)
3158   {
3159   HDEBUG(D_host_lookup)
3160     debug_printf("sender host name required, to match against %s\n", ss);
3161   if (host_lookup_failed || host_name_lookup() != OK)
3162     {
3163     *error = string_sprintf("failed to find host name for %s",
3164       sender_host_address);;
3165     return ERROR;
3166     }
3167   host_build_sender_fullhost();
3168   }
3169
3170 /* Match on the sender host name, using the general matching function */
3171
3172 switch(match_check_string(sender_host_name, ss, -1, TRUE, TRUE, TRUE, valueptr))
3173   {
3174   case OK:    return OK;
3175   case DEFER: return DEFER;
3176   }
3177
3178 /* If there are aliases, try matching on them. */
3179
3180 aliases = sender_host_aliases;
3181 while (*aliases)
3182   switch(match_check_string(*aliases++, ss, -1, TRUE, TRUE, TRUE, valueptr))
3183     {
3184     case OK:    return OK;
3185     case DEFER: return DEFER;
3186     }
3187 return FAIL;
3188 }
3189
3190
3191
3192
3193 /*************************************************
3194 *    Check a specific host matches a host list   *
3195 *************************************************/
3196
3197 /* This function is passed a host list containing items in a number of
3198 different formats and the identity of a host. Its job is to determine whether
3199 the given host is in the set of hosts defined by the list. The host name is
3200 passed as a pointer so that it can be looked up if needed and not already
3201 known. This is commonly the case when called from verify_check_host() to check
3202 an incoming connection. When called from elsewhere the host name should usually
3203 be set.
3204
3205 This function is now just a front end to match_check_list(), which runs common
3206 code for scanning a list. We pass it the check_host() function to perform a
3207 single test.
3208
3209 Arguments:
3210   listptr              pointer to the host list
3211   cache_bits           pointer to cache for named lists, or NULL
3212   host_name            the host name or NULL, implying use sender_host_name and
3213                          sender_host_aliases, looking them up if required
3214   host_address         the IP address
3215   valueptr             if not NULL, data from a lookup is passed back here
3216
3217 Returns:    OK    if the host is in the defined set
3218             FAIL  if the host is not in the defined set,
3219             DEFER if a data lookup deferred (not a host lookup)
3220
3221 If the host name was needed in order to make a comparison, and could not be
3222 determined from the IP address, the result is FAIL unless the item
3223 "+allow_unknown" was met earlier in the list, in which case OK is returned. */
3224
3225 int
3226 verify_check_this_host(const uschar **listptr, unsigned int *cache_bits,
3227   const uschar *host_name, const uschar *host_address, const uschar **valueptr)
3228 {
3229 int rc;
3230 unsigned int *local_cache_bits = cache_bits;
3231 const uschar *save_host_address = deliver_host_address;
3232 check_host_block cb = { .host_name = host_name, .host_address = host_address };
3233
3234 if (valueptr) *valueptr = NULL;
3235
3236 /* If the host address starts off ::ffff: it is an IPv6 address in
3237 IPv4-compatible mode. Find the IPv4 part for checking against IPv4
3238 addresses. */
3239
3240 cb.host_ipv4 = Ustrncmp(host_address, "::ffff:", 7) == 0
3241   ? host_address + 7 : host_address;
3242
3243 /* During the running of the check, put the IP address into $host_address. In
3244 the case of calls from the smtp transport, it will already be there. However,
3245 in other calls (e.g. when testing ignore_target_hosts), it won't. Just to be on
3246 the safe side, any existing setting is preserved, though as I write this
3247 (November 2004) I can't see any cases where it is actually needed. */
3248
3249 deliver_host_address = host_address;
3250 rc = match_check_list(
3251        listptr,                                /* the list */
3252        0,                                      /* separator character */
3253        &hostlist_anchor,                       /* anchor pointer */
3254        &local_cache_bits,                      /* cache pointer */
3255        check_host,                             /* function for testing */
3256        &cb,                                    /* argument for function */
3257        MCL_HOST,                               /* type of check */
3258        (host_address == sender_host_address)?
3259          US"host" : host_address,              /* text for debugging */
3260        valueptr);                              /* where to pass back data */
3261 deliver_host_address = save_host_address;
3262 return rc;
3263 }
3264
3265
3266
3267
3268 /*************************************************
3269 *      Check the given host item matches a list  *
3270 *************************************************/
3271 int
3272 verify_check_given_host(const uschar **listptr, const host_item *host)
3273 {
3274 return verify_check_this_host(listptr, NULL, host->name, host->address, NULL);
3275 }
3276
3277 /*************************************************
3278 *      Check the remote host matches a list      *
3279 *************************************************/
3280
3281 /* This is a front end to verify_check_this_host(), created because checking
3282 the remote host is a common occurrence. With luck, a good compiler will spot
3283 the tail recursion and optimize it. If there's no host address, this is
3284 command-line SMTP input - check against an empty string for the address.
3285
3286 Arguments:
3287   listptr              pointer to the host list
3288
3289 Returns:               the yield of verify_check_this_host(),
3290                        i.e. OK, FAIL, or DEFER
3291 */
3292
3293 int
3294 verify_check_host(uschar **listptr)
3295 {
3296 return verify_check_this_host(CUSS listptr, sender_host_cache, NULL,
3297   sender_host_address ? sender_host_address : US"", NULL);
3298 }
3299
3300
3301
3302
3303
3304 /*************************************************
3305 *              Invert an IP address              *
3306 *************************************************/
3307
3308 /* Originally just used for DNS xBL lists, now also used for the
3309 reverse_ip expansion operator.
3310
3311 Arguments:
3312   buffer         where to put the answer
3313   address        the address to invert
3314 */
3315
3316 void
3317 invert_address(uschar *buffer, uschar *address)
3318 {
3319 int bin[4];
3320 uschar *bptr = buffer;
3321
3322 /* If this is an IPv4 address mapped into IPv6 format, adjust the pointer
3323 to the IPv4 part only. */
3324
3325 if (Ustrncmp(address, "::ffff:", 7) == 0) address += 7;
3326
3327 /* Handle IPv4 address: when HAVE_IPV6 is false, the result of host_aton() is
3328 always 1. */
3329
3330 if (host_aton(address, bin) == 1)
3331   {
3332   int x = bin[0];
3333   for (int i = 0; i < 4; i++)
3334     {
3335     sprintf(CS bptr, "%d.", x & 255);
3336     while (*bptr) bptr++;
3337     x >>= 8;
3338     }
3339   }
3340
3341 /* Handle IPv6 address. Actually, as far as I know, there are no IPv6 addresses
3342 in any DNS black lists, and the format in which they will be looked up is
3343 unknown. This is just a guess. */
3344
3345 #if HAVE_IPV6
3346 else
3347   for (int j = 3; j >= 0; j--)
3348     {
3349     int x = bin[j];
3350     for (int i = 0; i < 8; i++)
3351       {
3352       sprintf(CS bptr, "%x.", x & 15);
3353       while (*bptr) bptr++;
3354       x >>= 4;
3355       }
3356     }
3357 #endif
3358
3359 /* Remove trailing period -- this is needed so that both arbitrary
3360 dnsbl keydomains and inverted addresses may be combined with the
3361 same format string, "%s.%s" */
3362
3363 *(--bptr) = 0;
3364 }
3365
3366
3367
3368 /*************************************************
3369 *          Perform a single dnsbl lookup         *
3370 *************************************************/
3371
3372 /* This function is called from verify_check_dnsbl() below. It is also called
3373 recursively from within itself when domain and domain_txt are different
3374 pointers, in order to get the TXT record from the alternate domain.
3375
3376 Arguments:
3377   domain         the outer dnsbl domain
3378   domain_txt     alternate domain to lookup TXT record on success; when the
3379                    same domain is to be used, domain_txt == domain (that is,
3380                    the pointers must be identical, not just the text)
3381   keydomain      the current keydomain (for debug message)
3382   prepend        subdomain to lookup (like keydomain, but
3383                    reversed if IP address)
3384   iplist         the list of matching IP addresses, or NULL for "any"
3385   bitmask        true if bitmask matching is wanted
3386   match_type     condition for 'succeed' result
3387                    0 => Any RR in iplist     (=)
3388                    1 => No RR in iplist      (!=)
3389                    2 => All RRs in iplist    (==)
3390                    3 => Some RRs not in iplist (!==)
3391                    the two bits are defined as MT_NOT and MT_ALL
3392   defer_return   what to return for a defer
3393
3394 Returns:         OK if lookup succeeded
3395                  FAIL if not
3396 */
3397
3398 static int
3399 one_check_dnsbl(uschar *domain, uschar *domain_txt, uschar *keydomain,
3400   uschar *prepend, uschar *iplist, BOOL bitmask, int match_type,
3401   int defer_return)
3402 {
3403 dns_answer * dnsa = store_get_dns_answer();
3404 dns_scan dnss;
3405 tree_node *t;
3406 dnsbl_cache_block *cb;
3407 int old_pool = store_pool;
3408 uschar * query;
3409 int qlen;
3410
3411 /* Construct the specific query domainname */
3412
3413 query = string_sprintf("%s.%s", prepend, domain);
3414 if ((qlen = Ustrlen(query)) >= 256)
3415   {
3416   log_write(0, LOG_MAIN|LOG_PANIC, "dnslist query is too long "
3417     "(ignored): %s...", query);
3418   return FAIL;
3419   }
3420
3421 /* Look for this query in the cache. */
3422
3423 if (  (t = tree_search(dnsbl_cache, query))
3424    && (cb = t->data.ptr)->expiry > time(NULL)
3425    )
3426
3427 /* Previous lookup was cached */
3428
3429   {
3430   HDEBUG(D_dnsbl) debug_printf("dnslists: using result of previous lookup\n");
3431   }
3432
3433 /* If not cached from a previous lookup, we must do a DNS lookup, and
3434 cache the result in permanent memory. */
3435
3436 else
3437   {
3438   uint ttl = 3600;      /* max TTL for positive cache entries */
3439
3440   store_pool = POOL_PERM;
3441
3442   if (t)
3443     {
3444     HDEBUG(D_dnsbl) debug_printf("cached data found but past valid time; ");
3445     }
3446
3447   else
3448     {   /* Set up a tree entry to cache the lookup */
3449     t = store_get(sizeof(tree_node) + qlen + 1 + 1, is_tainted(query));
3450     Ustrcpy(t->name, query);
3451     t->data.ptr = cb = store_get(sizeof(dnsbl_cache_block), FALSE);
3452     (void)tree_insertnode(&dnsbl_cache, t);
3453     }
3454
3455   /* Do the DNS lookup . */
3456
3457   HDEBUG(D_dnsbl) debug_printf("new DNS lookup for %s\n", query);
3458   cb->rc = dns_basic_lookup(dnsa, query, T_A);
3459   cb->text_set = FALSE;
3460   cb->text = NULL;
3461   cb->rhs = NULL;
3462
3463   /* If the lookup succeeded, cache the RHS address. The code allows for
3464   more than one address - this was for complete generality and the possible
3465   use of A6 records. However, A6 records are no longer supported. Leave the code
3466   here, just in case.
3467
3468   Quite apart from one A6 RR generating multiple addresses, there are DNS
3469   lists that return more than one A record, so we must handle multiple
3470   addresses generated in that way as well.
3471
3472   Mark the cache entry with the "now" plus the minimum of the address TTLs,
3473   or the RFC 2308 negative-cache value from the SOA if none were found. */
3474
3475   switch (cb->rc)
3476     {
3477     case DNS_SUCCEED:
3478       {
3479       dns_address ** addrp = &cb->rhs;
3480       dns_address * da;
3481       for (dns_record * rr = dns_next_rr(dnsa, &dnss, RESET_ANSWERS); rr;
3482            rr = dns_next_rr(dnsa, &dnss, RESET_NEXT))
3483         if (rr->type == T_A && (da = dns_address_from_rr(dnsa, rr)))
3484           {
3485           *addrp = da;
3486           while (da->next) da = da->next;
3487           addrp = &da->next;
3488           if (ttl > rr->ttl) ttl = rr->ttl;
3489           }
3490
3491       if (cb->rhs)
3492         {
3493         cb->expiry = time(NULL) + ttl;
3494         break;
3495         }
3496
3497       /* If we didn't find any A records, change the return code. This can
3498       happen when there is a CNAME record but there are no A records for what
3499       it points to. */
3500
3501       cb->rc = DNS_NODATA;
3502       }
3503       /*FALLTHROUGH*/
3504
3505     case DNS_NOMATCH:
3506     case DNS_NODATA:
3507       {
3508       /* Although there already is a neg-cache layer maintained by
3509       dns_basic_lookup(), we have a dnslist cache entry allocated and
3510       tree-inserted. So we may as well use it. */
3511
3512       time_t soa_negttl = dns_expire_from_soa(dnsa, T_A);
3513       cb->expiry = soa_negttl ? soa_negttl : time(NULL) + ttl;
3514       break;
3515       }
3516
3517     default:
3518       cb->expiry = time(NULL) + ttl;
3519       break;
3520     }
3521
3522   store_pool = old_pool;
3523   HDEBUG(D_dnsbl) debug_printf("dnslists: wrote cache entry, ttl=%d\n",
3524     (int)(cb->expiry - time(NULL)));
3525   }
3526
3527 /* We now have the result of the DNS lookup, either newly done, or cached
3528 from a previous call. If the lookup succeeded, check against the address
3529 list if there is one. This may be a positive equality list (introduced by
3530 "="), a negative equality list (introduced by "!="), a positive bitmask
3531 list (introduced by "&"), or a negative bitmask list (introduced by "!&").*/
3532
3533 if (cb->rc == DNS_SUCCEED)
3534   {
3535   dns_address * da = NULL;
3536   uschar *addlist = cb->rhs->address;
3537
3538   /* For A and AAAA records, there may be multiple addresses from multiple
3539   records. For A6 records (currently not expected to be used) there may be
3540   multiple addresses from a single record. */
3541
3542   for (da = cb->rhs->next; da; da = da->next)
3543     addlist = string_sprintf("%s, %s", addlist, da->address);
3544
3545   HDEBUG(D_dnsbl) debug_printf("DNS lookup for %s succeeded (yielding %s)\n",
3546     query, addlist);
3547
3548   /* Address list check; this can be either for equality, or via a bitmask.
3549   In the latter case, all the bits must match. */
3550
3551   if (iplist)
3552     {
3553     for (da = cb->rhs; da; da = da->next)
3554       {
3555       int ipsep = ',';
3556       const uschar *ptr = iplist;
3557       uschar *res;
3558
3559       /* Handle exact matching */
3560
3561       if (!bitmask)
3562         {
3563         while ((res = string_nextinlist(&ptr, &ipsep, NULL, 0)))
3564           if (Ustrcmp(CS da->address, res) == 0)
3565             break;
3566         }
3567
3568       /* Handle bitmask matching */
3569
3570       else
3571         {
3572         int address[4];
3573         int mask = 0;
3574
3575         /* At present, all known DNS blocking lists use A records, with
3576         IPv4 addresses on the RHS encoding the information they return. I
3577         wonder if this will linger on as the last vestige of IPv4 when IPv6
3578         is ubiquitous? Anyway, for now we use paranoia code to completely
3579         ignore IPv6 addresses. The default mask is 0, which always matches.
3580         We change this only for IPv4 addresses in the list. */
3581
3582         if (host_aton(da->address, address) == 1) mask = address[0];
3583
3584         /* Scan the returned addresses, skipping any that are IPv6 */
3585
3586         while ((res = string_nextinlist(&ptr, &ipsep, NULL, 0)))
3587           {
3588           if (host_aton(res, address) != 1) continue;
3589           if ((address[0] & mask) == address[0]) break;
3590           }
3591         }
3592
3593       /* If either
3594
3595          (a) An IP address in an any ('=') list matched, or
3596          (b) No IP address in an all ('==') list matched
3597
3598       then we're done searching. */
3599
3600       if (((match_type & MT_ALL) != 0) == (res == NULL)) break;
3601       }
3602
3603     /* If da == NULL, either
3604
3605        (a) No IP address in an any ('=') list matched, or
3606        (b) An IP address in an all ('==') list didn't match
3607
3608     so behave as if the DNSBL lookup had not succeeded, i.e. the host is not on
3609     the list. */
3610
3611     if ((match_type == MT_NOT || match_type == MT_ALL) != (da == NULL))
3612       {
3613       HDEBUG(D_dnsbl)
3614         {
3615         uschar *res = NULL;
3616         switch(match_type)
3617           {
3618           case 0:
3619             res = US"was no match"; break;
3620           case MT_NOT:
3621             res = US"was an exclude match"; break;
3622           case MT_ALL:
3623             res = US"was an IP address that did not match"; break;
3624           case MT_NOT|MT_ALL:
3625             res = US"were no IP addresses that did not match"; break;
3626           }
3627         debug_printf("=> but we are not accepting this block class because\n");
3628         debug_printf("=> there %s for %s%c%s\n",
3629           res,
3630           ((match_type & MT_ALL) == 0)? "" : "=",
3631           bitmask? '&' : '=', iplist);
3632         }
3633       return FAIL;
3634       }
3635     }
3636
3637   /* Either there was no IP list, or the record matched, implying that the
3638   domain is on the list. We now want to find a corresponding TXT record. If an
3639   alternate domain is specified for the TXT record, call this function
3640   recursively to look that up; this has the side effect of re-checking that
3641   there is indeed an A record at the alternate domain. */
3642
3643   if (domain_txt != domain)
3644     return one_check_dnsbl(domain_txt, domain_txt, keydomain, prepend, NULL,
3645       FALSE, match_type, defer_return);
3646
3647   /* If there is no alternate domain, look up a TXT record in the main domain
3648   if it has not previously been cached. */
3649
3650   if (!cb->text_set)
3651     {
3652     cb->text_set = TRUE;
3653     if (dns_basic_lookup(dnsa, query, T_TXT) == DNS_SUCCEED)
3654       for (dns_record * rr = dns_next_rr(dnsa, &dnss, RESET_ANSWERS); rr;
3655            rr = dns_next_rr(dnsa, &dnss, RESET_NEXT))
3656         if (rr->type == T_TXT)
3657           {
3658           int len = (rr->data)[0];
3659           if (len > 511) len = 127;
3660           store_pool = POOL_PERM;
3661           cb->text = string_sprintf("%.*s", len, CUS (rr->data+1));
3662           store_pool = old_pool;
3663           break;
3664           }
3665     }
3666
3667   dnslist_value = addlist;
3668   dnslist_text = cb->text;
3669   return OK;
3670   }
3671
3672 /* There was a problem with the DNS lookup */
3673
3674 if (cb->rc != DNS_NOMATCH && cb->rc != DNS_NODATA)
3675   {
3676   log_write(L_dnslist_defer, LOG_MAIN,
3677     "DNS list lookup defer (probably timeout) for %s: %s", query,
3678     (defer_return == OK)?   US"assumed in list" :
3679     (defer_return == FAIL)? US"assumed not in list" :
3680                             US"returned DEFER");
3681   return defer_return;
3682   }
3683
3684 /* No entry was found in the DNS; continue for next domain */
3685
3686 HDEBUG(D_dnsbl)
3687   {
3688   debug_printf("DNS lookup for %s failed\n", query);
3689   debug_printf("=> that means %s is not listed at %s\n",
3690      keydomain, domain);
3691   }
3692
3693 return FAIL;
3694 }
3695
3696
3697
3698
3699 /*************************************************
3700 *        Check host against DNS black lists      *
3701 *************************************************/
3702
3703 /* This function runs checks against a list of DNS black lists, until one
3704 matches. Each item on the list can be of the form
3705
3706   domain=ip-address/key
3707
3708 The domain is the right-most domain that is used for the query, for example,
3709 blackholes.mail-abuse.org. If the IP address is present, there is a match only
3710 if the DNS lookup returns a matching IP address. Several addresses may be
3711 given, comma-separated, for example: x.y.z=127.0.0.1,127.0.0.2.
3712
3713 If no key is given, what is looked up in the domain is the inverted IP address
3714 of the current client host. If a key is given, it is used to construct the
3715 domain for the lookup. For example:
3716
3717   dsn.rfc-ignorant.org/$sender_address_domain
3718
3719 After finding a match in the DNS, the domain is placed in $dnslist_domain, and
3720 then we check for a TXT record for an error message, and if found, save its
3721 value in $dnslist_text. We also cache everything in a tree, to optimize
3722 multiple lookups.
3723
3724 The TXT record is normally looked up in the same domain as the A record, but
3725 when many lists are combined in a single DNS domain, this will not be a very
3726 specific message. It is possible to specify a different domain for looking up
3727 TXT records; this is given before the main domain, comma-separated. For
3728 example:
3729
3730   dnslists = http.dnsbl.sorbs.net,dnsbl.sorbs.net=127.0.0.2 : \
3731              socks.dnsbl.sorbs.net,dnsbl.sorbs.net=127.0.0.3
3732
3733 The caching ensures that only one lookup in dnsbl.sorbs.net is done.
3734
3735 Note: an address for testing RBL is 192.203.178.39
3736 Note: an address for testing DUL is 192.203.178.4
3737 Note: a domain for testing RFCI is example.tld.dsn.rfc-ignorant.org
3738
3739 Arguments:
3740   where        the acl type
3741   listptr      the domain/address/data list
3742   log_msgptr   log message on error
3743
3744 Returns:    OK      successful lookup (i.e. the address is on the list), or
3745                       lookup deferred after +include_unknown
3746             FAIL    name not found, or no data found for the given type, or
3747                       lookup deferred after +exclude_unknown (default)
3748             DEFER   lookup failure, if +defer_unknown was set
3749 */
3750
3751 int
3752 verify_check_dnsbl(int where, const uschar ** listptr, uschar ** log_msgptr)
3753 {
3754 int sep = 0;
3755 int defer_return = FAIL;
3756 const uschar *list = *listptr;
3757 uschar *domain;
3758 uschar revadd[128];        /* Long enough for IPv6 address */
3759
3760 /* Indicate that the inverted IP address is not yet set up */
3761
3762 revadd[0] = 0;
3763
3764 /* In case this is the first time the DNS resolver is being used. */
3765
3766 dns_init(FALSE, FALSE, FALSE);  /*XXX dnssec? */
3767
3768 /* Loop through all the domains supplied, until something matches */
3769
3770 while ((domain = string_nextinlist(&list, &sep, NULL, 0)))
3771   {
3772   int rc;
3773   BOOL bitmask = FALSE;
3774   int match_type = 0;
3775   uschar *domain_txt;
3776   uschar *comma;
3777   uschar *iplist;
3778   uschar *key;
3779
3780   HDEBUG(D_dnsbl) debug_printf("dnslists check: %s\n", domain);
3781
3782   /* Deal with special values that change the behaviour on defer */
3783
3784   if (domain[0] == '+')
3785     {
3786     if      (strcmpic(domain, US"+include_unknown") == 0) defer_return = OK;
3787     else if (strcmpic(domain, US"+exclude_unknown") == 0) defer_return = FAIL;
3788     else if (strcmpic(domain, US"+defer_unknown") == 0)   defer_return = DEFER;
3789     else
3790       log_write(0, LOG_MAIN|LOG_PANIC, "unknown item in dnslist (ignored): %s",
3791         domain);
3792     continue;
3793     }
3794
3795   /* See if there's explicit data to be looked up */
3796
3797   if ((key = Ustrchr(domain, '/'))) *key++ = 0;
3798
3799   /* See if there's a list of addresses supplied after the domain name. This is
3800   introduced by an = or a & character; if preceded by = we require all matches
3801   and if preceded by ! we invert the result. */
3802
3803   if (!(iplist = Ustrchr(domain, '=')))
3804     {
3805     bitmask = TRUE;
3806     iplist = Ustrchr(domain, '&');
3807     }
3808
3809   if (iplist)                                  /* Found either = or & */
3810     {
3811     if (iplist > domain && iplist[-1] == '!')  /* Handle preceding ! */
3812       {
3813       match_type |= MT_NOT;
3814       iplist[-1] = 0;
3815       }
3816
3817     *iplist++ = 0;                             /* Terminate domain, move on */
3818
3819     /* If we found = (bitmask == FALSE), check for == or =& */
3820
3821     if (!bitmask && (*iplist == '=' || *iplist == '&'))
3822       {
3823       bitmask = *iplist++ == '&';
3824       match_type |= MT_ALL;
3825       }
3826     }
3827
3828
3829   /* If there is a comma in the domain, it indicates that a second domain for
3830   looking up TXT records is provided, before the main domain. Otherwise we must
3831   set domain_txt == domain. */
3832
3833   domain_txt = domain;
3834   if ((comma = Ustrchr(domain, ',')))
3835     {
3836     *comma++ = 0;
3837     domain = comma;
3838     }
3839
3840   /* Check that what we have left is a sensible domain name. There is no reason
3841   why these domains should in fact use the same syntax as hosts and email
3842   domains, but in practice they seem to. However, there is little point in
3843   actually causing an error here, because that would no doubt hold up incoming
3844   mail. Instead, I'll just log it. */
3845
3846   for (uschar * s = domain; *s; s++)
3847     if (!isalnum(*s) && *s != '-' && *s != '.' && *s != '_')
3848       {
3849       log_write(0, LOG_MAIN, "dnslists domain \"%s\" contains "
3850         "strange characters - is this right?", domain);
3851       break;
3852       }
3853
3854   /* Check the alternate domain if present */
3855
3856   if (domain_txt != domain) for (uschar * s = domain_txt; *s; s++)
3857     if (!isalnum(*s) && *s != '-' && *s != '.' && *s != '_')
3858       {
3859       log_write(0, LOG_MAIN, "dnslists domain \"%s\" contains "
3860         "strange characters - is this right?", domain_txt);
3861       break;
3862       }
3863
3864   /* If there is no key string, construct the query by adding the domain name
3865   onto the inverted host address, and perform a single DNS lookup. */
3866
3867   if (!key)
3868     {
3869     if (where == ACL_WHERE_NOTSMTP_START || where == ACL_WHERE_NOTSMTP)
3870       {
3871       *log_msgptr = string_sprintf
3872         ("cannot test auto-keyed dnslists condition in %s ACL",
3873           acl_wherenames[where]);
3874       return ERROR;
3875       }
3876     if (!sender_host_address) return FAIL;    /* can never match */
3877     if (revadd[0] == 0) invert_address(revadd, sender_host_address);
3878     rc = one_check_dnsbl(domain, domain_txt, sender_host_address, revadd,
3879       iplist, bitmask, match_type, defer_return);
3880     if (rc == OK)
3881       {
3882       dnslist_domain = string_copy(domain_txt);
3883       dnslist_matched = string_copy(sender_host_address);
3884       HDEBUG(D_dnsbl) debug_printf("=> that means %s is listed at %s\n",
3885         sender_host_address, dnslist_domain);
3886       }
3887     if (rc != FAIL) return rc;     /* OK or DEFER */
3888     }
3889
3890   /* If there is a key string, it can be a list of domains or IP addresses to
3891   be concatenated with the main domain. */
3892
3893   else
3894     {
3895     int keysep = 0;
3896     BOOL defer = FALSE;
3897     uschar *keydomain;
3898     uschar keyrevadd[128];
3899
3900     while ((keydomain = string_nextinlist(CUSS &key, &keysep, NULL, 0)))
3901       {
3902       uschar *prepend = keydomain;
3903
3904       if (string_is_ip_address(keydomain, NULL) != 0)
3905         {
3906         invert_address(keyrevadd, keydomain);
3907         prepend = keyrevadd;
3908         }
3909
3910       rc = one_check_dnsbl(domain, domain_txt, keydomain, prepend, iplist,
3911         bitmask, match_type, defer_return);
3912       if (rc == OK)
3913         {
3914         dnslist_domain = string_copy(domain_txt);
3915         dnslist_matched = string_copy(keydomain);
3916         HDEBUG(D_dnsbl) debug_printf("=> that means %s is listed at %s\n",
3917           keydomain, dnslist_domain);
3918         return OK;
3919         }
3920
3921       /* If the lookup deferred, remember this fact. We keep trying the rest
3922       of the list to see if we get a useful result, and if we don't, we return
3923       DEFER at the end. */
3924
3925       if (rc == DEFER) defer = TRUE;
3926       }    /* continue with next keystring domain/address */
3927
3928     if (defer) return DEFER;
3929     }
3930   }        /* continue with next dnsdb outer domain */
3931
3932 return FAIL;
3933 }
3934
3935
3936
3937 /****************************************************
3938   Verify a local user account for quota sufficiency
3939 ****************************************************/
3940
3941 /* The real work, done via a re-exec for privs, calls
3942 down to the transport for the quota check.
3943
3944 Route and transport (in recipient-verify mode) the
3945 given recipient. 
3946
3947 A routing result indicating any transport type other than appendfile
3948 results in a fail.
3949
3950 Return, on stdout, a result string containing:
3951 - highlevel result code (OK, DEFER, FAIL)
3952 - errno
3953 - where string
3954 - message string
3955 */
3956
3957 void
3958 verify_quota(uschar * address)
3959 {
3960 address_item vaddr = {.address = address};
3961 BOOL routed;
3962 uschar * msg = US"\0";
3963 int rc, len = 1;
3964
3965 if ((rc = verify_address(&vaddr, NULL, vopt_is_recipient | vopt_quota,
3966     1, 0, 0, NULL, NULL, &routed)) != OK)
3967   {
3968   uschar * where = recipient_verify_failure;
3969   msg = acl_verify_message ? acl_verify_message : vaddr.message;
3970   if (!msg) msg = US"";
3971   if (rc == DEFER && vaddr.basic_errno == ERRNO_EXIMQUOTA)
3972     {
3973     rc = FAIL;                                  /* DEFER -> FAIL */
3974     where = US"quota";
3975     vaddr.basic_errno = 0;
3976     }
3977   else if (!where) where = US"";
3978
3979   len = 5 + Ustrlen(msg) + 1 + Ustrlen(where);
3980   msg = string_sprintf("%c%c%c%c%c%s%c%s", (uschar)rc,
3981     (vaddr.basic_errno >> 24) && 0xff, (vaddr.basic_errno >> 16) && 0xff,
3982     (vaddr.basic_errno >> 8) && 0xff, vaddr.basic_errno && 0xff,
3983     where, '\0', msg);
3984   }
3985
3986 DEBUG(D_verify) debug_printf_indent("verify_quota: len %d\n", len);
3987 write(1, msg, len);
3988 return;
3989 }
3990
3991
3992 /******************************************************************************/
3993
3994 /* Quota cache lookup.  We use the callout hints db also for the quota cache.
3995 Return TRUE if a nonexpired record was found, having filled in the yield
3996 argument.
3997 */
3998
3999 static BOOL
4000 cached_quota_lookup(const uschar * rcpt, int * yield,
4001   int pos_cache, int neg_cache)
4002 {
4003 open_db dbblock, *dbm_file = NULL;
4004 dbdata_callout_cache_address * cache_address_record;
4005
4006 if (!pos_cache && !neg_cache)
4007   return FALSE;
4008 if (!(dbm_file = dbfn_open(US"callout", O_RDWR, &dbblock, FALSE, TRUE)))
4009   {
4010   HDEBUG(D_verify) debug_printf_indent("quota cache: not available\n");
4011   return FALSE;
4012   }
4013 if (!(cache_address_record = (dbdata_callout_cache_address *)
4014     get_callout_cache_record(dbm_file, rcpt, US"address",
4015       pos_cache, neg_cache)))
4016   {
4017   dbfn_close(dbm_file);
4018   return FALSE;
4019   }
4020 if (cache_address_record->result == ccache_accept)
4021   *yield = OK;
4022 dbfn_close(dbm_file);
4023 return TRUE;
4024 }
4025
4026 /* Quota cache write */
4027
4028 static void
4029 cache_quota_write(const uschar * rcpt, int yield, int pos_cache, int neg_cache)
4030 {
4031 open_db dbblock, *dbm_file = NULL;
4032 dbdata_callout_cache_address cache_address_record;
4033
4034 if (!pos_cache && !neg_cache)
4035   return;
4036 if (!(dbm_file = dbfn_open(US"callout", O_RDWR|O_CREAT, &dbblock, FALSE, TRUE)))
4037   {
4038   HDEBUG(D_verify) debug_printf_indent("quota cache: not available\n");
4039   return;
4040   }
4041
4042 cache_address_record.result = yield == OK ? ccache_accept : ccache_reject;
4043
4044 (void)dbfn_write(dbm_file, rcpt, &cache_address_record,
4045         (int)sizeof(dbdata_callout_cache_address));
4046 HDEBUG(D_verify) debug_printf_indent("wrote %s quota cache record for %s\n",
4047       yield == OK ? "positive" : "negative", rcpt);
4048
4049 dbfn_close(dbm_file);
4050 return;
4051 }
4052
4053
4054 /* To evaluate a local user's quota, starting in ACL, we need to
4055 fork & exec to regain privileges, to that we can change to the user's
4056 identity for access to their files.
4057
4058 Arguments:
4059  rcpt           Recipient account
4060  pos_cache      Number of seconds to cache a positive result (delivery
4061                 to be accepted).  Zero to disable caching.
4062  neg_cache      Number of seconds to cache a negative result.  Zero to disable.
4063  msg            Pointer to result string pointer
4064
4065 Return:         OK/DEFER/FAIL code
4066 */
4067
4068 int
4069 verify_quota_call(const uschar * rcpt, int pos_cache, int neg_cache,
4070   uschar ** msg)
4071 {
4072 int pfd[2], pid, save_errno, yield = FAIL;
4073 void (*oldsignal)(int);
4074 const uschar * where = US"socketpair";
4075
4076 *msg = NULL;
4077
4078 if (cached_quota_lookup(rcpt, &yield, pos_cache, neg_cache))
4079   {
4080   HDEBUG(D_verify) debug_printf_indent("quota cache: address record is %s\n",
4081     yield == OK ? "positive" : "negative");
4082   if (yield != OK)
4083     {
4084     recipient_verify_failure = US"quota";
4085     acl_verify_message = *msg =
4086       US"Previous (cached) quota verification failure";
4087     }
4088   return yield;
4089   }
4090
4091 if (pipe(pfd) != 0)
4092   goto fail;
4093
4094 where = US"fork";
4095 oldsignal = signal(SIGCHLD, SIG_DFL);
4096 if ((pid = exim_fork(US"quota-verify")) < 0)
4097   {
4098   save_errno = errno;
4099   close(pfd[pipe_write]);
4100   close(pfd[pipe_read]);
4101   errno = save_errno;
4102   goto fail;
4103   }
4104
4105 if (pid == 0)           /* child */
4106   {
4107   close(pfd[pipe_read]);
4108   force_fd(pfd[pipe_write], 1);         /* stdout to pipe */
4109   close(pfd[pipe_write]);
4110   dup2(1, 0);
4111   if (debug_fd > 0) force_fd(debug_fd, 2);
4112
4113   child_exec_exim(CEE_EXEC_EXIT, FALSE, NULL, FALSE, 3,
4114     US"-MCq", string_sprintf("%d", message_size), rcpt);
4115   /*NOTREACHED*/
4116   }
4117
4118 save_errno = errno;
4119 close(pfd[pipe_write]);
4120
4121 if (pid < 0)
4122   {
4123   DEBUG(D_verify) debug_printf_indent(" fork: %s\n", strerror(save_errno));
4124   }
4125 else
4126   {
4127   uschar buf[128];
4128   int n = read(pfd[pipe_read], buf, sizeof(buf));
4129   int status;
4130
4131   waitpid(pid, &status, 0);
4132   if (status == 0)
4133     {
4134     uschar * s;
4135
4136     if (n > 0) yield = buf[0];
4137     if (n > 4)
4138       save_errno = (buf[1] << 24) | (buf[2] << 16) | (buf[3] << 8) | buf[4];
4139     if ((recipient_verify_failure = n > 5
4140         ? string_copyn_taint(buf+5, n-5, FALSE) : NULL))
4141       {
4142       int m;
4143       s = buf + 5 + Ustrlen(recipient_verify_failure) + 1;
4144       m = n - (s - buf);
4145       acl_verify_message = *msg =
4146         m > 0 ? string_copyn_taint(s, m, FALSE) : NULL;
4147       }
4148
4149     DEBUG(D_verify) debug_printf_indent("verify call response:"
4150       " len %d yield %s errno '%s' where '%s' msg '%s'\n",
4151       n, rc_names[yield], strerror(save_errno), recipient_verify_failure, *msg);
4152
4153     if (  yield == OK
4154        || save_errno == 0 && Ustrcmp(recipient_verify_failure, "quota") == 0)
4155       cache_quota_write(rcpt, yield, pos_cache, neg_cache);
4156     else DEBUG(D_verify)
4157       debug_printf_indent("result not cacheable\n");
4158     }
4159   else
4160     {
4161     DEBUG(D_verify)
4162       debug_printf_indent("verify call response: waitpid status 0x%04x\n", status);
4163     }
4164   }
4165
4166 close(pfd[pipe_read]);
4167 errno = save_errno;
4168
4169 fail:
4170
4171 return yield;
4172 }
4173
4174
4175 /* vi: aw ai sw=2
4176 */
4177 /* End of verify.c */