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