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