1 /* $Cambridge: exim/src/src/match.c,v 1.3 2005/01/04 10:00:42 ph10 Exp $ */
3 /*************************************************
4 * Exim - an Internet mail transport agent *
5 *************************************************/
7 /* Copyright (c) University of Cambridge 1995 - 2005 */
8 /* See the file NOTICE for conditions of use and distribution. */
10 /* Functions for matching strings */
16 /* Argument block for the check_string() function. This is used for general
17 strings, domains, and local parts. */
19 typedef struct check_string_block {
20 uschar *origsubject; /* caseful; keep these two first, in */
21 uschar *subject; /* step with the block below */
29 /* Argument block for the check_address() function. This is used for whole
32 typedef struct check_address_block {
33 uschar *origaddress; /* caseful; keep these two first, in */
34 uschar *address; /* step with the block above */
37 } check_address_block;
41 /*************************************************
42 * Generalized string match *
43 *************************************************/
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.
52 The possible types of pattern are:
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
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).
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
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 @
90 Returns: OK if matched
92 DEFER if lookup deferred
96 check_string(void *arg, uschar *pattern, uschar **valueptr, uschar **error)
98 check_string_block *cb = (check_string_block *)arg;
99 int search_type, partial, affixlen, starflags;
100 int expand_setup = cb->expand_setup;
102 uschar *s = cb->subject;
103 uschar *filename = NULL;
104 uschar *keyquery, *result, *semicolon;
107 error = error; /* Keep clever compilers from complaining */
109 if (valueptr != NULL) *valueptr = NULL; /* For non-lookup matches */
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. */
115 if (expand_setup == 0)
117 expand_nstring[0] = s;
118 expand_nlength[0] = Ustrlen(s);
120 else if (expand_setup > 0) expand_setup--;
122 /* Regular expression match: compile, match, and set up $ variables if
125 if (pattern[0] == '^')
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
131 regex_match_and_setup(re, s, 0, expand_setup)
138 if (pattern[0] == '*')
141 int slen = Ustrlen(s);
142 int patlen; /* Sun compiler doesn't like non-constant initializer */
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)
151 expand_nstring[++expand_setup] = s;
152 expand_nlength[expand_setup] = slen - patlen;
153 expand_nmax = expand_setup;
155 return yield? OK : FAIL;
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. */
163 if (cb->at_is_special && pattern[0] == '@')
167 pattern = primary_hostname;
168 goto NOT_AT_SPECIAL; /* Handle as exact string match */
171 if (Ustrcmp(pattern, "@[]") == 0)
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;
181 if (strncmpic(pattern, US"@mx_", 4) == 0)
187 BOOL removed = FALSE;
188 uschar *ss = pattern + 4;
189 uschar *ignore_target_hosts = NULL;
191 if (strncmpic(ss, US"any", 3) == 0) ss += 3;
192 else if (strncmpic(ss, US"primary", 7) == 0)
197 else if (strncmpic(ss, US"secondary", 9) == 0)
202 else goto NOT_AT_SPECIAL;
204 if (strncmpic(ss, US"/ignore=", 8) == 0) ignore_target_hosts = ss + 8;
205 else if (*ss != 0) goto NOT_AT_SPECIAL;
211 rc = host_find_bydns(&h,
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 */
220 if (rc == HOST_FIND_AGAIN)
222 search_error_message = string_sprintf("DNS lookup of \"%s\" deferred", s);
226 if (rc == HOST_FOUND_LOCAL && !secy) return OK;
227 if (prim) return FAIL;
228 return removed? OK : FAIL;
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.
235 return (rc == HOST_FOUND && removed)? OK : FAIL;
240 /* Escape point from code for specials that start with "@" */
244 /* This is an exact string match if there is no semicolon in the pattern. */
246 if ((semicolon = Ustrchr(pattern, ';')) == NULL)
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;
254 /* Otherwise we have a lookup item. The lookup type, including partial, etc. is
255 the part of the string preceding the semicolon. */
258 search_type = search_findtype_partial(pattern, &partial, &affix, &affixlen,
261 if (search_type < 0) log_write(0, LOG_MAIN|LOG_PANIC_DIE, "%s",
262 search_error_message);
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. */
267 if (!cb->use_partial) partial = -1;
269 /* Set the parameters for the two different kinds of lookup. */
271 keyquery = semicolon + 1;
272 while (isspace(*keyquery)) keyquery++;
274 if (!mac_islookup(search_type, lookup_querystyle))
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. */
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);
290 if (result == NULL) return search_find_defer? DEFER : FAIL;
291 if (valueptr != NULL) *valueptr = result;
293 expand_nmax = expand_setup;
299 /*************************************************
300 * Public interface to check_string() *
301 *************************************************/
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().
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
317 Returns: OK if matched
319 DEFER if lookup deferred
323 match_check_string(uschar *s, uschar *pattern, int expand_setup,
324 BOOL use_partial, BOOL caseless, BOOL at_is_special, uschar **valueptr)
326 check_string_block cb;
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);
338 /*************************************************
339 * Get key string from check block *
340 *************************************************/
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.
349 type MCL_STRING, MCL_DOMAIN, MCL_HOST, MCL_ADDRESS, or MCL_LOCALPART
353 get_check_key(void *arg, int type)
360 return ((check_string_block *)arg)->subject;
363 return ((check_host_block *)arg)->host_address;
366 return ((check_address_block *)arg)->address;
368 return US""; /* In practice, should never happen */
373 /*************************************************
374 * Scan list and run matching function *
375 *************************************************/
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.
383 We can't quite keep the different types anonymous here because they permit
384 different special cases. A pity.
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.
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
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
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)
427 unsigned int *original_cache_bits = *cache_ptr;
428 BOOL include_unknown = FALSE;
429 BOOL ignore_unknown = FALSE;
435 /* Save time by not scanning for the option name when we don't need it. */
439 uschar *listname = readconf_find_option(listptr);
440 if (listname[0] != 0) ot = string_sprintf("%s in %s?", name, listname);
443 /* If the list is empty, the answer is no. Skip the debugging output for
446 if (*listptr == NULL)
450 if (ot != NULL) debug_printf("%s no (option unset)\n", ot);
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
460 if (type >= MCL_NOEXPAND)
463 type -= MCL_NOEXPAND; /* Remove the "no expand" flag */
467 list = expand_string(*listptr);
470 if (expand_string_forcedfail)
472 HDEBUG(D_lists) debug_printf("expansion of \"%s\" forced failure: "
473 "assume not in this list\n", *listptr);
476 log_write(0, LOG_MAIN|LOG_PANIC, "failed to expand \"%s\" while checking "
477 "a list: %s", *listptr, expand_string_message);
482 /* For an unnamed list, use the expanded version in comments */
486 if (ot == NULL) ot = string_sprintf("%s in \"%s\"?", name, list);
489 /* Now scan the list and process each item in turn, until one of them matches,
490 or we hit an error. */
492 while ((sss = string_nextinlist(&list, &sep, buffer, sizeof(buffer))) != NULL)
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). */
501 if (type == MCL_ADDRESS)
503 if (Ustrcmp(ss, "+caseful") == 0)
505 check_address_block *cb = (check_address_block *)arg;
506 uschar *at = Ustrrchr(cb->origaddress, '@');
508 Ustrncpy(cb->address, cb->origaddress, at - cb->origaddress);
509 cb->caseless = FALSE;
514 /* Similar processing for local parts */
516 else if (type == MCL_LOCALPART)
518 if (Ustrcmp(ss, "+caseful") == 0)
520 check_string_block *cb = (check_string_block *)arg;
521 Ustrcpy(cb->subject, cb->origsubject);
522 cb->caseless = FALSE;
527 /* If the host item is "+include_unknown", remember it in case there's a
528 subsequent failed reverse lookup. */
530 else if (type == MCL_HOST)
532 if (Ustrcmp(ss, "+include_unknown") == 0)
534 include_unknown = TRUE;
535 ignore_unknown = FALSE;
538 if (Ustrcmp(ss, "+ignore_unknown") == 0)
540 ignore_unknown = TRUE;
541 include_unknown = FALSE;
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. */
552 while (isspace((*(++ss))));
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. */
562 if (*ss == '+' && anchorptr != NULL)
567 unsigned int *use_cache_bits = original_cache_bits;
568 uschar *cached = US"";
570 tree_node *t = tree_search(*anchorptr, ss+1);
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" : "",
581 /* If the list number is negative, it means that this list is not
582 cacheable because it contains expansion items. */
584 if (nb->number < 0) use_cache_bits = NULL;
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
590 if (use_cache_bits != NULL)
592 offset = (nb->number)/16;
593 shift = ((nb->number)%16)*2;
594 bits = use_cache_bits[offset] & (3 << shift);
597 /* Not previously tested or no cache - run the full test */
601 switch (match_check_list(&(nb->string), 0, anchorptr, &use_cache_bits,
602 func, arg, type, name, valueptr))
604 case OK: bits = 1; break;
605 case FAIL: bits = 3; break;
606 case DEFER: goto DEFER_RETURN;
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. */
614 if (use_cache_bits == NULL)
620 use_cache_bits[offset] |= bits << shift;
622 if (valueptr != NULL)
624 int old_pool = store_pool;
625 namedlist_cacheblock *p;
627 /* Cached data for hosts persists over more than one message,
628 so we use the permanent store pool */
630 store_pool = POOL_PERM;
631 p = store_get(sizeof(namedlist_cacheblock));
632 p->key = string_copy(get_check_key(arg, type));
633 store_pool = old_pool;
636 p->next = nb->cache_data;
638 if (*valueptr != NULL)
640 DEBUG(D_lists) debug_printf("data from lookup saved for "
641 "cache for %s: %s\n", ss, *valueptr);
647 /* Previously cached; to find a lookup value, search a chain of values
648 and compare keys. Typically, there is only one such, but it is possible
649 for different keys to have matched the same named list. */
653 DEBUG(D_lists) debug_printf("cached %s match for %s\n",
654 ((bits & (-bits)) == bits)? "yes" : "no", ss);
655 cached = US" - cached";
656 if (valueptr != NULL)
658 uschar *key = get_check_key(arg, type);
659 namedlist_cacheblock *p;
660 for (p = nb->cache_data; p != NULL; p = p->next)
662 if (Ustrcmp(key, p->key) == 0)
668 DEBUG(D_lists) debug_printf("cached lookup data = %s\n", *valueptr);
672 /* Result of test is indicated by value in bits. For each test, we
673 have 00 => untested, 01 => tested yes, 11 => tested no. */
675 if ((bits & (-bits)) == bits) /* Only one of the two bits is set */
677 HDEBUG(D_lists) debug_printf("%s %s (matched \"%s\"%s)\n", ot,
678 (yield == OK)? "yes" : "no", sss, cached);
683 /* Run the provided function to do the individual test. */
688 switch ((func)(arg, ss, valueptr, &error))
691 HDEBUG(D_lists) debug_printf("%s %s (matched \"%s\")\n", ot,
692 (yield == OK)? "yes" : "no", sss);
698 /* The ERROR return occurs only when checking hosts, when either a
699 forward or reverse lookup has failed. The error string gives details of
705 HDEBUG(D_lists) debug_printf("%s: item ignored by +ignore_unknown",
710 HDEBUG(D_lists) debug_printf("%s %s (%s)\n", ot,
711 include_unknown? "yes":"no", error);
712 if (!include_unknown) return FAIL;
713 log_write(0, LOG_MAIN, "%s: accepted by +include_unknown", error);
720 /* If the item is a file name, we read the file and do a match attempt
721 on each line in the file, including possibly more negation processing. */
725 int file_yield = yield; /* In case empty file */
726 uschar *filename = ss;
727 FILE *f = Ufopen(filename, "rb");
728 uschar filebuffer[1024];
730 /* ot will be null in non-debugging cases, and anyway, we get better
731 wording by reworking it. */
735 uschar *listname = readconf_find_option(listptr);
736 if (listname[0] == 0)
737 listname = string_sprintf("\"%s\"", *listptr);
738 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "%s",
739 string_open_failed(errno, "%s when checking %s", sss, listname));
742 /* Trailing comments are introduced by #, but in an address list or local
743 part list, the # must be preceded by white space or the start of the line,
744 because the # character is a legal character in local parts. */
746 while (Ufgets(filebuffer, sizeof(filebuffer), f) != NULL)
749 uschar *sss = filebuffer;
751 while ((ss = Ustrchr(sss, '#')) != NULL)
753 if ((type != MCL_ADDRESS && type != MCL_LOCALPART) ||
754 ss == filebuffer || isspace(ss[-1]))
762 ss = filebuffer + Ustrlen(filebuffer); /* trailing space */
763 while (ss > filebuffer && isspace(ss[-1])) ss--;
767 while (isspace(*ss)) ss++; /* leading space */
769 if (*ss == 0) continue; /* ignore empty */
771 file_yield = yield; /* positive yield */
772 sss = ss; /* for debugging */
774 if (*ss == '!') /* negation */
776 file_yield = (file_yield == OK)? FAIL : OK;
777 while (isspace((*(++ss))));
780 switch ((func)(arg, ss, valueptr, &error))
784 HDEBUG(D_lists) debug_printf("%s %s (matched \"%s\" in %s)\n", ot,
785 (yield == OK)? "yes" : "no", sss, filename);
792 case ERROR: /* host name lookup failed - this can only */
793 if (ignore_unknown) /* be for an incoming host (not outgoing) */
795 HDEBUG(D_lists) debug_printf("%s: item ignored by +ignore_unknown",
800 HDEBUG(D_lists) debug_printf("%s %s (%s)\n", ot,
801 include_unknown? "yes":"no", error);
803 if (!include_unknown) return FAIL;
804 log_write(0, LOG_MAIN, "%s: accepted by +include_unknown", error);
810 /* At the end of the file, leave the yield setting at the final setting
811 for the file, in case this is the last item in the list. */
816 } /* Loop for the next item on the top-level list */
818 /* End of list reached: if the last item was negated yield OK, else FAIL. */
821 debug_printf("%s %s (end of list)\n", ot, (yield == OK)? "no":"yes");
822 return (yield == OK)? FAIL : OK;
824 /* Handle lookup defer */
827 HDEBUG(D_lists) debug_printf("%s lookup deferred for %s\n", ot, sss);
832 /*************************************************
833 * Match in colon-separated list *
834 *************************************************/
836 /* This function is used for domain lists and local part lists. It is not used
837 for host lists or address lists, which have additional interpretation of the
838 patterns. Some calls of it set sep > UCHAR_MAX in order to use its matching
839 facilities on single items. When this is done, it arranges to set the numerical
840 variables as a result of the match.
842 This function is now just a short interface to match_check_list(), which does
843 list scanning in a general way. A good compiler will optimize the tail
847 s string to search for
848 listptr ptr to ptr to colon separated list of patterns, or NULL
849 sep a separator value for the list (see string_nextinlist())
850 anchorptr ptr to tree for named items, or NULL if no named items
851 cache_bits ptr to cache_bits for ditto, or NULL if not caching
852 type MCL_DOMAIN when matching a domain list
853 MCL_LOCALPART when matching a local part list (address lists
854 have their own function)
855 MCL_STRING for others (e.g. list of ciphers)
856 MCL_NOEXPAND (whose value is greater than any of them) may
857 be added to any value to suppress expansion of the list
858 caseless TRUE for (mostly) caseless matching - passed directly to
860 valueptr pointer to where any lookup data is to be passed back,
861 or NULL (just passed on to match_check_string)
863 Returns: OK if matched a non-negated item
864 OK if hit end of list after a negated item
865 FAIL if expansion force-failed
866 FAIL if matched a negated item
867 FAIL if hit end of list after a non-negated item
868 DEFER if a lookup deferred
872 match_isinlist(uschar *s, uschar **listptr, int sep, tree_node **anchorptr,
873 unsigned int *cache_bits, int type, BOOL caseless, uschar **valueptr)
875 unsigned int *local_cache_bits = cache_bits;
876 check_string_block cb;
878 cb.subject = caseless? string_copylc(s) : string_copy(s);
879 cb.expand_setup = (sep > UCHAR_MAX)? 0 : -1;
880 cb.use_partial = TRUE;
881 cb.caseless = caseless;
882 cb.at_is_special = (type == MCL_DOMAIN || type == MCL_DOMAIN + MCL_NOEXPAND);
883 if (valueptr != NULL) *valueptr = NULL;
884 return match_check_list(listptr, sep, anchorptr, &local_cache_bits,
885 check_string, &cb, type, s, valueptr);
890 /*************************************************
891 * Match address to single address-list item *
892 *************************************************/
894 /* This function matches an address to an item from an address list. It is
895 called from match_address_list() via match_check_list(). That is why most of
896 its arguments are in an indirect block.
899 arg the argument block (see below)
900 pattern the pattern to match
901 valueptr where to return a value
902 error for error messages (not used in this function; it never
905 The argument block contains:
906 address the start of the subject address; when called from retry.c
907 it may be *@domain if the local part isn't relevant
908 origaddress the original, un-case-forced address (not used here, but used
909 in match_check_list() when +caseful is encountered)
910 expand_setup controls setting up of $n variables
911 caseless TRUE for caseless local part matching
913 Returns: OK for a match
915 DEFER if a lookup deferred
919 check_address(void *arg, uschar *pattern, uschar **valueptr, uschar **error)
921 check_address_block *cb = (check_address_block *)arg;
922 check_string_block csb;
925 unsigned int *null = NULL;
927 uschar *subject = cb->address;
928 uschar *s, *pdomain, *sdomain;
930 error = error; /* Keep clever compilers from complaining */
932 DEBUG(D_lists) debug_printf("address match: subject=%s pattern=%s\n",
935 /* Handle a regular expression, which must match the entire incoming address.
936 This may be the empty address. */
939 return match_check_string(subject, pattern, cb->expand_setup, TRUE,
940 cb->caseless, FALSE, NULL);
942 /* Handle a pattern that is just a lookup. Skip over possible lookup names
943 (letters, digits, hyphens). Skip over a possible * or *@ at the end. Then we
944 must have a semicolon for it to be a lookup. */
946 for (s = pattern; isalnum(*s) || *s == '-'; s++);
950 /* If it is a straight lookup, do a lookup for the whole address. This may be
951 the empty address. Partial matching doesn't make sense here, so we ignore it,
952 but write a panic log entry. However, *@ matching will be honoured. */
956 if (Ustrncmp(pattern, "partial-", 8) == 0)
957 log_write(0, LOG_MAIN|LOG_PANIC, "partial matching is not applicable to "
958 "whole-address lookups: ignored \"partial-\" in \"%s\"", pattern);
959 return match_check_string(subject, pattern, -1, FALSE, cb->caseless, FALSE,
963 /* For the remaining cases, an empty subject matches only an empty pattern,
964 because other patterns expect to have a local part and a domain to match
967 if (*subject == 0) return (*pattern == 0)? OK : FAIL;
969 /* Find the subject's domain */
971 sdomain = Ustrrchr(subject, '@');
973 /* If the pattern starts with "@@" we have a split lookup, where the domain is
974 looked up to obtain a list of local parts. If the subject's local part is just
975 "*" (called from retry) the match always fails. */
977 if (pattern[0] == '@' && pattern[1] == '@')
980 uschar *list, *key, *ss;
983 if (sdomain == subject + 1 && *subject == '*') return FAIL;
985 /* Loop for handling chains. The last item in any list may be of the form
986 ">name" in order to chain on to another list. */
988 for (key = sdomain + 1; key != NULL && watchdog-- > 0; )
992 if ((rc = match_check_string(key, pattern + 2, -1, TRUE, FALSE, FALSE,
993 &list)) != OK) return rc;
995 /* Check for chaining from the last item; set up the next key if one
998 ss = Ustrrchr(list, ':');
999 if (ss == NULL) ss = list; else ss++;
1000 while (isspace(*ss)) ss++;
1004 while (isspace(*ss)) ss++;
1005 key = string_copy(ss);
1009 /* Look up the local parts provided by the list; negation is permitted.
1010 If a local part has to begin with !, a regex can be used. */
1012 while ((ss = string_nextinlist(&list, &sep, buffer, sizeof(buffer)))
1020 while (isspace((*(++ss))));
1022 else local_yield = OK;
1025 rc = match_check_string(subject, ss, -1, TRUE, cb->caseless, FALSE,
1040 /* End of chain loop; panic if too many times */
1043 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "Loop detected in lookup of "
1044 "local part of %s in %s", subject, pattern);
1046 /* Otherwise the local part check has failed, so the whole match
1053 /* We get here if the pattern is not a lookup or a regular expression. If it
1054 contains an @ there is both a local part and a domain. */
1056 pdomain = Ustrrchr(pattern, '@');
1057 if (pdomain != NULL)
1061 /* If the domain in the pattern is empty or one of the special cases [] or
1062 mx_{any,primary,secondary}, and the local part in the pattern ends in "@",
1063 we have a pattern of the form <something>@@, <something>@@[], or
1064 <something>@@mx_{any,primary,secondary}. These magic "domains" are
1065 automatically interpreted in match_check_string. We just need to arrange that
1066 the leading @ is included in the domain. */
1068 if (pdomain > pattern && pdomain[-1] == '@' &&
1070 Ustrcmp(pdomain+1, "[]") == 0 ||
1071 Ustrcmp(pdomain+1, "mx_any") == 0 ||
1072 Ustrcmp(pdomain+1, "mx_primary") == 0 ||
1073 Ustrcmp(pdomain+1, "mx_secondary") == 0))
1076 pllen = pdomain - pattern;
1077 sllen = sdomain - subject;
1079 /* Compare the local parts in the subject and the pattern */
1081 if (*pattern == '*')
1083 int cllen = pllen - 1;
1084 if (sllen < cllen) return FAIL;
1087 if (strncmpic(subject+sllen-cllen, pattern + 1, cllen) != 0)
1092 if (Ustrncmp(subject+sllen-cllen, pattern + 1, cllen) != 0)
1095 if (cb->expand_setup > 0)
1097 expand_nstring[cb->expand_setup] = subject;
1098 expand_nlength[cb->expand_setup] = sllen - cllen;
1104 if (sllen != pllen) return FAIL;
1107 if (strncmpic(subject, pattern, sllen) != 0) return FAIL;
1111 if (Ustrncmp(subject, pattern, sllen) != 0) return FAIL;
1116 /* If the local part matched, or was not being checked, check the domain using
1117 the generalized function, which supports file lookups (which may defer). The
1118 original code read as follows:
1120 return match_check_string(sdomain + 1,
1121 (pdomain == NULL)? pattern : pdomain + 1,
1122 cb->expand_setup + expand_inc, TRUE, cb->caseless, TRUE, NULL);
1124 This supported only literal domains and *.x.y patterns. In order to allow for
1125 named domain lists (so that you can right, for example, "senders=+xxxx"), it
1126 was changed to use the list scanning function. */
1128 csb.origsubject = sdomain + 1;
1129 csb.subject = (cb->caseless)? string_copylc(sdomain+1) : string_copy(sdomain+1);
1130 csb.expand_setup = cb->expand_setup + expand_inc;
1131 csb.use_partial = TRUE;
1132 csb.caseless = cb->caseless;
1133 csb.at_is_special = TRUE;
1135 listptr = (pdomain == NULL)? pattern : pdomain + 1;
1136 if (valueptr != NULL) *valueptr = NULL;
1138 return match_check_list(
1139 &listptr, /* list of one item */
1140 UCHAR_MAX+1, /* impossible separator; single item */
1141 &domainlist_anchor, /* it's a domain list */
1142 &null, /* ptr to NULL means no caching */
1143 check_string, /* the function to do one test */
1144 &csb, /* its data */
1145 MCL_DOMAIN + MCL_NOEXPAND, /* domain list; don't expand */
1146 csb.subject, /* string for messages */
1147 valueptr); /* where to pass back lookup data */
1153 /*************************************************
1154 * Test whether address matches address list *
1155 *************************************************/
1157 /* This function is given an address and a list of things to match it against.
1158 The list may contain individual addresses, regular expressions, lookup
1159 specifications, and indirection via bare files. Negation is supported. The
1160 address to check can consist of just a domain, which will then match only
1161 domain items or items specified as *@domain.
1163 Domains are always lower cased before the match. Local parts are also lower
1164 cased unless "caseless" is false. The work of actually scanning the list is
1165 done by match_check_list(), with an appropriate block of arguments and a
1166 callback to check_address(). During caseless matching, it will recognize
1167 +caseful and revert to caseful matching.
1170 address address to test
1171 caseless TRUE to start in caseless state
1172 expand TRUE to allow list expansion
1173 listptr list to check against
1174 cache_bits points to cache bits for named address lists, or NULL
1175 expand_setup controls setting up of $n variables - passed through
1176 to check_address (q.v.)
1177 sep separator character for the list;
1178 may be 0 to get separator from the list;
1179 may be UCHAR_MAX+1 for one-item list
1180 valueptr where to return a lookup value, or NULL
1182 Returns: OK for a positive match, or end list after a negation;
1183 FAIL for a negative match, or end list after non-negation;
1184 DEFER if a lookup deferred
1188 match_address_list(uschar *address, BOOL caseless, BOOL expand,
1189 uschar **listptr, unsigned int *cache_bits, int expand_setup, int sep,
1193 check_address_block ab;
1194 unsigned int *local_cache_bits = cache_bits;
1196 /* RFC 2505 recommends that for spam checking, local parts should be caselessly
1197 compared. Therefore, Exim now forces the entire address into lower case here,
1198 provided that "caseless" is set. (It is FALSE for calls for matching rewriting
1199 patterns.) Otherwise just the domain is lower cases. A magic item "+caseful" in
1200 the list can be used to restore a caseful copy of the local part from the
1201 original address. */
1203 sprintf(CS big_buffer, "%.*s", big_buffer_size - 1, address);
1204 for (p = big_buffer + Ustrlen(big_buffer) - 1; p >= big_buffer; p--)
1206 if (!caseless && *p == '@') break;
1210 /* If expand_setup is zero, we need to set up $0 to the whole thing, in
1211 case there is a match. Can't use the built-in facilities of match_check_string
1212 (via check_address), as we may just be calling that for part of the address
1215 if (expand_setup == 0)
1217 expand_nstring[0] = string_copy(address);
1218 expand_nlength[0] = Ustrlen(address);
1222 /* Set up the data to be passed ultimately to check_address. */
1224 ab.origaddress = address;
1225 ab.address = big_buffer;
1226 ab.expand_setup = expand_setup;
1227 ab.caseless = caseless;
1229 return match_check_list(listptr, sep, &addresslist_anchor, &local_cache_bits,
1230 check_address, &ab, MCL_ADDRESS + (expand? 0:MCL_NOEXPAND), address,
1234 /* End of match.c */