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