d4c3008ba38286fbb23824e5d59303bb3d6f4dde
[users/heiko/exim.git] / src / src / match.c
1 /*************************************************
2 *     Exim - an Internet mail transport agent    *
3 *************************************************/
4
5 /* Copyright (c) University of Cambridge 1995 - 2018 */
6 /* Copyright (c) The Exim Maintainers 2020 */
7 /* See the file NOTICE for conditions of use and distribution. */
8
9 /* Functions for matching strings */
10
11
12 #include "exim.h"
13
14
15 /* Argument block for the check_string() function. This is used for general
16 strings, domains, and local parts. */
17
18 typedef struct check_string_block {
19   const uschar *origsubject;           /* caseful; keep these two first, in */
20   const uschar *subject;               /* step with the block below */
21   int    expand_setup;
22   BOOL   use_partial;
23   BOOL   caseless;
24   BOOL   at_is_special;
25 } check_string_block;
26
27
28 /* Argument block for the check_address() function. This is used for whole
29 addresses. */
30
31 typedef struct check_address_block {
32   const uschar *origaddress;         /* caseful; keep these two first, in */
33   uschar *address;                   /* step with the block above */
34   int    expand_setup;
35   BOOL   caseless;
36 } check_address_block;
37
38
39
40 /*************************************************
41 *           Generalized string match             *
42 *************************************************/
43
44 /* This function does a single match of a subject against a pattern, and
45 optionally sets up the numeric variables according to what it matched. It is
46 called from match_isinlist() via match_check_list() when scanning a list, and
47 from match_check_string() when testing just a single item. The subject and
48 options arguments are passed in a check_string_block so as to make it easier to
49 pass them through match_check_list.
50
51 The possible types of pattern are:
52
53   . regular expression - starts with ^
54   . tail match - starts with *
55   . lookup - starts with search type
56   . if at_is_special is set in the argument block:
57       @              matches the primary host name
58       @[]            matches a local IP address in brackets
59       @mx_any        matches any domain with an MX to the local host
60       @mx_primary    matches any domain with a primary MX to the local host
61       @mx_secondary  matches any domain with a secondary MX to the local host
62   . literal - anything else
63
64 Any of the @mx_xxx options can be followed by "/ignore=<list>" where <list> is
65 a list of IP addresses that are to be ignored (typically 127.0.0.1).
66
67 Arguments:
68   arg            check_string_block pointer - see below
69   pattern        the pattern to be matched
70   valueptr       if not NULL, and a lookup is done, return the result here
71                    instead of discarding it; else set it to point to NULL
72   error          for error messages (not used in this function; it never
73                    returns ERROR)
74
75 Contents of the argument block:
76   origsubject    the subject in its original casing
77   subject        the subject string to be checked, lowercased if caseless
78   expand_setup   if < 0, don't set up any numeric expansion variables;
79                  if = 0, set $0 to whole subject, and either
80                    $1 to what matches * or
81                    $1, $2, ... to r.e. bracketed items
82                  if > 0, don't set $0, but do set either
83                    $n to what matches *, or
84                    $n, $n+1, ... to r.e. bracketed items
85                  (where n = expand_setup)
86   use_partial    if FALSE, override any partial- search types
87   caseless       TRUE for caseless matching where possible
88   at_is_special  enable special handling of items starting with @
89
90 Returns:       OK    if matched
91                FAIL  if not matched
92                DEFER if lookup deferred
93 */
94
95 static int
96 check_string(void *arg, const uschar *pattern, const uschar **valueptr, uschar **error)
97 {
98 const check_string_block *cb = arg;
99 int search_type, partial, affixlen, starflags;
100 int expand_setup = cb->expand_setup;
101 const uschar * affix, * opts;
102 uschar *s;
103 uschar *filename = NULL;
104 uschar *keyquery, *result, *semicolon;
105 void *handle;
106
107 error = error;  /* Keep clever compilers from complaining */
108
109 if (valueptr != NULL) *valueptr = NULL;  /* For non-lookup matches */
110
111 /* For regular expressions, use cb->origsubject rather than cb->subject so that
112 it works if the pattern uses (?-i) to turn off case-independence, overriding
113 "caseless". */
114
115 s = string_copy(pattern[0] == '^' ? cb->origsubject : cb->subject);
116
117 /* If required to set up $0, initialize the data but don't turn on by setting
118 expand_nmax until the match is assured. */
119
120 expand_nmax = -1;
121 if (expand_setup == 0)
122   {
123   expand_nstring[0] = s;
124   expand_nlength[0] = Ustrlen(s);
125   }
126 else if (expand_setup > 0) expand_setup--;
127
128 /* Regular expression match: compile, match, and set up $ variables if
129 required. */
130
131 if (pattern[0] == '^')
132   {
133   const pcre * re = regex_must_compile(pattern, cb->caseless, FALSE);
134   return (expand_setup < 0
135           ? pcre_exec(re, NULL, CCS s, Ustrlen(s), 0, PCRE_EOPT, NULL, 0) >= 0
136           : regex_match_and_setup(re, s, 0, expand_setup)
137          )
138          ? OK : FAIL;
139   }
140
141 /* Tail match */
142
143 if (pattern[0] == '*')
144   {
145   int slen = Ustrlen(s);
146   int patlen;    /* Sun compiler doesn't like non-constant initializer */
147
148   patlen = Ustrlen(++pattern);
149   if (patlen > slen) return FAIL;
150   if (cb->caseless
151       ? strncmpic(s + slen - patlen, pattern, patlen) != 0
152       : Ustrncmp(s + slen - patlen, pattern, patlen) != 0)
153     return FAIL;
154   if (expand_setup >= 0)
155     {
156     expand_nstring[++expand_setup] = s;
157     expand_nlength[expand_setup] = slen - patlen;
158     expand_nmax = expand_setup;
159     }
160   if (valueptr) *valueptr = pattern;
161   return OK;
162   }
163
164 /* Match a special item starting with @ if so enabled. On its own, "@" matches
165 the primary host name - implement this by changing the pattern. For the other
166 cases we have to do some more work. If we don't recognize a special pattern,
167 just fall through - the match will fail. */
168
169 if (cb->at_is_special && pattern[0] == '@')
170   {
171   if (pattern[1] == 0)
172     {
173     pattern = primary_hostname;
174     goto NOT_AT_SPECIAL;               /* Handle as exact string match */
175     }
176
177   if (Ustrcmp(pattern, "@[]") == 0)
178     {
179     int slen = Ustrlen(s);
180     if (s[0] != '[' && s[slen-1] != ']') return FAIL;
181     for (ip_address_item * ip = host_find_interfaces(); ip; ip = ip->next)
182       if (Ustrncmp(ip->address, s+1, slen - 2) == 0
183             && ip->address[slen - 2] == 0)
184         {
185         if (valueptr) *valueptr = pattern;
186         return OK;
187         }
188     return FAIL;
189     }
190
191   if (strncmpic(pattern, US"@mx_", 4) == 0)
192     {
193     int rc;
194     host_item h;
195     BOOL prim = FALSE;
196     BOOL secy = FALSE;
197     BOOL removed = FALSE;
198     const uschar *ss = pattern + 4;
199     const uschar *ignore_target_hosts = NULL;
200
201     if (strncmpic(ss, US"any", 3) == 0) ss += 3;
202     else if (strncmpic(ss, US"primary", 7) == 0)
203       {
204       ss += 7;
205       prim = TRUE;
206       }
207     else if (strncmpic(ss, US"secondary", 9) == 0)
208       {
209       ss += 9;
210       secy = TRUE;
211       }
212     else goto NOT_AT_SPECIAL;
213
214     if (strncmpic(ss, US"/ignore=", 8) == 0) ignore_target_hosts = ss + 8;
215     else if (*ss) goto NOT_AT_SPECIAL;
216
217     h.next = NULL;
218     h.name = s;
219     h.address = NULL;
220
221     rc = host_find_bydns(&h,
222       ignore_target_hosts,
223       HOST_FIND_BY_MX,     /* search only for MX, not SRV or A */
224       NULL,                /* service name not relevant */
225       NULL,                /* srv_fail_domains not relevant */
226       NULL,                /* mx_fail_domains not relevant */
227       NULL,                /* no dnssec request/require XXX ? */
228       NULL,                /* no feedback FQDN */
229       &removed);           /* feedback if local removed */
230
231     if (rc == HOST_FIND_AGAIN)
232       {
233       search_error_message = string_sprintf("DNS lookup of \"%s\" deferred", s);
234       return DEFER;
235       }
236
237     if (rc != HOST_FOUND_LOCAL || secy)
238       if (prim || !removed) return FAIL;
239     if (valueptr) *valueptr = pattern;
240     return OK;
241
242     /*** The above line used to be the following line, but this is incorrect,
243     because host_find_bydns() may return HOST_NOT_FOUND if it removed some MX
244     hosts, but the remaining ones were non-existent. All we are interested in
245     is whether or not it removed some hosts.
246
247     return (rc == HOST_FOUND && removed)? OK : FAIL;
248     ***/
249     }
250   }
251
252 /* Escape point from code for specials that start with "@" */
253
254 NOT_AT_SPECIAL:
255
256 /* This is an exact string match if there is no semicolon in the pattern. */
257
258 if ((semicolon = Ustrchr(pattern, ';')) == NULL)
259   {
260   if (cb->caseless ? strcmpic(s, pattern) != 0 : Ustrcmp(s, pattern) != 0)
261     return FAIL;
262   if (expand_setup >= 0) expand_nmax = expand_setup;
263   if (valueptr) *valueptr = pattern;
264   return OK;
265
266 /*
267 XXX  looks like $0 may be usable
268 XXX  could add setting of *valueptr to all the OK returns; seems doable here, the Q
269      is: what effect would it have at config-file level.  domain_data & local_part_data
270      would get filled in... might anyone be checking it for emptiness?  I think the docs
271      do not say "will be empty otherwise", so that seems ok.
272 XXX WORRY: we get new caching of named-list match results.  Is that cache checked
273      for the key being matched?
274 XXX  could also add $0 fill-in with the matching text for pattern?  RE already has it,
275      tailmatch already has it, @[] => dotted.quad.etc, @mx => h->address ?
276 */
277   }
278
279 /* Otherwise we have a lookup item. The lookup type, including partial, etc. is
280 the part of the string preceding the semicolon. */
281
282 *semicolon = 0;
283 search_type = search_findtype_partial(pattern, &partial, &affix, &affixlen,
284   &starflags, &opts);
285 *semicolon = ';';
286 if (search_type < 0) log_write(0, LOG_MAIN|LOG_PANIC_DIE, "%s",
287   search_error_message);
288
289 /* Partial matching is not appropriate for certain lookups (e.g. when looking
290 up user@domain for sender rejection). There's a flag to disable it. */
291
292 if (!cb->use_partial) partial = -1;
293
294 /* Set the parameters for the three different kinds of lookup. */
295
296 keyquery = semicolon + 1;
297 Uskip_whitespace(&keyquery);
298
299 if (mac_islookup(search_type, lookup_absfilequery))
300   {
301   filename = keyquery;
302   while (*keyquery && !isspace(*keyquery)) keyquery++;
303   filename = string_copyn(filename, keyquery - filename);
304   Uskip_whitespace(&keyquery);
305   }
306
307 else if (!mac_islookup(search_type, lookup_querystyle))
308   {
309   filename = keyquery;
310   keyquery = s;
311   }
312
313 /* Now do the actual lookup; throw away the data returned unless it was asked
314 for; partial matching is all handled inside search_find(). Note that there is
315 no search_close() because of the caching arrangements. */
316
317 if (!(handle = search_open(filename, search_type, 0, NULL, NULL)))
318   log_write(0, LOG_MAIN|LOG_PANIC_DIE, "%s", search_error_message);
319 result = search_find(handle, filename, keyquery, partial, affix, affixlen,
320   starflags, &expand_setup, opts);
321
322 if (!result) return f.search_find_defer ? DEFER : FAIL;
323 if (valueptr) *valueptr = result;
324
325 expand_nmax = expand_setup;
326 return OK;
327 }
328
329
330
331 /*************************************************
332 *      Public interface to check_string()        *
333 *************************************************/
334
335 /* This function is called from several places where is it most convenient to
336 pass the arguments individually. It places them in a check_string_block
337 structure, and then calls check_string().
338
339 Arguments:
340   s            the subject string to be checked
341   pattern      the pattern to check it against
342   expand_setup expansion setup option (see check_string())
343   use_partial  if FALSE, override any partial- search types
344   caseless     TRUE for caseless matching where possible
345   at_is_special TRUE to recognize @, @[], etc.
346   valueptr     if not NULL, and a file lookup was done, return the result
347                  here instead of discarding it; else set it to point to NULL
348
349 Returns:       OK    if matched
350                FAIL  if not matched
351                DEFER if lookup deferred
352 */
353
354 int
355 match_check_string(const uschar *s, const uschar *pattern, int expand_setup,
356   BOOL use_partial, BOOL caseless, BOOL at_is_special, const uschar **valueptr)
357 {
358 check_string_block cb;
359 cb.origsubject = s;
360 cb.subject = caseless? string_copylc(s) : string_copy(s);
361 cb.expand_setup = expand_setup;
362 cb.use_partial = use_partial;
363 cb.caseless = caseless;
364 cb.at_is_special = at_is_special;
365 return check_string(&cb, pattern, valueptr, NULL);
366 }
367
368
369
370 /*************************************************
371 *       Get key string from check block          *
372 *************************************************/
373
374 /* When caching the data from a lookup for a named list, we have to save the
375 key that was found, because other lookups of different keys on the same list
376 may occur. This function has knowledge of the different lookup types, and
377 extracts the appropriate key.
378
379 Arguments:
380   arg          the check block
381   type         MCL_STRING, MCL_DOMAIN, MCL_HOST, MCL_ADDRESS, or MCL_LOCALPART
382 */
383
384 static const uschar *
385 get_check_key(void *arg, int type)
386 {
387 switch(type)
388   {
389   case MCL_STRING:
390   case MCL_DOMAIN:
391   case MCL_LOCALPART:
392   return ((check_string_block *)arg)->subject;
393
394   case MCL_HOST:
395   return ((check_host_block *)arg)->host_address;
396
397   case MCL_ADDRESS:
398   return ((check_address_block *)arg)->address;
399   }
400 return US"";  /* In practice, should never happen */
401 }
402
403
404
405 /*************************************************
406 *       Scan list and run matching function      *
407 *************************************************/
408
409 /* This function scans a list of patterns, and runs a matching function for
410 each item in the list. It is called from the functions that match domains,
411 local parts, hosts, and addresses, because its overall structure is the same in
412 all cases. However, the details of each particular match is different, so it
413 calls back to a given function do perform an actual match.
414
415 We can't quite keep the different types anonymous here because they permit
416 different special cases. A pity.
417
418 If a list item starts with !, that implies negation if the subject matches the
419 rest of the item (ignoring white space after the !). The result when the end of
420 the list is reached is FALSE unless the last item on the list is negated, in
421 which case it is TRUE. A file name in the list causes its lines to be
422 interpolated as if items in the list. An item starting with + is a named
423 sublist, obtained by searching the tree pointed to by anchorptr, with possible
424 cached match results in cache_bits.
425
426 Arguments:
427   listptr      pointer to the pointer to the list
428   sep          separator character for string_nextinlist();
429                  normally zero for a standard list;
430                  sometimes UCHAR_MAX+1 for single items;
431   anchorptr    -> tree of named items, or NULL if no named items
432   cache_ptr    pointer to pointer to cache bits for named items, or
433                  pointer to NULL if not caching; may get set NULL if an
434                  uncacheable named list is encountered
435   func         function to call back to do one test
436   arg          pointer to pass to the function; the string to be matched is
437                  in the structure it points to
438   type         MCL_STRING, MCL_DOMAIN, MCL_HOST, MCL_ADDRESS, or MCL_LOCALPART
439                  these are used for some special handling
440                MCL_NOEXPAND (whose value is greater than any of them) may
441                  be added to any value to suppress expansion of the list
442   name         string to use in debugging info
443   valueptr     where to pass back data from a lookup
444
445 Returns:       OK    if matched a non-negated item
446                OK    if hit end of list after a negated item
447                FAIL  if expansion force-failed
448                FAIL  if matched a negated item
449                FAIL  if hit end of list after a non-negated item
450                DEFER if a something deferred or expansion failed
451 */
452
453 int
454 match_check_list(const uschar **listptr, int sep, tree_node **anchorptr,
455   unsigned int **cache_ptr, int (*func)(void *,const uschar *,const uschar **,uschar **),
456   void *arg, int type, const uschar *name, const uschar **valueptr)
457 {
458 int yield = OK;
459 unsigned int *original_cache_bits = *cache_ptr;
460 BOOL include_unknown = FALSE;
461 BOOL ignore_unknown = FALSE;
462 BOOL include_defer = FALSE;
463 BOOL ignore_defer = FALSE;
464 const uschar *list;
465 uschar *sss;
466 uschar *ot = NULL;
467
468 /* Save time by not scanning for the option name when we don't need it. */
469
470 HDEBUG(D_any)
471   {
472   uschar *listname = readconf_find_option(listptr);
473   if (listname[0] != 0) ot = string_sprintf("%s in %s?", name, listname);
474   }
475
476 /* If the list is empty, the answer is no. Skip the debugging output for
477 an unnamed list. */
478
479 if (!*listptr)
480   {
481   HDEBUG(D_lists) if (ot) debug_printf("%s no (option unset)\n", ot);
482   return FAIL;
483   }
484
485 /* Expand the list before we scan it. A forced expansion gives the answer
486 "not in list"; other expansion errors cause DEFER to be returned. However,
487 if the type value is greater than or equal to than MCL_NOEXPAND, do not expand
488 the list. */
489
490 if (type >= MCL_NOEXPAND)
491   {
492   list = *listptr;
493   type -= MCL_NOEXPAND;       /* Remove the "no expand" flag */
494   }
495 else
496   {
497   /* If we are searching a domain list, and $domain is not set, set it to the
498   subject that is being sought for the duration of the expansion. */
499
500   if (type == MCL_DOMAIN && !deliver_domain)
501     {
502     check_string_block *cb = (check_string_block *)arg;
503     deliver_domain = string_copy(cb->subject);
504     list = expand_cstring(*listptr);
505     deliver_domain = NULL;
506     }
507   else
508     list = expand_cstring(*listptr);
509
510   if (!list)
511     {
512     if (f.expand_string_forcedfail)
513       {
514       HDEBUG(D_lists) debug_printf("expansion of \"%s\" forced failure: "
515         "assume not in this list\n", *listptr);
516       return FAIL;
517       }
518     log_write(0, LOG_MAIN|LOG_PANIC, "failed to expand \"%s\" while checking "
519       "a list: %s", *listptr, expand_string_message);
520     return DEFER;
521     }
522   }
523
524 /* For an unnamed list, use the expanded version in comments */
525
526 HDEBUG(D_any) if (!ot) ot = string_sprintf("%s in \"%s\"?", name, list);
527
528 /* Now scan the list and process each item in turn, until one of them matches,
529 or we hit an error. */
530
531 while ((sss = string_nextinlist(&list, &sep, NULL, 0)))
532   {
533   uschar * ss = sss;
534
535   /* Address lists may contain +caseful, to restore caseful matching of the
536   local part. We have to know the layout of the control block, unfortunately.
537   The lower cased address is in a temporary buffer, so we just copy the local
538   part back to the start of it (if a local part exists). */
539
540   if (type == MCL_ADDRESS)
541     {
542     if (Ustrcmp(ss, "+caseful") == 0)
543       {
544       check_address_block *cb = (check_address_block *)arg;
545       uschar *at = Ustrrchr(cb->origaddress, '@');
546
547       if (at)
548         Ustrncpy(cb->address, cb->origaddress, at - cb->origaddress);
549       cb->caseless = FALSE;
550       continue;
551       }
552     }
553
554   /* Similar processing for local parts */
555
556   else if (type == MCL_LOCALPART)
557     {
558     if (Ustrcmp(ss, "+caseful") == 0)
559       {
560       check_string_block *cb = (check_string_block *)arg;
561       Ustrcpy(US cb->subject, cb->origsubject);
562       cb->caseless = FALSE;
563       continue;
564       }
565     }
566
567   /* If the host item is "+include_unknown" or "+ignore_unknown", remember it
568   in case there's a subsequent failed reverse lookup. There is similar
569   processing for "defer". */
570
571   else if (type == MCL_HOST && *ss == '+')
572     {
573     if (Ustrcmp(ss, "+include_unknown") == 0)
574       {
575       include_unknown = TRUE;
576       ignore_unknown = FALSE;
577       continue;
578       }
579     if (Ustrcmp(ss, "+ignore_unknown") == 0)
580       {
581       ignore_unknown = TRUE;
582       include_unknown = FALSE;
583       continue;
584       }
585     if (Ustrcmp(ss, "+include_defer") == 0)
586       {
587       include_defer = TRUE;
588       ignore_defer = FALSE;
589       continue;
590       }
591     if (Ustrcmp(ss, "+ignore_defer") == 0)
592       {
593       ignore_defer = TRUE;
594       include_defer = FALSE;
595       continue;
596       }
597     }
598
599   /* Starting with ! specifies a negative item. It is theoretically possible
600   for a local part to start with !. In that case, a regex has to be used. */
601
602   if (*ss == '!')
603     {
604     yield = FAIL;
605     while (isspace((*(++ss))));
606     }
607   else
608     yield = OK;
609
610   /* If the item does not begin with '/', it might be a + item for a named
611   list. Otherwise, it is just a single list entry that has to be matched.
612   We recognize '+' only when supplied with a tree of named lists. */
613
614   if (*ss != '/')
615     {
616     if (*ss == '+' && anchorptr)
617       {
618       int bits = 0;
619       int offset = 0;
620       int shift = 0;
621       unsigned int *use_cache_bits = original_cache_bits;
622       uschar *cached = US"";
623       namedlist_block *nb;
624       tree_node * t;
625
626       if (!(t = tree_search(*anchorptr, ss+1)))
627         {
628         log_write(0, LOG_MAIN|LOG_PANIC, "unknown named%s list \"%s\"",
629           type == MCL_DOMAIN ?    " domain" :
630           type == MCL_HOST ?      " host" :
631           type == MCL_ADDRESS ?   " address" :
632           type == MCL_LOCALPART ? " local part" : "",
633           ss);
634         return DEFER;
635         }
636       nb = t->data.ptr;
637
638       /* If the list number is negative, it means that this list is not
639       cacheable because it contains expansion items. */
640
641       if (nb->number < 0) use_cache_bits = NULL;
642
643       /* If we have got a cache pointer, get the bits. This is not an "else"
644       because the pointer may be NULL from the start if caching is not
645       required. */
646
647       if (use_cache_bits)
648         {
649         offset = (nb->number)/16;
650         shift = ((nb->number)%16)*2;
651         bits = use_cache_bits[offset] & (3 << shift);
652         }
653
654       /* Not previously tested or no cache - run the full test */
655
656       if (bits == 0)
657         {
658         switch (match_check_list(&(nb->string), 0, anchorptr, &use_cache_bits,
659                 func, arg, type, name, valueptr))
660           {
661           case OK:   bits = 1; break;
662           case FAIL: bits = 3; break;
663           case DEFER: goto DEFER_RETURN;
664           }
665
666         /* If this list was uncacheable, or a sublist turned out to be
667         uncacheable, the value of use_cache_bits will now be NULL, even if it
668         wasn't before. Ensure that this is passed up to the next level.
669         Otherwise, remember the result of the search in the cache. */
670
671         if (!use_cache_bits)
672           *cache_ptr = NULL;
673         else
674           {
675           use_cache_bits[offset] |= bits << shift;
676
677           if (valueptr)
678             {
679             int old_pool = store_pool;
680             namedlist_cacheblock *p;
681
682             /* Cached data for hosts persists over more than one message,
683             so we use the permanent store pool */
684
685             store_pool = POOL_PERM;
686             p = store_get(sizeof(namedlist_cacheblock), FALSE);
687             p->key = string_copy(get_check_key(arg, type));
688
689
690             p->data = *valueptr ? string_copy(*valueptr) : NULL;
691             store_pool = old_pool;
692
693             p->next = nb->cache_data;
694             nb->cache_data = p;
695             if (*valueptr)
696               DEBUG(D_lists) debug_printf("data from lookup saved for "
697                 "cache for %s: %s\n", ss, *valueptr);
698             }
699           }
700         }
701
702        /* Previously cached; to find a lookup value, search a chain of values
703        and compare keys. Typically, there is only one such, but it is possible
704        for different keys to have matched the same named list. */
705
706       else
707         {
708         DEBUG(D_lists) debug_printf("cached %s match for %s\n",
709           ((bits & (-bits)) == bits)? "yes" : "no", ss);
710
711         cached = US" - cached";
712         if (valueptr)
713           {
714           const uschar *key = get_check_key(arg, type);
715
716           for (namedlist_cacheblock * p = nb->cache_data; p; p = p->next)
717             if (Ustrcmp(key, p->key) == 0)
718               {
719               *valueptr = p->data;
720               break;
721               }
722           DEBUG(D_lists) debug_printf("cached lookup data = %s\n", *valueptr);
723           }
724         }
725
726       /* Result of test is indicated by value in bits. For each test, we
727       have 00 => untested, 01 => tested yes, 11 => tested no. */
728
729       if ((bits & (-bits)) == bits)    /* Only one of the two bits is set */
730         {
731         HDEBUG(D_lists) debug_printf("%s %s (matched \"%s\"%s)\n", ot,
732           (yield == OK)? "yes" : "no", sss, cached);
733         return yield;
734         }
735       }
736
737     /* Run the provided function to do the individual test. */
738
739     else
740       {
741       uschar * error = NULL;
742       switch ((func)(arg, ss, valueptr, &error))
743         {
744         case OK:
745           HDEBUG(D_lists) debug_printf("%s %s (matched \"%s\")\n", ot,
746             (yield == OK)? "yes" : "no", sss);
747           return yield;
748
749         case DEFER:
750           if (!error)
751             error = string_sprintf("DNS lookup of \"%s\" deferred", ss);
752           if (ignore_defer)
753             {
754             HDEBUG(D_lists) debug_printf("%s: item ignored by +ignore_defer\n",
755               error);
756             break;
757             }
758           if (include_defer)
759             {
760             log_write(0, LOG_MAIN, "%s: accepted by +include_defer", error);
761             return OK;
762             }
763           if (!search_error_message) search_error_message = error;
764           goto DEFER_RETURN;
765
766         /* The ERROR return occurs when checking hosts, when either a forward
767         or reverse lookup has failed. It can also occur in a match_ip list if a
768         non-IP address item is encountered. The error string gives details of
769         which it was. */
770
771         case ERROR:
772           if (ignore_unknown)
773             {
774             HDEBUG(D_lists) debug_printf("%s: item ignored by +ignore_unknown\n",
775               error);
776             }
777           else
778             {
779             HDEBUG(D_lists) debug_printf("%s %s (%s)\n", ot,
780               include_unknown? "yes":"no", error);
781             if (!include_unknown)
782               {
783               if (LOGGING(unknown_in_list))
784                 log_write(0, LOG_MAIN, "list matching forced to fail: %s", error);
785               return FAIL;
786               }
787             log_write(0, LOG_MAIN, "%s: accepted by +include_unknown", error);
788             return OK;
789             }
790         }
791       }
792     }
793
794   /* If the item is a file name, we read the file and do a match attempt
795   on each line in the file, including possibly more negation processing. */
796
797   else
798     {
799     int file_yield = yield;       /* In case empty file */
800     uschar * filename = ss;
801     FILE * f = Ufopen(filename, "rb");
802     uschar filebuffer[1024];
803
804     /* ot will be null in non-debugging cases, and anyway, we get better
805     wording by reworking it. */
806
807     if (!f)
808       {
809       uschar * listname = readconf_find_option(listptr);
810       if (listname[0] == 0)
811         listname = string_sprintf("\"%s\"", *listptr);
812       log_write(0, LOG_MAIN|LOG_PANIC_DIE, "%s",
813         string_open_failed(errno, "%s when checking %s", sss, listname));
814       }
815
816     /* Trailing comments are introduced by #, but in an address list or local
817     part list, the # must be preceded by white space or the start of the line,
818     because the # character is a legal character in local parts. */
819
820     while (Ufgets(filebuffer, sizeof(filebuffer), f) != NULL)
821       {
822       uschar *error;
823       uschar *sss = filebuffer;
824
825       while ((ss = Ustrchr(sss, '#')) != NULL)
826         {
827         if ((type != MCL_ADDRESS && type != MCL_LOCALPART) ||
828               ss == filebuffer || isspace(ss[-1]))
829           {
830           *ss = 0;
831           break;
832           }
833         sss = ss + 1;
834         }
835
836       ss = filebuffer + Ustrlen(filebuffer);             /* trailing space */
837       while (ss > filebuffer && isspace(ss[-1])) ss--;
838       *ss = 0;
839
840       ss = filebuffer;
841       while (isspace(*ss)) ss++;                         /* leading space */
842
843       if (*ss == 0) continue;                            /* ignore empty */
844
845       file_yield = yield;                                /* positive yield */
846       sss = ss;                                          /* for debugging */
847
848       if (*ss == '!')                                    /* negation */
849         {
850         file_yield = (file_yield == OK)? FAIL : OK;
851         while (isspace((*(++ss))));
852         }
853
854       switch ((func)(arg, ss, valueptr, &error))
855         {
856         case OK:
857           (void)fclose(f);
858           HDEBUG(D_lists) debug_printf("%s %s (matched \"%s\" in %s)\n", ot,
859             yield == OK ? "yes" : "no", sss, filename);
860           return file_yield;
861
862         case DEFER:
863           if (!error)
864             error = string_sprintf("DNS lookup of %s deferred", ss);
865           if (ignore_defer)
866             {
867             HDEBUG(D_lists) debug_printf("%s: item ignored by +ignore_defer\n",
868               error);
869             break;
870             }
871           (void)fclose(f);
872           if (include_defer)
873             {
874             log_write(0, LOG_MAIN, "%s: accepted by +include_defer", error);
875             return OK;
876             }
877           goto DEFER_RETURN;
878
879         case ERROR:             /* host name lookup failed - this can only */
880           if (ignore_unknown)   /* be for an incoming host (not outgoing) */
881             {
882             HDEBUG(D_lists) debug_printf("%s: item ignored by +ignore_unknown\n",
883               error);
884             }
885           else
886            {
887             HDEBUG(D_lists) debug_printf("%s %s (%s)\n", ot,
888               include_unknown? "yes":"no", error);
889             (void)fclose(f);
890             if (!include_unknown)
891               {
892               if (LOGGING(unknown_in_list))
893                 log_write(0, LOG_MAIN, "list matching forced to fail: %s", error);
894               return FAIL;
895               }
896             log_write(0, LOG_MAIN, "%s: accepted by +include_unknown", error);
897             return OK;
898             }
899         }
900       }
901
902     /* At the end of the file, leave the yield setting at the final setting
903     for the file, in case this is the last item in the list. */
904
905     yield = file_yield;
906     (void)fclose(f);
907     }
908   }    /* Loop for the next item on the top-level list */
909
910 /* End of list reached: if the last item was negated yield OK, else FAIL. */
911
912 HDEBUG(D_lists)
913   debug_printf("%s %s (end of list)\n", ot, yield == OK ? "no":"yes");
914 return yield == OK ? FAIL : OK;
915
916 /* Something deferred */
917
918 DEFER_RETURN:
919 HDEBUG(D_lists) debug_printf("%s list match deferred for %s\n", ot, sss);
920 return DEFER;
921 }
922
923
924 /*************************************************
925 *          Match in colon-separated list         *
926 *************************************************/
927
928 /* This function is used for domain lists and local part lists. It is not used
929 for host lists or address lists, which have additional interpretation of the
930 patterns. Some calls of it set sep > UCHAR_MAX in order to use its matching
931 facilities on single items. When this is done, it arranges to set the numerical
932 variables as a result of the match.
933
934 This function is now just a short interface to match_check_list(), which does
935 list scanning in a general way. A good compiler will optimize the tail
936 recursion.
937
938 Arguments:
939   s              string to search for
940   listptr        ptr to ptr to colon separated list of patterns, or NULL
941   sep            a separator value for the list (see string_nextinlist())
942   anchorptr      ptr to tree for named items, or NULL if no named items
943   cache_bits     ptr to cache_bits for ditto, or NULL if not caching
944   type           MCL_DOMAIN when matching a domain list
945                  MCL_LOCALPART when matching a local part list (address lists
946                    have their own function)
947                  MCL_STRING for others (e.g. list of ciphers)
948                  MCL_NOEXPAND (whose value is greater than any of them) may
949                    be added to any value to suppress expansion of the list
950   caseless       TRUE for (mostly) caseless matching - passed directly to
951                    match_check_string()
952   valueptr       pointer to where any lookup data is to be passed back,
953                  or NULL (just passed on to match_check_string)
954
955 Returns:         OK    if matched a non-negated item
956                  OK    if hit end of list after a negated item
957                  FAIL  if expansion force-failed
958                  FAIL  if matched a negated item
959                  FAIL  if hit end of list after a non-negated item
960                  DEFER if a lookup deferred
961 */
962
963 int
964 match_isinlist(const uschar *s, const uschar **listptr, int sep,
965    tree_node **anchorptr,
966   unsigned int *cache_bits, int type, BOOL caseless, const uschar **valueptr)
967 {
968 unsigned int *local_cache_bits = cache_bits;
969 check_string_block cb;
970 cb.origsubject = s;
971 cb.subject = caseless? string_copylc(s) : string_copy(s);
972 cb.expand_setup = (sep > UCHAR_MAX)? 0 : -1;
973 cb.use_partial = TRUE;
974 cb.caseless = caseless;
975 cb.at_is_special = (type == MCL_DOMAIN || type == MCL_DOMAIN + MCL_NOEXPAND);
976 if (valueptr != NULL) *valueptr = NULL;
977 return  match_check_list(listptr, sep, anchorptr, &local_cache_bits,
978   check_string, &cb, type, s, valueptr);
979 }
980
981
982
983 /*************************************************
984 *    Match address to single address-list item   *
985 *************************************************/
986
987 /* This function matches an address to an item from an address list. It is
988 called from match_address_list() via match_check_list(). That is why most of
989 its arguments are in an indirect block.
990
991 Arguments:
992   arg            the argument block (see below)
993   pattern        the pattern to match
994   valueptr       where to return a value
995   error          for error messages (not used in this function; it never
996                    returns ERROR)
997
998 The argument block contains:
999   address        the start of the subject address; when called from retry.c
1000                    it may be *@domain if the local part isn't relevant
1001   origaddress    the original, un-case-forced address (not used here, but used
1002                    in match_check_list() when +caseful is encountered)
1003   expand_setup   controls setting up of $n variables
1004   caseless       TRUE for caseless local part matching
1005
1006 Returns:         OK     for a match
1007                  FAIL   for no match
1008                  DEFER  if a lookup deferred
1009 */
1010
1011 static int
1012 check_address(void *arg, const uschar *pattern, const uschar **valueptr, uschar **error)
1013 {
1014 check_address_block *cb = (check_address_block *)arg;
1015 check_string_block csb;
1016 int rc;
1017 int expand_inc = 0;
1018 unsigned int *null = NULL;
1019 const uschar *listptr;
1020 uschar *subject = cb->address;
1021 const uschar *s;
1022 uschar *pdomain, *sdomain;
1023
1024 error = error;  /* Keep clever compilers from complaining */
1025
1026 DEBUG(D_lists) debug_printf("address match test: subject=%s pattern=%s\n",
1027   subject, pattern);
1028
1029 /* Find the subject's domain */
1030
1031 sdomain = Ustrrchr(subject, '@');
1032
1033 /* The only case where a subject may not have a domain is if the subject is
1034 empty. Otherwise, a subject with no domain is a serious configuration error. */
1035
1036 if (sdomain == NULL && *subject != 0)
1037   {
1038   log_write(0, LOG_MAIN|LOG_PANIC, "no @ found in the subject of an "
1039     "address list match: subject=\"%s\" pattern=\"%s\"", subject, pattern);
1040   return FAIL;
1041   }
1042
1043 /* Handle a regular expression, which must match the entire incoming address.
1044 This may be the empty address. */
1045
1046 if (*pattern == '^')
1047   return match_check_string(subject, pattern, cb->expand_setup, TRUE,
1048     cb->caseless, FALSE, NULL);
1049
1050 /* Handle a pattern that is just a lookup. Skip over possible lookup names
1051 (letters, digits, hyphens). Skip over a possible * or *@ at the end. Then we
1052 must have a semicolon for it to be a lookup. */
1053
1054 for (s = pattern; isalnum(*s) || *s == '-'; s++);
1055 if (*s == '*') s++;
1056 if (*s == '@') s++;
1057
1058 /* If it is a straight lookup, do a lookup for the whole address. This may be
1059 the empty address. Partial matching doesn't make sense here, so we ignore it,
1060 but write a panic log entry. However, *@ matching will be honoured. */
1061
1062 if (*s == ';')
1063   {
1064   if (Ustrncmp(pattern, "partial-", 8) == 0)
1065     log_write(0, LOG_MAIN|LOG_PANIC, "partial matching is not applicable to "
1066       "whole-address lookups: ignored \"partial-\" in \"%s\"", pattern);
1067   return match_check_string(subject, pattern, -1, FALSE, cb->caseless, FALSE,
1068     valueptr);
1069   }
1070
1071 /* For the remaining cases, an empty subject matches only an empty pattern,
1072 because other patterns expect to have a local part and a domain to match
1073 against. */
1074
1075 if (*subject == 0) return (*pattern == 0)? OK : FAIL;
1076
1077 /* If the pattern starts with "@@" we have a split lookup, where the domain is
1078 looked up to obtain a list of local parts. If the subject's local part is just
1079 "*" (called from retry) the match always fails. */
1080
1081 if (pattern[0] == '@' && pattern[1] == '@')
1082   {
1083   int watchdog = 50;
1084   uschar *list, *ss;
1085   uschar buffer[1024];
1086
1087   if (sdomain == subject + 1 && *subject == '*') return FAIL;
1088
1089   /* Loop for handling chains. The last item in any list may be of the form
1090   ">name" in order to chain on to another list. */
1091
1092   for (const uschar * key = sdomain + 1; key && watchdog-- > 0; )
1093     {
1094     int sep = 0;
1095
1096     if ((rc = match_check_string(key, pattern + 2, -1, TRUE, FALSE, FALSE,
1097       CUSS &list)) != OK) return rc;
1098
1099     /* Check for chaining from the last item; set up the next key if one
1100     is found. */
1101
1102     ss = Ustrrchr(list, ':');
1103     if (ss == NULL) ss = list; else ss++;
1104     while (isspace(*ss)) ss++;
1105     if (*ss == '>')
1106       {
1107       *ss++ = 0;
1108       while (isspace(*ss)) ss++;
1109       key = string_copy(ss);
1110       }
1111     else key = NULL;
1112
1113     /* Look up the local parts provided by the list; negation is permitted.
1114     If a local part has to begin with !, a regex can be used. */
1115
1116     while ((ss = string_nextinlist(CUSS &list, &sep, buffer, sizeof(buffer))))
1117       {
1118       int local_yield;
1119
1120       if (*ss == '!')
1121         {
1122         local_yield = FAIL;
1123         while (isspace((*(++ss))));
1124         }
1125       else local_yield = OK;
1126
1127       *sdomain = 0;
1128       rc = match_check_string(subject, ss, -1, TRUE, cb->caseless, FALSE,
1129         valueptr);
1130       *sdomain = '@';
1131
1132       switch(rc)
1133         {
1134         case OK:
1135         return local_yield;
1136
1137         case DEFER:
1138         return DEFER;
1139         }
1140       }
1141     }
1142
1143   /* End of chain loop; panic if too many times */
1144
1145   if (watchdog <= 0)
1146     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "Loop detected in lookup of "
1147       "local part of %s in %s", subject, pattern);
1148
1149   /* Otherwise the local part check has failed, so the whole match
1150   fails. */
1151
1152   return FAIL;
1153   }
1154
1155
1156 /* We get here if the pattern is not a lookup or a regular expression. If it
1157 contains an @ there is both a local part and a domain. */
1158
1159 pdomain = Ustrrchr(pattern, '@');
1160 if (pdomain != NULL)
1161   {
1162   int pllen, sllen;
1163
1164   /* If the domain in the pattern is empty or one of the special cases [] or
1165   mx_{any,primary,secondary}, and the local part in the pattern ends in "@",
1166   we have a pattern of the form <something>@@, <something>@@[], or
1167   <something>@@mx_{any,primary,secondary}. These magic "domains" are
1168   automatically interpreted in match_check_string. We just need to arrange that
1169   the leading @ is included in the domain. */
1170
1171   if (pdomain > pattern && pdomain[-1] == '@' &&
1172        (pdomain[1] == 0 ||
1173         Ustrcmp(pdomain+1, "[]") == 0 ||
1174         Ustrcmp(pdomain+1, "mx_any") == 0 ||
1175         Ustrcmp(pdomain+1, "mx_primary") == 0 ||
1176         Ustrcmp(pdomain+1, "mx_secondary") == 0))
1177     pdomain--;
1178
1179   pllen = pdomain - pattern;
1180   sllen = sdomain - subject;
1181
1182   /* Compare the local parts in the subject and the pattern */
1183
1184   if (*pattern == '*')
1185     {
1186     int cllen = pllen - 1;
1187     if (sllen < cllen) return FAIL;
1188     if (cb->caseless
1189         ? strncmpic(subject+sllen-cllen, pattern + 1, cllen) != 0
1190         : Ustrncmp(subject+sllen-cllen, pattern + 1, cllen) != 0)
1191         return FAIL;
1192     if (cb->expand_setup > 0)
1193       {
1194       expand_nstring[cb->expand_setup] = subject;
1195       expand_nlength[cb->expand_setup] = sllen - cllen;
1196       expand_inc = 1;
1197       }
1198     }
1199   else
1200     {
1201     if (sllen != pllen) return FAIL;
1202     if (cb->caseless
1203         ? strncmpic(subject, pattern, sllen) != 0
1204         : Ustrncmp(subject, pattern, sllen) != 0) return FAIL;
1205     }
1206   }
1207
1208 /* If the local part matched, or was not being checked, check the domain using
1209 the generalized function, which supports file lookups (which may defer). The
1210 original code read as follows:
1211
1212   return match_check_string(sdomain + 1,
1213       pdomain ? pdomain + 1 : pattern,
1214       cb->expand_setup + expand_inc, TRUE, cb->caseless, TRUE, NULL);
1215
1216 This supported only literal domains and *.x.y patterns. In order to allow for
1217 named domain lists (so that you can right, for example, "senders=+xxxx"), it
1218 was changed to use the list scanning function. */
1219
1220 csb.origsubject = sdomain + 1;
1221 csb.subject = cb->caseless ? string_copylc(sdomain+1) : string_copy(sdomain+1);
1222 csb.expand_setup = cb->expand_setup + expand_inc;
1223 csb.use_partial = TRUE;
1224 csb.caseless = cb->caseless;
1225 csb.at_is_special = TRUE;
1226
1227 listptr = pdomain ? pdomain + 1 : pattern;
1228 if (valueptr) *valueptr = NULL;
1229
1230 return match_check_list(
1231   &listptr,                  /* list of one item */
1232   UCHAR_MAX+1,               /* impossible separator; single item */
1233   &domainlist_anchor,        /* it's a domain list */
1234   &null,                     /* ptr to NULL means no caching */
1235   check_string,              /* the function to do one test */
1236   &csb,                      /* its data */
1237   MCL_DOMAIN + MCL_NOEXPAND, /* domain list; don't expand */
1238   csb.subject,               /* string for messages */
1239   valueptr);                 /* where to pass back lookup data */
1240 }
1241
1242
1243
1244
1245 /*************************************************
1246 *    Test whether address matches address list   *
1247 *************************************************/
1248
1249 /* This function is given an address and a list of things to match it against.
1250 The list may contain individual addresses, regular expressions, lookup
1251 specifications, and indirection via bare files. Negation is supported. The
1252 address to check can consist of just a domain, which will then match only
1253 domain items or items specified as *@domain.
1254
1255 Domains are always lower cased before the match. Local parts are also lower
1256 cased unless "caseless" is false. The work of actually scanning the list is
1257 done by match_check_list(), with an appropriate block of arguments and a
1258 callback to check_address(). During caseless matching, it will recognize
1259 +caseful and revert to caseful matching.
1260
1261 Arguments:
1262   address         address to test
1263   caseless        TRUE to start in caseless state
1264   expand          TRUE to allow list expansion
1265   listptr         list to check against
1266   cache_bits      points to cache bits for named address lists, or NULL
1267   expand_setup    controls setting up of $n variables - passed through
1268                   to check_address (q.v.)
1269   sep             separator character for the list;
1270                   may be 0 to get separator from the list;
1271                   may be UCHAR_MAX+1 for one-item list
1272   valueptr        where to return a lookup value, or NULL
1273
1274 Returns:          OK    for a positive match, or end list after a negation;
1275                   FAIL  for a negative match, or end list after non-negation;
1276                   DEFER if a lookup deferred
1277 */
1278
1279 int
1280 match_address_list(const uschar *address, BOOL caseless, BOOL expand,
1281   const uschar **listptr, unsigned int *cache_bits, int expand_setup, int sep,
1282   const uschar **valueptr)
1283 {
1284 check_address_block ab;
1285 unsigned int *local_cache_bits = cache_bits;
1286 int len;
1287
1288 /* RFC 2505 recommends that for spam checking, local parts should be caselessly
1289 compared. Therefore, Exim now forces the entire address into lower case here,
1290 provided that "caseless" is set. (It is FALSE for calls for matching rewriting
1291 patterns.) Otherwise just the domain is lower cases. A magic item "+caseful" in
1292 the list can be used to restore a caseful copy of the local part from the
1293 original address. */
1294
1295 if ((len = Ustrlen(address)) > 255) len = 255;
1296 ab.address = string_copyn(address, len);
1297
1298 for (uschar * p = ab.address + len - 1; p >= ab.address; p--)
1299   {
1300   if (!caseless && *p == '@') break;
1301   *p = tolower(*p);
1302   }
1303
1304 /* If expand_setup is zero, we need to set up $0 to the whole thing, in
1305 case there is a match. Can't use the built-in facilities of match_check_string
1306 (via check_address), as we may just be calling that for part of the address
1307 (the domain). */
1308
1309 if (expand_setup == 0)
1310   {
1311   expand_nstring[0] = string_copy(address);
1312   expand_nlength[0] = Ustrlen(address);
1313   expand_setup++;
1314   }
1315
1316 /* Set up the data to be passed ultimately to check_address. */
1317
1318 ab.origaddress = address;
1319 /* ab.address is above */
1320 ab.expand_setup = expand_setup;
1321 ab.caseless = caseless;
1322
1323 return match_check_list(listptr, sep, &addresslist_anchor, &local_cache_bits,
1324   check_address, &ab, MCL_ADDRESS + (expand? 0:MCL_NOEXPAND), address,
1325     valueptr);
1326 }
1327
1328 /* Simpler version of match_address_list; always caseless, expanding,
1329 no cache bits, no value-return.
1330
1331 Arguments:
1332   address         address to test
1333   listptr         list to check against
1334   sep             separator character for the list;
1335                   may be 0 to get separator from the list;
1336                   may be UCHAR_MAX+1 for one-item list
1337
1338 Returns:          OK    for a positive match, or end list after a negation;
1339                   FAIL  for a negative match, or end list after non-negation;
1340                   DEFER if a lookup deferred
1341 */
1342
1343 int
1344 match_address_list_basic(const uschar *address, const uschar **listptr, int sep)
1345 {
1346 return match_address_list(address, TRUE, TRUE, listptr, NULL, -1, sep, NULL);
1347 }
1348
1349 /* End of match.c */