1 /*************************************************
2 * Exim - an Internet mail transport agent *
3 *************************************************/
5 /* Copyright (c) University of Cambridge 1995 - 2018 */
6 /* Copyright (c) The Exim Maintainers 2020 */
7 /* See the file NOTICE for conditions of use and distribution. */
9 /* Functions for matching strings */
15 /* Argument block for the check_string() function. This is used for general
16 strings, domains, and local parts. */
18 typedef struct check_string_block {
19 const uschar *origsubject; /* caseful; keep these two first, in */
20 const uschar *subject; /* step with the block below */
28 /* Argument block for the check_address() function. This is used for whole
31 typedef struct check_address_block {
32 const uschar *origaddress; /* caseful; keep these two first, in */
33 uschar *address; /* step with the block above */
36 } check_address_block;
40 /*************************************************
41 * Generalized string match *
42 *************************************************/
44 /* This function does a single match of a subject against a pattern, and
45 optionally sets up the numeric variables according to what it matched. It is
46 called from match_isinlist() via match_check_list() when scanning a list, and
47 from match_check_string() when testing just a single item. The subject and
48 options arguments are passed in a check_string_block so as to make it easier to
49 pass them through match_check_list.
51 The possible types of pattern are:
53 . regular expression - starts with ^
54 . tail match - starts with *
55 . lookup - starts with search type
56 . if at_is_special is set in the argument block:
57 @ matches the primary host name
58 @[] matches a local IP address in brackets
59 @mx_any matches any domain with an MX to the local host
60 @mx_primary matches any domain with a primary MX to the local host
61 @mx_secondary matches any domain with a secondary MX to the local host
62 . literal - anything else
64 Any of the @mx_xxx options can be followed by "/ignore=<list>" where <list> is
65 a list of IP addresses that are to be ignored (typically 127.0.0.1).
68 arg check_string_block pointer - see below
69 pattern the pattern to be matched
70 valueptr if not NULL, and a lookup is done, return the result here
71 instead of discarding it; else set it to point to NULL
72 error for error messages (not used in this function; it never
75 Contents of the argument block:
76 origsubject the subject in its original casing
77 subject the subject string to be checked, lowercased if caseless
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, const uschar *pattern, const uschar **valueptr, uschar **error)
98 const check_string_block *cb = arg;
99 int search_type, partial, affixlen, starflags;
100 int expand_setup = cb->expand_setup;
101 const uschar * affix, * opts;
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 /* For regular expressions, use cb->origsubject rather than cb->subject so that
112 it works if the pattern uses (?-i) to turn off case-independence, overriding
115 s = string_copy(pattern[0] == '^' ? cb->origsubject : cb->subject);
117 /* If required to set up $0, initialize the data but don't turn on by setting
118 expand_nmax until the match is assured. */
121 if (expand_setup == 0)
123 expand_nstring[0] = s;
124 expand_nlength[0] = Ustrlen(s);
126 else if (expand_setup > 0) expand_setup--;
128 /* Regular expression match: compile, match, and set up $ variables if
131 if (pattern[0] == '^')
133 const pcre *re = regex_must_compile(pattern, cb->caseless, FALSE);
134 return ((expand_setup < 0)?
135 pcre_exec(re, NULL, CCS s, Ustrlen(s), 0, PCRE_EOPT, NULL, 0) >= 0
137 regex_match_and_setup(re, s, 0, expand_setup)
144 if (pattern[0] == '*')
147 int slen = Ustrlen(s);
148 int patlen; /* Sun compiler doesn't like non-constant initializer */
150 patlen = Ustrlen(++pattern);
151 if (patlen > slen) return FAIL;
152 yield = cb->caseless?
153 (strncmpic(s + slen - patlen, pattern, patlen) == 0) :
154 (Ustrncmp(s + slen - patlen, pattern, patlen) == 0);
155 if (yield && expand_setup >= 0)
157 expand_nstring[++expand_setup] = s;
158 expand_nlength[expand_setup] = slen - patlen;
159 expand_nmax = expand_setup;
161 return yield? OK : FAIL;
164 /* Match a special item starting with @ if so enabled. On its own, "@" matches
165 the primary host name - implement this by changing the pattern. For the other
166 cases we have to do some more work. If we don't recognize a special pattern,
167 just fall through - the match will fail. */
169 if (cb->at_is_special && pattern[0] == '@')
173 pattern = primary_hostname;
174 goto NOT_AT_SPECIAL; /* Handle as exact string match */
177 if (Ustrcmp(pattern, "@[]") == 0)
179 int slen = Ustrlen(s);
180 if (s[0] != '[' && s[slen-1] != ']') return FAIL;
181 for (ip_address_item * ip = host_find_interfaces(); ip; ip = ip->next)
182 if (Ustrncmp(ip->address, s+1, slen - 2) == 0
183 && ip->address[slen - 2] == 0)
188 if (strncmpic(pattern, US"@mx_", 4) == 0)
194 BOOL removed = FALSE;
195 const uschar *ss = pattern + 4;
196 const uschar *ignore_target_hosts = NULL;
198 if (strncmpic(ss, US"any", 3) == 0) ss += 3;
199 else if (strncmpic(ss, US"primary", 7) == 0)
204 else if (strncmpic(ss, US"secondary", 9) == 0)
209 else goto NOT_AT_SPECIAL;
211 if (strncmpic(ss, US"/ignore=", 8) == 0) ignore_target_hosts = ss + 8;
212 else if (*ss != 0) goto NOT_AT_SPECIAL;
218 rc = host_find_bydns(&h,
220 HOST_FIND_BY_MX, /* search only for MX, not SRV or A */
221 NULL, /* service name not relevant */
222 NULL, /* srv_fail_domains not relevant */
223 NULL, /* mx_fail_domains not relevant */
224 NULL, /* no dnssec request/require XXX ? */
225 NULL, /* no feedback FQDN */
226 &removed); /* feedback if local removed */
228 if (rc == HOST_FIND_AGAIN)
230 search_error_message = string_sprintf("DNS lookup of \"%s\" deferred", s);
234 if (rc == HOST_FOUND_LOCAL && !secy) return OK;
235 if (prim) return FAIL;
236 return removed? OK : FAIL;
238 /*** The above line used to be the following line, but this is incorrect,
239 because host_find_bydns() may return HOST_NOT_FOUND if it removed some MX
240 hosts, but the remaining ones were non-existent. All we are interested in
241 is whether or not it removed some hosts.
243 return (rc == HOST_FOUND && removed)? OK : FAIL;
248 /* Escape point from code for specials that start with "@" */
252 /* This is an exact string match if there is no semicolon in the pattern. */
254 if ((semicolon = Ustrchr(pattern, ';')) == NULL)
256 BOOL yield = cb->caseless?
257 (strcmpic(s, pattern) == 0) : (Ustrcmp(s, pattern) == 0);
258 if (yield && expand_setup >= 0) expand_nmax = expand_setup;
259 return yield? OK : FAIL;
262 /* Otherwise we have a lookup item. The lookup type, including partial, etc. is
263 the part of the string preceding the semicolon. */
266 search_type = search_findtype_partial(pattern, &partial, &affix, &affixlen,
269 if (search_type < 0) log_write(0, LOG_MAIN|LOG_PANIC_DIE, "%s",
270 search_error_message);
272 /* Partial matching is not appropriate for certain lookups (e.g. when looking
273 up user@domain for sender rejection). There's a flag to disable it. */
275 if (!cb->use_partial) partial = -1;
277 /* Set the parameters for the three different kinds of lookup. */
279 keyquery = semicolon + 1;
280 Uskip_whitespace(&keyquery);
282 if (mac_islookup(search_type, lookup_absfilequery))
285 while (*keyquery && !isspace(*keyquery)) keyquery++;
286 filename = string_copyn(filename, keyquery - filename);
287 Uskip_whitespace(&keyquery);
290 else if (!mac_islookup(search_type, lookup_querystyle))
296 /* Now do the actual lookup; throw away the data returned unless it was asked
297 for; partial matching is all handled inside search_find(). Note that there is
298 no search_close() because of the caching arrangements. */
300 if (!(handle = search_open(filename, search_type, 0, NULL, NULL)))
301 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "%s", search_error_message);
302 result = search_find(handle, filename, keyquery, partial, affix, affixlen,
303 starflags, &expand_setup, opts);
305 if (!result) return f.search_find_defer ? DEFER : FAIL;
306 if (valueptr) *valueptr = result;
308 expand_nmax = expand_setup;
314 /*************************************************
315 * Public interface to check_string() *
316 *************************************************/
318 /* This function is called from several places where is it most convenient to
319 pass the arguments individually. It places them in a check_string_block
320 structure, and then calls check_string().
323 s the subject string to be checked
324 pattern the pattern to check it against
325 expand_setup expansion setup option (see check_string())
326 use_partial if FALSE, override any partial- search types
327 caseless TRUE for caseless matching where possible
328 at_is_special TRUE to recognize @, @[], etc.
329 valueptr if not NULL, and a file lookup was done, return the result
330 here instead of discarding it; else set it to point to NULL
332 Returns: OK if matched
334 DEFER if lookup deferred
338 match_check_string(const uschar *s, const uschar *pattern, int expand_setup,
339 BOOL use_partial, BOOL caseless, BOOL at_is_special, const uschar **valueptr)
341 check_string_block cb;
343 cb.subject = caseless? string_copylc(s) : string_copy(s);
344 cb.expand_setup = expand_setup;
345 cb.use_partial = use_partial;
346 cb.caseless = caseless;
347 cb.at_is_special = at_is_special;
348 return check_string(&cb, pattern, valueptr, NULL);
353 /*************************************************
354 * Get key string from check block *
355 *************************************************/
357 /* When caching the data from a lookup for a named list, we have to save the
358 key that was found, because other lookups of different keys on the same list
359 may occur. This function has knowledge of the different lookup types, and
360 extracts the appropriate key.
364 type MCL_STRING, MCL_DOMAIN, MCL_HOST, MCL_ADDRESS, or MCL_LOCALPART
367 static const uschar *
368 get_check_key(void *arg, int type)
375 return ((check_string_block *)arg)->subject;
378 return ((check_host_block *)arg)->host_address;
381 return ((check_address_block *)arg)->address;
383 return US""; /* In practice, should never happen */
388 /*************************************************
389 * Scan list and run matching function *
390 *************************************************/
392 /* This function scans a list of patterns, and runs a matching function for
393 each item in the list. It is called from the functions that match domains,
394 local parts, hosts, and addresses, because its overall structure is the same in
395 all cases. However, the details of each particular match is different, so it
396 calls back to a given function do perform an actual match.
398 We can't quite keep the different types anonymous here because they permit
399 different special cases. A pity.
401 If a list item starts with !, that implies negation if the subject matches the
402 rest of the item (ignoring white space after the !). The result when the end of
403 the list is reached is FALSE unless the last item on the list is negated, in
404 which case it is TRUE. A file name in the list causes its lines to be
405 interpolated as if items in the list. An item starting with + is a named
406 sublist, obtained by searching the tree pointed to by anchorptr, with possible
407 cached match results in cache_bits.
410 listptr pointer to the pointer to the list
411 sep separator character for string_nextinlist();
412 normally zero for a standard list;
413 sometimes UCHAR_MAX+1 for single items;
414 anchorptr -> tree of named items, or NULL if no named items
415 cache_ptr pointer to pointer to cache bits for named items, or
416 pointer to NULL if not caching; may get set NULL if an
417 uncacheable named list is encountered
418 func function to call back to do one test
419 arg pointer to pass to the function; the string to be matched is
420 in the structure it points to
421 type MCL_STRING, MCL_DOMAIN, MCL_HOST, MCL_ADDRESS, or MCL_LOCALPART
422 these are used for some special handling
423 MCL_NOEXPAND (whose value is greater than any of them) may
424 be added to any value to suppress expansion of the list
425 name string to use in debugging info
426 valueptr where to pass back data from a lookup
428 Returns: OK if matched a non-negated item
429 OK if hit end of list after a negated item
430 FAIL if expansion force-failed
431 FAIL if matched a negated item
432 FAIL if hit end of list after a non-negated item
433 DEFER if a something deferred or expansion failed
437 match_check_list(const uschar **listptr, int sep, tree_node **anchorptr,
438 unsigned int **cache_ptr, int (*func)(void *,const uschar *,const uschar **,uschar **),
439 void *arg, int type, const uschar *name, const uschar **valueptr)
442 unsigned int *original_cache_bits = *cache_ptr;
443 BOOL include_unknown = FALSE;
444 BOOL ignore_unknown = FALSE;
445 BOOL include_defer = FALSE;
446 BOOL ignore_defer = FALSE;
451 /* Save time by not scanning for the option name when we don't need it. */
455 uschar *listname = readconf_find_option(listptr);
456 if (listname[0] != 0) ot = string_sprintf("%s in %s?", name, listname);
459 /* If the list is empty, the answer is no. Skip the debugging output for
464 HDEBUG(D_lists) if (ot) debug_printf("%s no (option unset)\n", ot);
468 /* Expand the list before we scan it. A forced expansion gives the answer
469 "not in list"; other expansion errors cause DEFER to be returned. However,
470 if the type value is greater than or equal to than MCL_NOEXPAND, do not expand
473 if (type >= MCL_NOEXPAND)
476 type -= MCL_NOEXPAND; /* Remove the "no expand" flag */
480 /* If we are searching a domain list, and $domain is not set, set it to the
481 subject that is being sought for the duration of the expansion. */
483 if (type == MCL_DOMAIN && !deliver_domain)
485 check_string_block *cb = (check_string_block *)arg;
486 deliver_domain = string_copy(cb->subject);
487 list = expand_cstring(*listptr);
488 deliver_domain = NULL;
491 list = expand_cstring(*listptr);
495 if (f.expand_string_forcedfail)
497 HDEBUG(D_lists) debug_printf("expansion of \"%s\" forced failure: "
498 "assume not in this list\n", *listptr);
501 log_write(0, LOG_MAIN|LOG_PANIC, "failed to expand \"%s\" while checking "
502 "a list: %s", *listptr, expand_string_message);
507 /* For an unnamed list, use the expanded version in comments */
509 HDEBUG(D_any) if (!ot) ot = string_sprintf("%s in \"%s\"?", name, list);
511 /* Now scan the list and process each item in turn, until one of them matches,
512 or we hit an error. */
514 while ((sss = string_nextinlist(&list, &sep, NULL, 0)))
518 /* Address lists may contain +caseful, to restore caseful matching of the
519 local part. We have to know the layout of the control block, unfortunately.
520 The lower cased address is in a temporary buffer, so we just copy the local
521 part back to the start of it (if a local part exists). */
523 if (type == MCL_ADDRESS)
525 if (Ustrcmp(ss, "+caseful") == 0)
527 check_address_block *cb = (check_address_block *)arg;
528 uschar *at = Ustrrchr(cb->origaddress, '@');
531 Ustrncpy(cb->address, cb->origaddress, at - cb->origaddress);
532 cb->caseless = FALSE;
537 /* Similar processing for local parts */
539 else if (type == MCL_LOCALPART)
541 if (Ustrcmp(ss, "+caseful") == 0)
543 check_string_block *cb = (check_string_block *)arg;
544 Ustrcpy(US cb->subject, cb->origsubject);
545 cb->caseless = FALSE;
550 /* If the host item is "+include_unknown" or "+ignore_unknown", remember it
551 in case there's a subsequent failed reverse lookup. There is similar
552 processing for "defer". */
554 else if (type == MCL_HOST && *ss == '+')
556 if (Ustrcmp(ss, "+include_unknown") == 0)
558 include_unknown = TRUE;
559 ignore_unknown = FALSE;
562 if (Ustrcmp(ss, "+ignore_unknown") == 0)
564 ignore_unknown = TRUE;
565 include_unknown = FALSE;
568 if (Ustrcmp(ss, "+include_defer") == 0)
570 include_defer = TRUE;
571 ignore_defer = FALSE;
574 if (Ustrcmp(ss, "+ignore_defer") == 0)
577 include_defer = FALSE;
582 /* Starting with ! specifies a negative item. It is theoretically possible
583 for a local part to start with !. In that case, a regex has to be used. */
588 while (isspace((*(++ss))));
593 /* If the item does not begin with '/', it might be a + item for a named
594 list. Otherwise, it is just a single list entry that has to be matched.
595 We recognize '+' only when supplied with a tree of named lists. */
599 if (*ss == '+' && anchorptr)
604 unsigned int *use_cache_bits = original_cache_bits;
605 uschar *cached = US"";
609 if (!(t = tree_search(*anchorptr, ss+1)))
611 log_write(0, LOG_MAIN|LOG_PANIC, "unknown named%s list \"%s\"",
612 type == MCL_DOMAIN ? " domain" :
613 type == MCL_HOST ? " host" :
614 type == MCL_ADDRESS ? " address" :
615 type == MCL_LOCALPART ? " local part" : "",
621 /* If the list number is negative, it means that this list is not
622 cacheable because it contains expansion items. */
624 if (nb->number < 0) use_cache_bits = NULL;
626 /* If we have got a cache pointer, get the bits. This is not an "else"
627 because the pointer may be NULL from the start if caching is not
632 offset = (nb->number)/16;
633 shift = ((nb->number)%16)*2;
634 bits = use_cache_bits[offset] & (3 << shift);
637 /* Not previously tested or no cache - run the full test */
641 switch (match_check_list(&(nb->string), 0, anchorptr, &use_cache_bits,
642 func, arg, type, name, valueptr))
644 case OK: bits = 1; break;
645 case FAIL: bits = 3; break;
646 case DEFER: goto DEFER_RETURN;
649 /* If this list was uncacheable, or a sublist turned out to be
650 uncacheable, the value of use_cache_bits will now be NULL, even if it
651 wasn't before. Ensure that this is passed up to the next level.
652 Otherwise, remember the result of the search in the cache. */
658 use_cache_bits[offset] |= bits << shift;
662 int old_pool = store_pool;
663 namedlist_cacheblock *p;
665 /* Cached data for hosts persists over more than one message,
666 so we use the permanent store pool */
668 store_pool = POOL_PERM;
669 p = store_get(sizeof(namedlist_cacheblock), FALSE);
670 p->key = string_copy(get_check_key(arg, type));
673 p->data = *valueptr ? string_copy(*valueptr) : NULL;
674 store_pool = old_pool;
676 p->next = nb->cache_data;
679 DEBUG(D_lists) debug_printf("data from lookup saved for "
680 "cache for %s: %s\n", ss, *valueptr);
685 /* Previously cached; to find a lookup value, search a chain of values
686 and compare keys. Typically, there is only one such, but it is possible
687 for different keys to have matched the same named list. */
691 DEBUG(D_lists) debug_printf("cached %s match for %s\n",
692 ((bits & (-bits)) == bits)? "yes" : "no", ss);
694 cached = US" - cached";
697 const uschar *key = get_check_key(arg, type);
699 for (namedlist_cacheblock * p = nb->cache_data; p; p = p->next)
700 if (Ustrcmp(key, p->key) == 0)
705 DEBUG(D_lists) debug_printf("cached lookup data = %s\n", *valueptr);
709 /* Result of test is indicated by value in bits. For each test, we
710 have 00 => untested, 01 => tested yes, 11 => tested no. */
712 if ((bits & (-bits)) == bits) /* Only one of the two bits is set */
714 HDEBUG(D_lists) debug_printf("%s %s (matched \"%s\"%s)\n", ot,
715 (yield == OK)? "yes" : "no", sss, cached);
720 /* Run the provided function to do the individual test. */
724 uschar * error = NULL;
725 switch ((func)(arg, ss, valueptr, &error))
728 HDEBUG(D_lists) debug_printf("%s %s (matched \"%s\")\n", ot,
729 (yield == OK)? "yes" : "no", sss);
734 error = string_sprintf("DNS lookup of \"%s\" deferred", ss);
737 HDEBUG(D_lists) debug_printf("%s: item ignored by +ignore_defer\n",
743 log_write(0, LOG_MAIN, "%s: accepted by +include_defer", error);
746 if (!search_error_message) search_error_message = error;
749 /* The ERROR return occurs when checking hosts, when either a forward
750 or reverse lookup has failed. It can also occur in a match_ip list if a
751 non-IP address item is encountered. The error string gives details of
757 HDEBUG(D_lists) debug_printf("%s: item ignored by +ignore_unknown\n",
762 HDEBUG(D_lists) debug_printf("%s %s (%s)\n", ot,
763 include_unknown? "yes":"no", error);
764 if (!include_unknown)
766 if (LOGGING(unknown_in_list))
767 log_write(0, LOG_MAIN, "list matching forced to fail: %s", error);
770 log_write(0, LOG_MAIN, "%s: accepted by +include_unknown", error);
777 /* If the item is a file name, we read the file and do a match attempt
778 on each line in the file, including possibly more negation processing. */
782 int file_yield = yield; /* In case empty file */
783 uschar * filename = ss;
784 FILE * f = Ufopen(filename, "rb");
785 uschar filebuffer[1024];
787 /* ot will be null in non-debugging cases, and anyway, we get better
788 wording by reworking it. */
792 uschar * listname = readconf_find_option(listptr);
793 if (listname[0] == 0)
794 listname = string_sprintf("\"%s\"", *listptr);
795 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "%s",
796 string_open_failed(errno, "%s when checking %s", sss, listname));
799 /* Trailing comments are introduced by #, but in an address list or local
800 part list, the # must be preceded by white space or the start of the line,
801 because the # character is a legal character in local parts. */
803 while (Ufgets(filebuffer, sizeof(filebuffer), f) != NULL)
806 uschar *sss = filebuffer;
808 while ((ss = Ustrchr(sss, '#')) != NULL)
810 if ((type != MCL_ADDRESS && type != MCL_LOCALPART) ||
811 ss == filebuffer || isspace(ss[-1]))
819 ss = filebuffer + Ustrlen(filebuffer); /* trailing space */
820 while (ss > filebuffer && isspace(ss[-1])) ss--;
824 while (isspace(*ss)) ss++; /* leading space */
826 if (*ss == 0) continue; /* ignore empty */
828 file_yield = yield; /* positive yield */
829 sss = ss; /* for debugging */
831 if (*ss == '!') /* negation */
833 file_yield = (file_yield == OK)? FAIL : OK;
834 while (isspace((*(++ss))));
837 switch ((func)(arg, ss, valueptr, &error))
841 HDEBUG(D_lists) debug_printf("%s %s (matched \"%s\" in %s)\n", ot,
842 yield == OK ? "yes" : "no", sss, filename);
847 error = string_sprintf("DNS lookup of %s deferred", ss);
850 HDEBUG(D_lists) debug_printf("%s: item ignored by +ignore_defer\n",
857 log_write(0, LOG_MAIN, "%s: accepted by +include_defer", error);
862 case ERROR: /* host name lookup failed - this can only */
863 if (ignore_unknown) /* be for an incoming host (not outgoing) */
865 HDEBUG(D_lists) debug_printf("%s: item ignored by +ignore_unknown\n",
870 HDEBUG(D_lists) debug_printf("%s %s (%s)\n", ot,
871 include_unknown? "yes":"no", error);
873 if (!include_unknown)
875 if (LOGGING(unknown_in_list))
876 log_write(0, LOG_MAIN, "list matching forced to fail: %s", error);
879 log_write(0, LOG_MAIN, "%s: accepted by +include_unknown", error);
885 /* At the end of the file, leave the yield setting at the final setting
886 for the file, in case this is the last item in the list. */
891 } /* Loop for the next item on the top-level list */
893 /* End of list reached: if the last item was negated yield OK, else FAIL. */
896 debug_printf("%s %s (end of list)\n", ot, yield == OK ? "no":"yes");
897 return yield == OK ? FAIL : OK;
899 /* Something deferred */
902 HDEBUG(D_lists) debug_printf("%s list match deferred for %s\n", ot, sss);
907 /*************************************************
908 * Match in colon-separated list *
909 *************************************************/
911 /* This function is used for domain lists and local part lists. It is not used
912 for host lists or address lists, which have additional interpretation of the
913 patterns. Some calls of it set sep > UCHAR_MAX in order to use its matching
914 facilities on single items. When this is done, it arranges to set the numerical
915 variables as a result of the match.
917 This function is now just a short interface to match_check_list(), which does
918 list scanning in a general way. A good compiler will optimize the tail
922 s string to search for
923 listptr ptr to ptr to colon separated list of patterns, or NULL
924 sep a separator value for the list (see string_nextinlist())
925 anchorptr ptr to tree for named items, or NULL if no named items
926 cache_bits ptr to cache_bits for ditto, or NULL if not caching
927 type MCL_DOMAIN when matching a domain list
928 MCL_LOCALPART when matching a local part list (address lists
929 have their own function)
930 MCL_STRING for others (e.g. list of ciphers)
931 MCL_NOEXPAND (whose value is greater than any of them) may
932 be added to any value to suppress expansion of the list
933 caseless TRUE for (mostly) caseless matching - passed directly to
935 valueptr pointer to where any lookup data is to be passed back,
936 or NULL (just passed on to match_check_string)
938 Returns: OK if matched a non-negated item
939 OK if hit end of list after a negated item
940 FAIL if expansion force-failed
941 FAIL if matched a negated item
942 FAIL if hit end of list after a non-negated item
943 DEFER if a lookup deferred
947 match_isinlist(const uschar *s, const uschar **listptr, int sep,
948 tree_node **anchorptr,
949 unsigned int *cache_bits, int type, BOOL caseless, const uschar **valueptr)
951 unsigned int *local_cache_bits = cache_bits;
952 check_string_block cb;
954 cb.subject = caseless? string_copylc(s) : string_copy(s);
955 cb.expand_setup = (sep > UCHAR_MAX)? 0 : -1;
956 cb.use_partial = TRUE;
957 cb.caseless = caseless;
958 cb.at_is_special = (type == MCL_DOMAIN || type == MCL_DOMAIN + MCL_NOEXPAND);
959 if (valueptr != NULL) *valueptr = NULL;
960 return match_check_list(listptr, sep, anchorptr, &local_cache_bits,
961 check_string, &cb, type, s, valueptr);
966 /*************************************************
967 * Match address to single address-list item *
968 *************************************************/
970 /* This function matches an address to an item from an address list. It is
971 called from match_address_list() via match_check_list(). That is why most of
972 its arguments are in an indirect block.
975 arg the argument block (see below)
976 pattern the pattern to match
977 valueptr where to return a value
978 error for error messages (not used in this function; it never
981 The argument block contains:
982 address the start of the subject address; when called from retry.c
983 it may be *@domain if the local part isn't relevant
984 origaddress the original, un-case-forced address (not used here, but used
985 in match_check_list() when +caseful is encountered)
986 expand_setup controls setting up of $n variables
987 caseless TRUE for caseless local part matching
989 Returns: OK for a match
991 DEFER if a lookup deferred
995 check_address(void *arg, const uschar *pattern, const uschar **valueptr, uschar **error)
997 check_address_block *cb = (check_address_block *)arg;
998 check_string_block csb;
1001 unsigned int *null = NULL;
1002 const uschar *listptr;
1003 uschar *subject = cb->address;
1005 uschar *pdomain, *sdomain;
1007 error = error; /* Keep clever compilers from complaining */
1009 DEBUG(D_lists) debug_printf("address match test: subject=%s pattern=%s\n",
1012 /* Find the subject's domain */
1014 sdomain = Ustrrchr(subject, '@');
1016 /* The only case where a subject may not have a domain is if the subject is
1017 empty. Otherwise, a subject with no domain is a serious configuration error. */
1019 if (sdomain == NULL && *subject != 0)
1021 log_write(0, LOG_MAIN|LOG_PANIC, "no @ found in the subject of an "
1022 "address list match: subject=\"%s\" pattern=\"%s\"", subject, pattern);
1026 /* Handle a regular expression, which must match the entire incoming address.
1027 This may be the empty address. */
1029 if (*pattern == '^')
1030 return match_check_string(subject, pattern, cb->expand_setup, TRUE,
1031 cb->caseless, FALSE, NULL);
1033 /* Handle a pattern that is just a lookup. Skip over possible lookup names
1034 (letters, digits, hyphens). Skip over a possible * or *@ at the end. Then we
1035 must have a semicolon for it to be a lookup. */
1037 for (s = pattern; isalnum(*s) || *s == '-'; s++);
1041 /* If it is a straight lookup, do a lookup for the whole address. This may be
1042 the empty address. Partial matching doesn't make sense here, so we ignore it,
1043 but write a panic log entry. However, *@ matching will be honoured. */
1047 if (Ustrncmp(pattern, "partial-", 8) == 0)
1048 log_write(0, LOG_MAIN|LOG_PANIC, "partial matching is not applicable to "
1049 "whole-address lookups: ignored \"partial-\" in \"%s\"", pattern);
1050 return match_check_string(subject, pattern, -1, FALSE, cb->caseless, FALSE,
1054 /* For the remaining cases, an empty subject matches only an empty pattern,
1055 because other patterns expect to have a local part and a domain to match
1058 if (*subject == 0) return (*pattern == 0)? OK : FAIL;
1060 /* If the pattern starts with "@@" we have a split lookup, where the domain is
1061 looked up to obtain a list of local parts. If the subject's local part is just
1062 "*" (called from retry) the match always fails. */
1064 if (pattern[0] == '@' && pattern[1] == '@')
1068 uschar buffer[1024];
1070 if (sdomain == subject + 1 && *subject == '*') return FAIL;
1072 /* Loop for handling chains. The last item in any list may be of the form
1073 ">name" in order to chain on to another list. */
1075 for (const uschar * key = sdomain + 1; key && watchdog-- > 0; )
1079 if ((rc = match_check_string(key, pattern + 2, -1, TRUE, FALSE, FALSE,
1080 CUSS &list)) != OK) return rc;
1082 /* Check for chaining from the last item; set up the next key if one
1085 ss = Ustrrchr(list, ':');
1086 if (ss == NULL) ss = list; else ss++;
1087 while (isspace(*ss)) ss++;
1091 while (isspace(*ss)) ss++;
1092 key = string_copy(ss);
1096 /* Look up the local parts provided by the list; negation is permitted.
1097 If a local part has to begin with !, a regex can be used. */
1099 while ((ss = string_nextinlist(CUSS &list, &sep, buffer, sizeof(buffer))))
1106 while (isspace((*(++ss))));
1108 else local_yield = OK;
1111 rc = match_check_string(subject, ss, -1, TRUE, cb->caseless, FALSE,
1126 /* End of chain loop; panic if too many times */
1129 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "Loop detected in lookup of "
1130 "local part of %s in %s", subject, pattern);
1132 /* Otherwise the local part check has failed, so the whole match
1139 /* We get here if the pattern is not a lookup or a regular expression. If it
1140 contains an @ there is both a local part and a domain. */
1142 pdomain = Ustrrchr(pattern, '@');
1143 if (pdomain != NULL)
1147 /* If the domain in the pattern is empty or one of the special cases [] or
1148 mx_{any,primary,secondary}, and the local part in the pattern ends in "@",
1149 we have a pattern of the form <something>@@, <something>@@[], or
1150 <something>@@mx_{any,primary,secondary}. These magic "domains" are
1151 automatically interpreted in match_check_string. We just need to arrange that
1152 the leading @ is included in the domain. */
1154 if (pdomain > pattern && pdomain[-1] == '@' &&
1156 Ustrcmp(pdomain+1, "[]") == 0 ||
1157 Ustrcmp(pdomain+1, "mx_any") == 0 ||
1158 Ustrcmp(pdomain+1, "mx_primary") == 0 ||
1159 Ustrcmp(pdomain+1, "mx_secondary") == 0))
1162 pllen = pdomain - pattern;
1163 sllen = sdomain - subject;
1165 /* Compare the local parts in the subject and the pattern */
1167 if (*pattern == '*')
1169 int cllen = pllen - 1;
1170 if (sllen < cllen) return FAIL;
1173 if (strncmpic(subject+sllen-cllen, pattern + 1, cllen) != 0)
1178 if (Ustrncmp(subject+sllen-cllen, pattern + 1, cllen) != 0)
1181 if (cb->expand_setup > 0)
1183 expand_nstring[cb->expand_setup] = subject;
1184 expand_nlength[cb->expand_setup] = sllen - cllen;
1190 if (sllen != pllen) return FAIL;
1193 if (strncmpic(subject, pattern, sllen) != 0) return FAIL;
1197 if (Ustrncmp(subject, pattern, sllen) != 0) return FAIL;
1202 /* If the local part matched, or was not being checked, check the domain using
1203 the generalized function, which supports file lookups (which may defer). The
1204 original code read as follows:
1206 return match_check_string(sdomain + 1,
1207 (pdomain == NULL)? pattern : pdomain + 1,
1208 cb->expand_setup + expand_inc, TRUE, cb->caseless, TRUE, NULL);
1210 This supported only literal domains and *.x.y patterns. In order to allow for
1211 named domain lists (so that you can right, for example, "senders=+xxxx"), it
1212 was changed to use the list scanning function. */
1214 csb.origsubject = sdomain + 1;
1215 csb.subject = (cb->caseless)? string_copylc(sdomain+1) : string_copy(sdomain+1);
1216 csb.expand_setup = cb->expand_setup + expand_inc;
1217 csb.use_partial = TRUE;
1218 csb.caseless = cb->caseless;
1219 csb.at_is_special = TRUE;
1221 listptr = (pdomain == NULL)? pattern : pdomain + 1;
1222 if (valueptr != NULL) *valueptr = NULL;
1224 return match_check_list(
1225 &listptr, /* list of one item */
1226 UCHAR_MAX+1, /* impossible separator; single item */
1227 &domainlist_anchor, /* it's a domain list */
1228 &null, /* ptr to NULL means no caching */
1229 check_string, /* the function to do one test */
1230 &csb, /* its data */
1231 MCL_DOMAIN + MCL_NOEXPAND, /* domain list; don't expand */
1232 csb.subject, /* string for messages */
1233 valueptr); /* where to pass back lookup data */
1239 /*************************************************
1240 * Test whether address matches address list *
1241 *************************************************/
1243 /* This function is given an address and a list of things to match it against.
1244 The list may contain individual addresses, regular expressions, lookup
1245 specifications, and indirection via bare files. Negation is supported. The
1246 address to check can consist of just a domain, which will then match only
1247 domain items or items specified as *@domain.
1249 Domains are always lower cased before the match. Local parts are also lower
1250 cased unless "caseless" is false. The work of actually scanning the list is
1251 done by match_check_list(), with an appropriate block of arguments and a
1252 callback to check_address(). During caseless matching, it will recognize
1253 +caseful and revert to caseful matching.
1256 address address to test
1257 caseless TRUE to start in caseless state
1258 expand TRUE to allow list expansion
1259 listptr list to check against
1260 cache_bits points to cache bits for named address lists, or NULL
1261 expand_setup controls setting up of $n variables - passed through
1262 to check_address (q.v.)
1263 sep separator character for the list;
1264 may be 0 to get separator from the list;
1265 may be UCHAR_MAX+1 for one-item list
1266 valueptr where to return a lookup value, or NULL
1268 Returns: OK for a positive match, or end list after a negation;
1269 FAIL for a negative match, or end list after non-negation;
1270 DEFER if a lookup deferred
1274 match_address_list(const uschar *address, BOOL caseless, BOOL expand,
1275 const uschar **listptr, unsigned int *cache_bits, int expand_setup, int sep,
1276 const uschar **valueptr)
1278 check_address_block ab;
1279 unsigned int *local_cache_bits = cache_bits;
1282 /* RFC 2505 recommends that for spam checking, local parts should be caselessly
1283 compared. Therefore, Exim now forces the entire address into lower case here,
1284 provided that "caseless" is set. (It is FALSE for calls for matching rewriting
1285 patterns.) Otherwise just the domain is lower cases. A magic item "+caseful" in
1286 the list can be used to restore a caseful copy of the local part from the
1287 original address. */
1289 if ((len = Ustrlen(address)) > 255) len = 255;
1290 ab.address = string_copyn(address, len);
1292 for (uschar * p = ab.address + len - 1; p >= ab.address; p--)
1294 if (!caseless && *p == '@') break;
1298 /* If expand_setup is zero, we need to set up $0 to the whole thing, in
1299 case there is a match. Can't use the built-in facilities of match_check_string
1300 (via check_address), as we may just be calling that for part of the address
1303 if (expand_setup == 0)
1305 expand_nstring[0] = string_copy(address);
1306 expand_nlength[0] = Ustrlen(address);
1310 /* Set up the data to be passed ultimately to check_address. */
1312 ab.origaddress = address;
1313 /* ab.address is above */
1314 ab.expand_setup = expand_setup;
1315 ab.caseless = caseless;
1317 return match_check_list(listptr, sep, &addresslist_anchor, &local_cache_bits,
1318 check_address, &ab, MCL_ADDRESS + (expand? 0:MCL_NOEXPAND), address,
1322 /* Simpler version of match_address_list; always caseless, expanding,
1323 no cache bits, no value-return.
1326 address address to test
1327 listptr list to check against
1328 sep separator character for the list;
1329 may be 0 to get separator from the list;
1330 may be UCHAR_MAX+1 for one-item list
1332 Returns: OK for a positive match, or end list after a negation;
1333 FAIL for a negative match, or end list after non-negation;
1334 DEFER if a lookup deferred
1338 match_address_list_basic(const uschar *address, const uschar **listptr, int sep)
1340 return match_address_list(address, TRUE, TRUE, listptr, NULL, -1, sep, NULL);
1343 /* End of match.c */