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