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