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