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