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