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