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