a0899bf3eef8f9e0e6ae751955821838556e36ac
[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 /* 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 uschar buffer[1024];
450
451 /* Save time by not scanning for the option name when we don't need it. */
452
453 HDEBUG(D_any)
454   {
455   uschar *listname = readconf_find_option(listptr);
456   if (listname[0] != 0) ot = string_sprintf("%s in %s?", name, listname);
457   }
458
459 /* If the list is empty, the answer is no. Skip the debugging output for
460 an unnamed list. */
461
462 if (!*listptr)
463   {
464   HDEBUG(D_lists) if (ot) debug_printf("%s no (option unset)\n", ot);
465   return FAIL;
466   }
467
468 /* Expand the list before we scan it. A forced expansion gives the answer
469 "not in list"; other expansion errors cause DEFER to be returned. However,
470 if the type value is greater than or equal to than MCL_NOEXPAND, do not expand
471 the list. */
472
473 if (type >= MCL_NOEXPAND)
474   {
475   list = *listptr;
476   type -= MCL_NOEXPAND;       /* Remove the "no expand" flag */
477   }
478 else
479   {
480   /* If we are searching a domain list, and $domain is not set, set it to the
481   subject that is being sought for the duration of the expansion. */
482
483   if (type == MCL_DOMAIN && !deliver_domain)
484     {
485     check_string_block *cb = (check_string_block *)arg;
486     deliver_domain = string_copy(cb->subject);
487     list = expand_cstring(*listptr);
488     deliver_domain = NULL;
489     }
490   else
491     list = expand_cstring(*listptr);
492
493   if (!list)
494     {
495     if (f.expand_string_forcedfail)
496       {
497       HDEBUG(D_lists) debug_printf("expansion of \"%s\" forced failure: "
498         "assume not in this list\n", *listptr);
499       return FAIL;
500       }
501     log_write(0, LOG_MAIN|LOG_PANIC, "failed to expand \"%s\" while checking "
502       "a list: %s", *listptr, expand_string_message);
503     return DEFER;
504     }
505   }
506
507 /* For an unnamed list, use the expanded version in comments */
508
509 HDEBUG(D_any) if (ot == NULL) ot = string_sprintf("%s in \"%s\"?", name, list);
510
511 /* Now scan the list and process each item in turn, until one of them matches,
512 or we hit an error. */
513
514 while ((sss = string_nextinlist(&list, &sep, buffer, sizeof(buffer))))
515   {
516   uschar * ss = sss;
517
518   /* Address lists may contain +caseful, to restore caseful matching of the
519   local part. We have to know the layout of the control block, unfortunately.
520   The lower cased address is in a temporary buffer, so we just copy the local
521   part back to the start of it (if a local part exists). */
522
523   if (type == MCL_ADDRESS)
524     {
525     if (Ustrcmp(ss, "+caseful") == 0)
526       {
527       check_address_block *cb = (check_address_block *)arg;
528       uschar *at = Ustrrchr(cb->origaddress, '@');
529
530       if (at)
531         Ustrncpy(cb->address, cb->origaddress, at - cb->origaddress);
532       cb->caseless = FALSE;
533       continue;
534       }
535     }
536
537   /* Similar processing for local parts */
538
539   else if (type == MCL_LOCALPART)
540     {
541     if (Ustrcmp(ss, "+caseful") == 0)
542       {
543       check_string_block *cb = (check_string_block *)arg;
544       Ustrcpy(US cb->subject, cb->origsubject);
545       cb->caseless = FALSE;
546       continue;
547       }
548     }
549
550   /* If the host item is "+include_unknown" or "+ignore_unknown", remember it
551   in case there's a subsequent failed reverse lookup. There is similar
552   processing for "defer". */
553
554   else if (type == MCL_HOST && *ss == '+')
555     {
556     if (Ustrcmp(ss, "+include_unknown") == 0)
557       {
558       include_unknown = TRUE;
559       ignore_unknown = FALSE;
560       continue;
561       }
562     if (Ustrcmp(ss, "+ignore_unknown") == 0)
563       {
564       ignore_unknown = TRUE;
565       include_unknown = FALSE;
566       continue;
567       }
568     if (Ustrcmp(ss, "+include_defer") == 0)
569       {
570       include_defer = TRUE;
571       ignore_defer = FALSE;
572       continue;
573       }
574     if (Ustrcmp(ss, "+ignore_defer") == 0)
575       {
576       ignore_defer = TRUE;
577       include_defer = FALSE;
578       continue;
579       }
580     }
581
582   /* Starting with ! specifies a negative item. It is theoretically possible
583   for a local part to start with !. In that case, a regex has to be used. */
584
585   if (*ss == '!')
586     {
587     yield = FAIL;
588     while (isspace((*(++ss))));
589     }
590   else
591     yield = OK;
592
593   /* If the item does not begin with '/', it might be a + item for a named
594   list. Otherwise, it is just a single list entry that has to be matched.
595   We recognize '+' only when supplied with a tree of named lists. */
596
597   if (*ss != '/')
598     {
599     if (*ss == '+' && anchorptr)
600       {
601       int bits = 0;
602       int offset = 0;
603       int shift = 0;
604       unsigned int *use_cache_bits = original_cache_bits;
605       uschar *cached = US"";
606       namedlist_block *nb;
607       tree_node * t;
608
609       if (!(t = tree_search(*anchorptr, ss+1)))
610         {
611         log_write(0, LOG_MAIN|LOG_PANIC, "unknown named%s list \"%s\"",
612           type == MCL_DOMAIN ?    " domain" :
613           type == MCL_HOST ?      " host" :
614           type == MCL_ADDRESS ?   " address" :
615           type == MCL_LOCALPART ? " local part" : "",
616           ss);
617         return DEFER;
618         }
619       nb = t->data.ptr;
620
621       /* If the list number is negative, it means that this list is not
622       cacheable because it contains expansion items. */
623
624       if (nb->number < 0) use_cache_bits = NULL;
625
626       /* If we have got a cache pointer, get the bits. This is not an "else"
627       because the pointer may be NULL from the start if caching is not
628       required. */
629
630       if (use_cache_bits)
631         {
632         offset = (nb->number)/16;
633         shift = ((nb->number)%16)*2;
634         bits = use_cache_bits[offset] & (3 << shift);
635         }
636
637       /* Not previously tested or no cache - run the full test */
638
639       if (bits == 0)
640         {
641         switch (match_check_list(&(nb->string), 0, anchorptr, &use_cache_bits,
642                 func, arg, type, name, valueptr))
643           {
644           case OK:   bits = 1; break;
645           case FAIL: bits = 3; break;
646           case DEFER: goto DEFER_RETURN;
647           }
648
649         /* If this list was uncacheable, or a sublist turned out to be
650         uncacheable, the value of use_cache_bits will now be NULL, even if it
651         wasn't before. Ensure that this is passed up to the next level.
652         Otherwise, remember the result of the search in the cache. */
653
654         if (!use_cache_bits)
655           *cache_ptr = NULL;
656         else
657           {
658           use_cache_bits[offset] |= bits << shift;
659
660           if (valueptr)
661             {
662             int old_pool = store_pool;
663             namedlist_cacheblock *p;
664
665             /* Cached data for hosts persists over more than one message,
666             so we use the permanent store pool */
667
668             store_pool = POOL_PERM;
669             p = store_get(sizeof(namedlist_cacheblock), FALSE);
670             p->key = string_copy(get_check_key(arg, type));
671
672
673             p->data = *valueptr ? string_copy(*valueptr) : NULL;
674             store_pool = old_pool;
675
676             p->next = nb->cache_data;
677             nb->cache_data = p;
678             if (*valueptr)
679               DEBUG(D_lists) debug_printf("data from lookup saved for "
680                 "cache for %s: %s\n", ss, *valueptr);
681             }
682           }
683         }
684
685        /* Previously cached; to find a lookup value, search a chain of values
686        and compare keys. Typically, there is only one such, but it is possible
687        for different keys to have matched the same named list. */
688
689       else
690         {
691         DEBUG(D_lists) debug_printf("cached %s match for %s\n",
692           ((bits & (-bits)) == bits)? "yes" : "no", ss);
693
694         cached = US" - cached";
695         if (valueptr)
696           {
697           const uschar *key = get_check_key(arg, type);
698
699           for (namedlist_cacheblock * p = nb->cache_data; p; p = p->next)
700             if (Ustrcmp(key, p->key) == 0)
701               {
702               *valueptr = p->data;
703               break;
704               }
705           DEBUG(D_lists) debug_printf("cached lookup data = %s\n", *valueptr);
706           }
707         }
708
709       /* Result of test is indicated by value in bits. For each test, we
710       have 00 => untested, 01 => tested yes, 11 => tested no. */
711
712       if ((bits & (-bits)) == bits)    /* Only one of the two bits is set */
713         {
714         HDEBUG(D_lists) debug_printf("%s %s (matched \"%s\"%s)\n", ot,
715           (yield == OK)? "yes" : "no", sss, cached);
716         return yield;
717         }
718       }
719
720     /* Run the provided function to do the individual test. */
721
722     else
723       {
724       uschar * error = NULL;
725       switch ((func)(arg, ss, valueptr, &error))
726         {
727         case OK:
728           HDEBUG(D_lists) debug_printf("%s %s (matched \"%s\")\n", ot,
729             (yield == OK)? "yes" : "no", sss);
730           return yield;
731
732         case DEFER:
733           if (!error)
734             error = string_sprintf("DNS lookup of \"%s\" deferred", ss);
735           if (ignore_defer)
736             {
737             HDEBUG(D_lists) debug_printf("%s: item ignored by +ignore_defer\n",
738               error);
739             break;
740             }
741           if (include_defer)
742             {
743             log_write(0, LOG_MAIN, "%s: accepted by +include_defer", error);
744             return OK;
745             }
746           if (!search_error_message) search_error_message = error;
747           goto DEFER_RETURN;
748
749         /* The ERROR return occurs when checking hosts, when either a forward
750         or reverse lookup has failed. It can also occur in a match_ip list if a
751         non-IP address item is encountered. The error string gives details of
752         which it was. */
753
754         case ERROR:
755           if (ignore_unknown)
756             {
757             HDEBUG(D_lists) debug_printf("%s: item ignored by +ignore_unknown\n",
758               error);
759             }
760           else
761             {
762             HDEBUG(D_lists) debug_printf("%s %s (%s)\n", ot,
763               include_unknown? "yes":"no", error);
764             if (!include_unknown)
765               {
766               if (LOGGING(unknown_in_list))
767                 log_write(0, LOG_MAIN, "list matching forced to fail: %s", error);
768               return FAIL;
769               }
770             log_write(0, LOG_MAIN, "%s: accepted by +include_unknown", error);
771             return OK;
772             }
773         }
774       }
775     }
776
777   /* If the item is a file name, we read the file and do a match attempt
778   on each line in the file, including possibly more negation processing. */
779
780   else
781     {
782     int file_yield = yield;       /* In case empty file */
783     uschar * filename = ss;
784     FILE * f = Ufopen(filename, "rb");
785     uschar filebuffer[1024];
786
787     /* ot will be null in non-debugging cases, and anyway, we get better
788     wording by reworking it. */
789
790     if (!f)
791       {
792       uschar * listname = readconf_find_option(listptr);
793       if (listname[0] == 0)
794         listname = string_sprintf("\"%s\"", *listptr);
795       log_write(0, LOG_MAIN|LOG_PANIC_DIE, "%s",
796         string_open_failed(errno, "%s when checking %s", sss, listname));
797       }
798
799     /* Trailing comments are introduced by #, but in an address list or local
800     part list, the # must be preceded by white space or the start of the line,
801     because the # character is a legal character in local parts. */
802
803     while (Ufgets(filebuffer, sizeof(filebuffer), f) != NULL)
804       {
805       uschar *error;
806       uschar *sss = filebuffer;
807
808       while ((ss = Ustrchr(sss, '#')) != NULL)
809         {
810         if ((type != MCL_ADDRESS && type != MCL_LOCALPART) ||
811               ss == filebuffer || isspace(ss[-1]))
812           {
813           *ss = 0;
814           break;
815           }
816         sss = ss + 1;
817         }
818
819       ss = filebuffer + Ustrlen(filebuffer);             /* trailing space */
820       while (ss > filebuffer && isspace(ss[-1])) ss--;
821       *ss = 0;
822
823       ss = filebuffer;
824       while (isspace(*ss)) ss++;                         /* leading space */
825
826       if (*ss == 0) continue;                            /* ignore empty */
827
828       file_yield = yield;                                /* positive yield */
829       sss = ss;                                          /* for debugging */
830
831       if (*ss == '!')                                    /* negation */
832         {
833         file_yield = (file_yield == OK)? FAIL : OK;
834         while (isspace((*(++ss))));
835         }
836
837       switch ((func)(arg, ss, valueptr, &error))
838         {
839         case OK:
840           (void)fclose(f);
841           HDEBUG(D_lists) debug_printf("%s %s (matched \"%s\" in %s)\n", ot,
842             yield == OK ? "yes" : "no", sss, filename);
843           return file_yield;
844
845         case DEFER:
846           if (!error)
847             error = string_sprintf("DNS lookup of %s deferred", ss);
848           if (ignore_defer)
849             {
850             HDEBUG(D_lists) debug_printf("%s: item ignored by +ignore_defer\n",
851               error);
852             break;
853             }
854           (void)fclose(f);
855           if (include_defer)
856             {
857             log_write(0, LOG_MAIN, "%s: accepted by +include_defer", error);
858             return OK;
859             }
860           goto DEFER_RETURN;
861
862         case ERROR:             /* host name lookup failed - this can only */
863           if (ignore_unknown)   /* be for an incoming host (not outgoing) */
864             {
865             HDEBUG(D_lists) debug_printf("%s: item ignored by +ignore_unknown\n",
866               error);
867             }
868           else
869            {
870             HDEBUG(D_lists) debug_printf("%s %s (%s)\n", ot,
871               include_unknown? "yes":"no", error);
872             (void)fclose(f);
873             if (!include_unknown)
874               {
875               if (LOGGING(unknown_in_list))
876                 log_write(0, LOG_MAIN, "list matching forced to fail: %s", error);
877               return FAIL;
878               }
879             log_write(0, LOG_MAIN, "%s: accepted by +include_unknown", error);
880             return OK;
881             }
882         }
883       }
884
885     /* At the end of the file, leave the yield setting at the final setting
886     for the file, in case this is the last item in the list. */
887
888     yield = file_yield;
889     (void)fclose(f);
890     }
891   }    /* Loop for the next item on the top-level list */
892
893 /* End of list reached: if the last item was negated yield OK, else FAIL. */
894
895 HDEBUG(D_lists)
896   debug_printf("%s %s (end of list)\n", ot, yield == OK ? "no":"yes");
897 return yield == OK ? FAIL : OK;
898
899 /* Something deferred */
900
901 DEFER_RETURN:
902 HDEBUG(D_lists) debug_printf("%s list match deferred for %s\n", ot, sss);
903 return DEFER;
904 }
905
906
907 /*************************************************
908 *          Match in colon-separated list         *
909 *************************************************/
910
911 /* This function is used for domain lists and local part lists. It is not used
912 for host lists or address lists, which have additional interpretation of the
913 patterns. Some calls of it set sep > UCHAR_MAX in order to use its matching
914 facilities on single items. When this is done, it arranges to set the numerical
915 variables as a result of the match.
916
917 This function is now just a short interface to match_check_list(), which does
918 list scanning in a general way. A good compiler will optimize the tail
919 recursion.
920
921 Arguments:
922   s              string to search for
923   listptr        ptr to ptr to colon separated list of patterns, or NULL
924   sep            a separator value for the list (see string_nextinlist())
925   anchorptr      ptr to tree for named items, or NULL if no named items
926   cache_bits     ptr to cache_bits for ditto, or NULL if not caching
927   type           MCL_DOMAIN when matching a domain list
928                  MCL_LOCALPART when matching a local part list (address lists
929                    have their own function)
930                  MCL_STRING for others (e.g. list of ciphers)
931                  MCL_NOEXPAND (whose value is greater than any of them) may
932                    be added to any value to suppress expansion of the list
933   caseless       TRUE for (mostly) caseless matching - passed directly to
934                    match_check_string()
935   valueptr       pointer to where any lookup data is to be passed back,
936                  or NULL (just passed on to match_check_string)
937
938 Returns:         OK    if matched a non-negated item
939                  OK    if hit end of list after a negated item
940                  FAIL  if expansion force-failed
941                  FAIL  if matched a negated item
942                  FAIL  if hit end of list after a non-negated item
943                  DEFER if a lookup deferred
944 */
945
946 int
947 match_isinlist(const uschar *s, const uschar **listptr, int sep,
948    tree_node **anchorptr,
949   unsigned int *cache_bits, int type, BOOL caseless, const uschar **valueptr)
950 {
951 unsigned int *local_cache_bits = cache_bits;
952 check_string_block cb;
953 cb.origsubject = s;
954 cb.subject = caseless? string_copylc(s) : string_copy(s);
955 cb.expand_setup = (sep > UCHAR_MAX)? 0 : -1;
956 cb.use_partial = TRUE;
957 cb.caseless = caseless;
958 cb.at_is_special = (type == MCL_DOMAIN || type == MCL_DOMAIN + MCL_NOEXPAND);
959 if (valueptr != NULL) *valueptr = NULL;
960 return  match_check_list(listptr, sep, anchorptr, &local_cache_bits,
961   check_string, &cb, type, s, valueptr);
962 }
963
964
965
966 /*************************************************
967 *    Match address to single address-list item   *
968 *************************************************/
969
970 /* This function matches an address to an item from an address list. It is
971 called from match_address_list() via match_check_list(). That is why most of
972 its arguments are in an indirect block.
973
974 Arguments:
975   arg            the argument block (see below)
976   pattern        the pattern to match
977   valueptr       where to return a value
978   error          for error messages (not used in this function; it never
979                    returns ERROR)
980
981 The argument block contains:
982   address        the start of the subject address; when called from retry.c
983                    it may be *@domain if the local part isn't relevant
984   origaddress    the original, un-case-forced address (not used here, but used
985                    in match_check_list() when +caseful is encountered)
986   expand_setup   controls setting up of $n variables
987   caseless       TRUE for caseless local part matching
988
989 Returns:         OK     for a match
990                  FAIL   for no match
991                  DEFER  if a lookup deferred
992 */
993
994 static int
995 check_address(void *arg, const uschar *pattern, const uschar **valueptr, uschar **error)
996 {
997 check_address_block *cb = (check_address_block *)arg;
998 check_string_block csb;
999 int rc;
1000 int expand_inc = 0;
1001 unsigned int *null = NULL;
1002 const uschar *listptr;
1003 uschar *subject = cb->address;
1004 const uschar *s;
1005 uschar *pdomain, *sdomain;
1006
1007 error = error;  /* Keep clever compilers from complaining */
1008
1009 DEBUG(D_lists) debug_printf("address match test: subject=%s pattern=%s\n",
1010   subject, pattern);
1011
1012 /* Find the subject's domain */
1013
1014 sdomain = Ustrrchr(subject, '@');
1015
1016 /* The only case where a subject may not have a domain is if the subject is
1017 empty. Otherwise, a subject with no domain is a serious configuration error. */
1018
1019 if (sdomain == NULL && *subject != 0)
1020   {
1021   log_write(0, LOG_MAIN|LOG_PANIC, "no @ found in the subject of an "
1022     "address list match: subject=\"%s\" pattern=\"%s\"", subject, pattern);
1023   return FAIL;
1024   }
1025
1026 /* Handle a regular expression, which must match the entire incoming address.
1027 This may be the empty address. */
1028
1029 if (*pattern == '^')
1030   return match_check_string(subject, pattern, cb->expand_setup, TRUE,
1031     cb->caseless, FALSE, NULL);
1032
1033 /* Handle a pattern that is just a lookup. Skip over possible lookup names
1034 (letters, digits, hyphens). Skip over a possible * or *@ at the end. Then we
1035 must have a semicolon for it to be a lookup. */
1036
1037 for (s = pattern; isalnum(*s) || *s == '-'; s++);
1038 if (*s == '*') s++;
1039 if (*s == '@') s++;
1040
1041 /* If it is a straight lookup, do a lookup for the whole address. This may be
1042 the empty address. Partial matching doesn't make sense here, so we ignore it,
1043 but write a panic log entry. However, *@ matching will be honoured. */
1044
1045 if (*s == ';')
1046   {
1047   if (Ustrncmp(pattern, "partial-", 8) == 0)
1048     log_write(0, LOG_MAIN|LOG_PANIC, "partial matching is not applicable to "
1049       "whole-address lookups: ignored \"partial-\" in \"%s\"", pattern);
1050   return match_check_string(subject, pattern, -1, FALSE, cb->caseless, FALSE,
1051     valueptr);
1052   }
1053
1054 /* For the remaining cases, an empty subject matches only an empty pattern,
1055 because other patterns expect to have a local part and a domain to match
1056 against. */
1057
1058 if (*subject == 0) return (*pattern == 0)? OK : FAIL;
1059
1060 /* If the pattern starts with "@@" we have a split lookup, where the domain is
1061 looked up to obtain a list of local parts. If the subject's local part is just
1062 "*" (called from retry) the match always fails. */
1063
1064 if (pattern[0] == '@' && pattern[1] == '@')
1065   {
1066   int watchdog = 50;
1067   uschar *list, *ss;
1068   uschar buffer[1024];
1069
1070   if (sdomain == subject + 1 && *subject == '*') return FAIL;
1071
1072   /* Loop for handling chains. The last item in any list may be of the form
1073   ">name" in order to chain on to another list. */
1074
1075   for (const uschar * key = sdomain + 1; key && watchdog-- > 0; )
1076     {
1077     int sep = 0;
1078
1079     if ((rc = match_check_string(key, pattern + 2, -1, TRUE, FALSE, FALSE,
1080       CUSS &list)) != OK) return rc;
1081
1082     /* Check for chaining from the last item; set up the next key if one
1083     is found. */
1084
1085     ss = Ustrrchr(list, ':');
1086     if (ss == NULL) ss = list; else ss++;
1087     while (isspace(*ss)) ss++;
1088     if (*ss == '>')
1089       {
1090       *ss++ = 0;
1091       while (isspace(*ss)) ss++;
1092       key = string_copy(ss);
1093       }
1094     else key = NULL;
1095
1096     /* Look up the local parts provided by the list; negation is permitted.
1097     If a local part has to begin with !, a regex can be used. */
1098
1099     while ((ss = string_nextinlist(CUSS &list, &sep, buffer, sizeof(buffer))))
1100       {
1101       int local_yield;
1102
1103       if (*ss == '!')
1104         {
1105         local_yield = FAIL;
1106         while (isspace((*(++ss))));
1107         }
1108       else local_yield = OK;
1109
1110       *sdomain = 0;
1111       rc = match_check_string(subject, ss, -1, TRUE, cb->caseless, FALSE,
1112         valueptr);
1113       *sdomain = '@';
1114
1115       switch(rc)
1116         {
1117         case OK:
1118         return local_yield;
1119
1120         case DEFER:
1121         return DEFER;
1122         }
1123       }
1124     }
1125
1126   /* End of chain loop; panic if too many times */
1127
1128   if (watchdog <= 0)
1129     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "Loop detected in lookup of "
1130       "local part of %s in %s", subject, pattern);
1131
1132   /* Otherwise the local part check has failed, so the whole match
1133   fails. */
1134
1135   return FAIL;
1136   }
1137
1138
1139 /* We get here if the pattern is not a lookup or a regular expression. If it
1140 contains an @ there is both a local part and a domain. */
1141
1142 pdomain = Ustrrchr(pattern, '@');
1143 if (pdomain != NULL)
1144   {
1145   int pllen, sllen;
1146
1147   /* If the domain in the pattern is empty or one of the special cases [] or
1148   mx_{any,primary,secondary}, and the local part in the pattern ends in "@",
1149   we have a pattern of the form <something>@@, <something>@@[], or
1150   <something>@@mx_{any,primary,secondary}. These magic "domains" are
1151   automatically interpreted in match_check_string. We just need to arrange that
1152   the leading @ is included in the domain. */
1153
1154   if (pdomain > pattern && pdomain[-1] == '@' &&
1155        (pdomain[1] == 0 ||
1156         Ustrcmp(pdomain+1, "[]") == 0 ||
1157         Ustrcmp(pdomain+1, "mx_any") == 0 ||
1158         Ustrcmp(pdomain+1, "mx_primary") == 0 ||
1159         Ustrcmp(pdomain+1, "mx_secondary") == 0))
1160     pdomain--;
1161
1162   pllen = pdomain - pattern;
1163   sllen = sdomain - subject;
1164
1165   /* Compare the local parts in the subject and the pattern */
1166
1167   if (*pattern == '*')
1168     {
1169     int cllen = pllen - 1;
1170     if (sllen < cllen) return FAIL;
1171     if (cb->caseless)
1172       {
1173       if (strncmpic(subject+sllen-cllen, pattern + 1, cllen) != 0)
1174         return FAIL;
1175       }
1176     else
1177       {
1178       if (Ustrncmp(subject+sllen-cllen, pattern + 1, cllen) != 0)
1179         return FAIL;
1180       }
1181     if (cb->expand_setup > 0)
1182       {
1183       expand_nstring[cb->expand_setup] = subject;
1184       expand_nlength[cb->expand_setup] = sllen - cllen;
1185       expand_inc = 1;
1186       }
1187     }
1188   else
1189     {
1190     if (sllen != pllen) return FAIL;
1191     if (cb->caseless)
1192       {
1193       if (strncmpic(subject, pattern, sllen) != 0) return FAIL;
1194       }
1195     else
1196       {
1197       if (Ustrncmp(subject, pattern, sllen) != 0) return FAIL;
1198       }
1199     }
1200   }
1201
1202 /* If the local part matched, or was not being checked, check the domain using
1203 the generalized function, which supports file lookups (which may defer). The
1204 original code read as follows:
1205
1206   return match_check_string(sdomain + 1,
1207       (pdomain == NULL)? pattern : pdomain + 1,
1208       cb->expand_setup + expand_inc, TRUE, cb->caseless, TRUE, NULL);
1209
1210 This supported only literal domains and *.x.y patterns. In order to allow for
1211 named domain lists (so that you can right, for example, "senders=+xxxx"), it
1212 was changed to use the list scanning function. */
1213
1214 csb.origsubject = sdomain + 1;
1215 csb.subject = (cb->caseless)? string_copylc(sdomain+1) : string_copy(sdomain+1);
1216 csb.expand_setup = cb->expand_setup + expand_inc;
1217 csb.use_partial = TRUE;
1218 csb.caseless = cb->caseless;
1219 csb.at_is_special = TRUE;
1220
1221 listptr = (pdomain == NULL)? pattern : pdomain + 1;
1222 if (valueptr != NULL) *valueptr = NULL;
1223
1224 return match_check_list(
1225   &listptr,                  /* list of one item */
1226   UCHAR_MAX+1,               /* impossible separator; single item */
1227   &domainlist_anchor,        /* it's a domain list */
1228   &null,                     /* ptr to NULL means no caching */
1229   check_string,              /* the function to do one test */
1230   &csb,                      /* its data */
1231   MCL_DOMAIN + MCL_NOEXPAND, /* domain list; don't expand */
1232   csb.subject,               /* string for messages */
1233   valueptr);                 /* where to pass back lookup data */
1234 }
1235
1236
1237
1238
1239 /*************************************************
1240 *    Test whether address matches address list   *
1241 *************************************************/
1242
1243 /* This function is given an address and a list of things to match it against.
1244 The list may contain individual addresses, regular expressions, lookup
1245 specifications, and indirection via bare files. Negation is supported. The
1246 address to check can consist of just a domain, which will then match only
1247 domain items or items specified as *@domain.
1248
1249 Domains are always lower cased before the match. Local parts are also lower
1250 cased unless "caseless" is false. The work of actually scanning the list is
1251 done by match_check_list(), with an appropriate block of arguments and a
1252 callback to check_address(). During caseless matching, it will recognize
1253 +caseful and revert to caseful matching.
1254
1255 Arguments:
1256   address         address to test
1257   caseless        TRUE to start in caseless state
1258   expand          TRUE to allow list expansion
1259   listptr         list to check against
1260   cache_bits      points to cache bits for named address lists, or NULL
1261   expand_setup    controls setting up of $n variables - passed through
1262                   to check_address (q.v.)
1263   sep             separator character for the list;
1264                   may be 0 to get separator from the list;
1265                   may be UCHAR_MAX+1 for one-item list
1266   valueptr        where to return a lookup value, or NULL
1267
1268 Returns:          OK    for a positive match, or end list after a negation;
1269                   FAIL  for a negative match, or end list after non-negation;
1270                   DEFER if a lookup deferred
1271 */
1272
1273 int
1274 match_address_list(const uschar *address, BOOL caseless, BOOL expand,
1275   const uschar **listptr, unsigned int *cache_bits, int expand_setup, int sep,
1276   const uschar **valueptr)
1277 {
1278 check_address_block ab;
1279 unsigned int *local_cache_bits = cache_bits;
1280 int len;
1281
1282 /* RFC 2505 recommends that for spam checking, local parts should be caselessly
1283 compared. Therefore, Exim now forces the entire address into lower case here,
1284 provided that "caseless" is set. (It is FALSE for calls for matching rewriting
1285 patterns.) Otherwise just the domain is lower cases. A magic item "+caseful" in
1286 the list can be used to restore a caseful copy of the local part from the
1287 original address. */
1288
1289 if ((len = Ustrlen(address)) > 255) len = 255;
1290 ab.address = string_copyn(address, len);
1291
1292 for (uschar * p = ab.address + len - 1; p >= ab.address; p--)
1293   {
1294   if (!caseless && *p == '@') break;
1295   *p = tolower(*p);
1296   }
1297
1298 /* If expand_setup is zero, we need to set up $0 to the whole thing, in
1299 case there is a match. Can't use the built-in facilities of match_check_string
1300 (via check_address), as we may just be calling that for part of the address
1301 (the domain). */
1302
1303 if (expand_setup == 0)
1304   {
1305   expand_nstring[0] = string_copy(address);
1306   expand_nlength[0] = Ustrlen(address);
1307   expand_setup++;
1308   }
1309
1310 /* Set up the data to be passed ultimately to check_address. */
1311
1312 ab.origaddress = address;
1313 /* ab.address is above */
1314 ab.expand_setup = expand_setup;
1315 ab.caseless = caseless;
1316
1317 return match_check_list(listptr, sep, &addresslist_anchor, &local_cache_bits,
1318   check_address, &ab, MCL_ADDRESS + (expand? 0:MCL_NOEXPAND), address,
1319     valueptr);
1320 }
1321
1322 /* Simpler version of match_address_list; always caseless, expanding,
1323 no cache bits, no value-return.
1324
1325 Arguments:
1326   address         address to test
1327   listptr         list to check against
1328   sep             separator character for the list;
1329                   may be 0 to get separator from the list;
1330                   may be UCHAR_MAX+1 for one-item list
1331
1332 Returns:          OK    for a positive match, or end list after a negation;
1333                   FAIL  for a negative match, or end list after non-negation;
1334                   DEFER if a lookup deferred
1335 */
1336
1337 int
1338 match_address_list_basic(const uschar *address, const uschar **listptr, int sep)
1339 {
1340 return match_address_list(address, TRUE, TRUE, listptr, NULL, -1, sep, NULL);
1341 }
1342
1343 /* End of match.c */