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