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