1 /*************************************************
2 * Exim - an Internet mail transport agent *
3 *************************************************/
5 /* Copyright (c) The Exim Maintainers 2020 - 2022 */
6 /* Copyright (c) University of Cambridge 1995 - 2018 */
7 /* See the file NOTICE for conditions of use and distribution. */
8 /* SPDX-License-Identifier: GPL-2.0-or-later */
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 const uschar *origsubject; /* caseful; keep these two first, in */
21 const uschar *subject; /* step with the block below */
23 mcs_flags flags; /* MCS_* defs in macros.h */
27 /* Argument block for the check_address() function. This is used for whole
30 typedef struct check_address_block {
31 const uschar *origaddress; /* caseful; keep these two first, in */
32 uschar *address; /* step with the block above */
34 mcs_flags flags; /* MCS_CASELESS, MCS_TEXTONLY_RE */
35 } check_address_block;
39 /*************************************************
40 * Generalized string match *
41 *************************************************/
43 /* This function does a single match of a subject against a pattern, and
44 optionally sets up the numeric variables according to what it matched. It is
45 called from match_isinlist() via match_check_list() when scanning a list, and
46 from match_check_string() when testing just a single item. The subject and
47 options arguments are passed in a check_string_block so as to make it easier to
48 pass them through match_check_list.
50 The possible types of pattern are:
52 . regular expression - starts with ^
53 . tail match - starts with *
54 . lookup - starts with search type
55 . if at_is_special is set in the argument block:
56 @ matches the primary host name
57 @[] matches a local IP address in brackets
58 @mx_any matches any domain with an MX to the local host
59 @mx_primary matches any domain with a primary MX to the local host
60 @mx_secondary matches any domain with a secondary MX to the local host
61 . literal - anything else
63 Any of the @mx_xxx options can be followed by "/ignore=<list>" where <list> is
64 a list of IP addresses that are to be ignored (typically 127.0.0.1).
67 arg check_string_block pointer - see below
68 pattern the pattern to be matched
69 valueptr if not NULL, and a lookup is done, return the result here
70 instead of discarding it; else set it to point to NULL
71 error for error messages (not used in this function; it never
74 Contents of the argument block:
75 origsubject the subject in its original casing
76 subject the subject string to be checked, lowercased if caseless
77 expand_setup if < 0, don't set up any numeric expansion variables;
78 if = 0, set $0 to whole subject, and either
79 $1 to what matches * or
80 $1, $2, ... to r.e. bracketed items
81 if > 0, don't set $0, but do set either
82 $n to what matches *, or
83 $n, $n+1, ... to r.e. bracketed items
84 (where n = expand_setup)
85 use_partial if FALSE, override any partial- search types
86 caseless TRUE for caseless matching where possible
87 at_is_special enable special handling of items starting with @
89 Returns: OK if matched
91 DEFER if lookup deferred
95 check_string(void * arg, const uschar * pattern, const uschar ** valueptr,
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 if (valueptr) *valueptr = NULL;
109 /* For regular expressions, use cb->origsubject rather than cb->subject so that
110 it works if the pattern uses (?-i) to turn off case-independence, overriding
113 s = string_copy(pattern[0] == '^' ? cb->origsubject : cb->subject);
115 /* If required to set up $0, initialize the data but don't turn on by setting
116 expand_nmax until the match is assured. */
119 if (expand_setup == 0)
121 expand_nstring[0] = s; /* $0 (might be) the matched subject in full */
122 expand_nlength[0] = Ustrlen(s);
124 else if (expand_setup > 0) expand_setup--;
126 /* Regular expression match: compile, match, and set up $ variables if
129 if (pattern[0] == '^')
131 const pcre2_code * re = regex_must_compile(pattern,
132 cb->flags & (MCS_CACHEABLE | MCS_CASELESS), FALSE);
134 ? !regex_match(re, s, -1, NULL)
135 : !regex_match_and_setup(re, s, 0, expand_setup)
138 if (valueptr) *valueptr = pattern; /* "value" gets the RE */
144 if (pattern[0] == '*')
146 int slen = Ustrlen(s);
147 int patlen; /* Sun compiler doesn't like non-constant initializer */
149 patlen = Ustrlen(++pattern);
150 if (patlen > slen) return FAIL;
151 if (cb->flags & MCS_CASELESS
152 ? strncmpic(s + slen - patlen, pattern, patlen) != 0
153 : Ustrncmp(s + slen - patlen, pattern, patlen) != 0)
155 if (expand_setup >= 0)
157 expand_nstring[++expand_setup] = s; /* write a $n, the matched subject variable-part */
158 expand_nlength[expand_setup] = slen - patlen;
159 expand_nmax = expand_setup; /* commit also $0, the matched subject */
161 if (valueptr) *valueptr = pattern - 1; /* "value" gets the (original) pattern */
165 /* Match a special item starting with @ if so enabled. On its own, "@" matches
166 the primary host name - implement this by changing the pattern. For the other
167 cases we have to do some more work. If we don't recognize a special pattern,
168 just fall through - the match will fail. */
170 if (cb->flags & MCS_AT_SPECIAL && pattern[0] == '@')
174 pattern = primary_hostname;
175 goto NOT_AT_SPECIAL; /* Handle as exact string match */
178 if (Ustrcmp(pattern, "@[]") == 0)
180 int slen = Ustrlen(s);
181 if (s[0] != '[' && s[slen-1] != ']') return FAIL; /*XXX should this be || ? */
182 for (ip_address_item * ip = host_find_interfaces(); ip; ip = ip->next)
183 if (Ustrncmp(ip->address, s+1, slen - 2) == 0
184 && ip->address[slen - 2] == 0)
186 if (expand_setup >= 0) expand_nmax = expand_setup; /* commit $0, the IP addr */
187 if (valueptr) *valueptr = pattern; /* "value" gets the pattern */
193 if (strncmpic(pattern, US"@mx_", 4) == 0)
199 BOOL removed = FALSE;
200 const uschar *ss = pattern + 4;
201 const uschar *ignore_target_hosts = NULL;
203 if (strncmpic(ss, US"any", 3) == 0) ss += 3;
204 else if (strncmpic(ss, US"primary", 7) == 0)
209 else if (strncmpic(ss, US"secondary", 9) == 0)
214 else goto NOT_AT_SPECIAL;
216 if (strncmpic(ss, US"/ignore=", 8) == 0) ignore_target_hosts = ss + 8;
217 else if (*ss) goto NOT_AT_SPECIAL;
223 rc = host_find_bydns(&h,
225 HOST_FIND_BY_MX, /* search only for MX, not SRV or A */
226 NULL, /* service name not relevant */
227 NULL, /* srv_fail_domains not relevant */
228 NULL, /* mx_fail_domains not relevant */
229 NULL, /* no dnssec request/require XXX ? */
230 NULL, /* no feedback FQDN */
231 &removed); /* feedback if local removed */
233 if (rc == HOST_FIND_AGAIN)
235 search_error_message = string_sprintf("DNS lookup of \"%s\" deferred", s);
239 if ((rc != HOST_FOUND_LOCAL || secy) && (prim || !removed))
242 if (expand_setup >= 0) expand_nmax = expand_setup; /* commit $0, the matched subject */
243 if (valueptr) *valueptr = pattern; /* "value" gets the patterm */
246 /*** The above line used to be the following line, but this is incorrect,
247 because host_find_bydns() may return HOST_NOT_FOUND if it removed some MX
248 hosts, but the remaining ones were non-existent. All we are interested in
249 is whether or not it removed some hosts.
251 return (rc == HOST_FOUND && removed)? OK : FAIL;
256 /* Escape point from code for specials that start with "@" */
260 /* This is an exact string match if there is no semicolon in the pattern. */
262 if ((semicolon = Ustrchr(pattern, ';')) == NULL)
264 if (cb->flags & MCS_CASELESS ? strcmpic(s, pattern) != 0 : Ustrcmp(s, pattern) != 0)
266 if (expand_setup >= 0) expand_nmax = expand_setup; /* $0 gets the matched subject */
267 if (valueptr) *valueptr = pattern; /* "value" gets the pattern */
271 /* Otherwise we have a lookup item. The lookup type, including partial, etc. is
272 the part of the string preceding the semicolon. */
275 search_type = search_findtype_partial(pattern, &partial, &affix, &affixlen,
278 if (search_type < 0) log_write(0, LOG_MAIN|LOG_PANIC_DIE, "%s",
279 search_error_message);
281 /* Partial matching is not appropriate for certain lookups (e.g. when looking
282 up user@domain for sender rejection). There's a flag to disable it. */
284 if (!(cb->flags & MCS_PARTIAL)) partial = -1;
286 /* Set the parameters for the three different kinds of lookup. */
288 keyquery = search_args(search_type, s, semicolon+1, &filename, opts);
290 /* Now do the actual lookup; throw away the data returned unless it was asked
291 for; partial matching is all handled inside search_find(). Note that there is
292 no search_close() because of the caching arrangements. */
294 if (!(handle = search_open(filename, search_type, 0, NULL, NULL)))
295 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "%s", search_error_message);
296 result = search_find(handle, filename, keyquery, partial, affix, affixlen,
297 starflags, &expand_setup, opts);
299 if (!result) return f.search_find_defer ? DEFER : FAIL;
300 if (valueptr) *valueptr = result;
302 expand_nmax = expand_setup;
308 /*************************************************
309 * Public interface to check_string() *
310 *************************************************/
312 /* This function is called from several places where is it most convenient to
313 pass the arguments individually. It places them in a check_string_block
314 structure, and then calls check_string().
317 s the subject string to be checked
318 pattern the pattern to check it against
319 expand_setup expansion setup option (see check_string())
321 use_partial if FALSE, override any partial- search types
322 caseless TRUE for caseless matching where possible
323 at_is_special TRUE to recognize @, @[], etc.
324 valueptr if not NULL, and a file lookup was done, return the result
325 here instead of discarding it; else set it to point to NULL
327 Returns: OK if matched
329 DEFER if lookup deferred
333 match_check_string(const uschar * s, const uschar * pattern, int expand_setup,
334 mcs_flags flags, const uschar ** valueptr)
336 check_string_block cb;
338 cb.subject = flags & MCS_CASELESS ? string_copylc(s) : string_copy(s);
339 cb.expand_setup = expand_setup;
341 return check_string(&cb, pattern, valueptr, NULL);
346 /*************************************************
347 * Get key string from check block *
348 *************************************************/
350 /* When caching the data from a lookup for a named list, we have to save the
351 key that was found, because other lookups of different keys on the same list
352 may occur. This function has knowledge of the different lookup types, and
353 extracts the appropriate key.
357 type MCL_STRING, MCL_DOMAIN, MCL_HOST, MCL_ADDRESS, or MCL_LOCALPART
360 static const uschar *
361 get_check_key(void *arg, int type)
367 case MCL_LOCALPART: return ((check_string_block *)arg)->subject;
368 case MCL_HOST: return ((check_host_block *)arg)->host_address;
369 case MCL_ADDRESS: return ((check_address_block *)arg)->address;
371 return US""; /* In practice, should never happen */
376 /*************************************************
377 * Scan list and run matching function *
378 *************************************************/
380 /* This function scans a list of patterns, and runs a matching function for
381 each item in the list. It is called from the functions that match domains,
382 local parts, hosts, and addresses, because its overall structure is the same in
383 all cases. However, the details of each particular match is different, so it
384 calls back to a given function do perform an actual match.
386 We can't quite keep the different types anonymous here because they permit
387 different special cases. A pity.
389 If a list item starts with !, that implies negation if the subject matches the
390 rest of the item (ignoring white space after the !). The result when the end of
391 the list is reached is FALSE unless the last item on the list is negated, in
392 which case it is TRUE. A file name in the list causes its lines to be
393 interpolated as if items in the list. An item starting with + is a named
394 sublist, obtained by searching the tree pointed to by anchorptr, with possible
395 cached match results in cache_bits.
398 listptr pointer to the pointer to the list
399 sep separator character for string_nextinlist();
400 normally zero for a standard list;
401 sometimes UCHAR_MAX+1 for single items;
402 anchorptr -> tree of named items, or NULL if no named items
403 cache_ptr pointer to pointer to cache bits for named items, or
404 pointer to NULL if not caching; may get set NULL if an
405 uncacheable named list is encountered
406 func function to call back to do one test
407 arg pointer to pass to the function; the string to be matched is
408 in the structure it points to
409 type MCL_STRING, MCL_DOMAIN, MCL_HOST, MCL_ADDRESS, or MCL_LOCALPART
410 these are used for some special handling
411 MCL_NOEXPAND (whose value is greater than any of them) may
412 be added to any value to suppress expansion of the list
413 name string to use in debugging info
414 valueptr where to pass back data from a lookup
416 Returns: OK if matched a non-negated item
417 OK if hit end of list after a negated item
418 FAIL if expansion force-failed
419 FAIL if matched a negated item
420 FAIL if hit end of list after a non-negated item
421 DEFER if a something deferred or expansion failed
425 match_check_list(const uschar **listptr, int sep, tree_node **anchorptr,
426 unsigned int **cache_ptr, int (*func)(void *,const uschar *,const uschar **,uschar **),
427 void *arg, int type, const uschar *name, const uschar **valueptr)
430 unsigned int * original_cache_bits = *cache_ptr;
431 BOOL include_unknown = FALSE, ignore_unknown = FALSE,
432 include_defer = FALSE, ignore_defer = FALSE;
438 /* Save time by not scanning for the option name when we don't need it. */
442 uschar * listname = readconf_find_option(listptr);
443 if (*listname) ot = string_sprintf("%s in %s?", name, listname);
446 /* If the list is empty, the answer is no. Skip the debugging output for
451 HDEBUG(D_lists) if (ot) debug_printf_indent("%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 */
468 /* If we are searching a domain list, and $domain is not set, set it to the
469 subject that is being sought for the duration of the expansion. */
471 if (type == MCL_DOMAIN && !deliver_domain)
473 check_string_block *cb = (check_string_block *)arg;
474 deliver_domain = string_copy(cb->subject);
475 list = expand_string_2(*listptr, &textonly_re);
476 deliver_domain = NULL;
479 list = expand_string_2(*listptr, &textonly_re);
483 if (f.expand_string_forcedfail)
485 HDEBUG(D_lists) debug_printf_indent("expansion of \"%s\" forced failure: "
486 "assume not in this list\n", *listptr);
489 log_write(0, LOG_MAIN|LOG_PANIC, "failed to expand \"%s\" while checking "
490 "a list: %s", *listptr, expand_string_message);
495 if (textonly_re) switch (type)
499 case MCL_LOCALPART: ((check_string_block *)arg)->flags |= MCS_CACHEABLE; break;
500 case MCL_HOST: ((check_host_block *)arg)->flags |= MCS_CACHEABLE; break;
501 case MCL_ADDRESS: ((check_address_block *)arg)->flags |= MCS_CACHEABLE; break;
504 /* For an unnamed list, use the expanded version in comments */
505 #define LIST_LIMIT_PR 2048
507 HDEBUG(D_any) if (!ot)
510 gstring * g = string_fmt_append(NULL, "%s in \"%n%.*s%n\"",
511 name, &n, LIST_LIMIT_PR, list, &m);
512 if (m - n >= LIST_LIMIT_PR) g = string_catn(g, US"...", 3);
513 g = string_catn(g, US"?", 1);
514 gstring_release_unused(g);
515 ot = string_from_gstring(g);
518 /* Now scan the list and process each item in turn, until one of them matches,
519 or we hit an error. */
521 while ((sss = string_nextinlist(&list, &sep, NULL, 0)))
525 /* Address lists may contain +caseful, to restore caseful matching of the
526 local part. We have to know the layout of the control block, unfortunately.
527 The lower cased address is in a temporary buffer, so we just copy the local
528 part back to the start of it (if a local part exists). */
530 if (type == MCL_ADDRESS)
532 if (Ustrcmp(ss, "+caseful") == 0)
534 check_address_block *cb = (check_address_block *)arg;
535 uschar *at = Ustrrchr(cb->origaddress, '@');
538 Ustrncpy(cb->address, cb->origaddress, at - cb->origaddress);
539 cb->flags &= ~MCS_CASELESS;
544 /* Similar processing for local parts */
546 else if (type == MCL_LOCALPART)
548 if (Ustrcmp(ss, "+caseful") == 0)
550 check_string_block *cb = (check_string_block *)arg;
551 Ustrcpy(US cb->subject, cb->origsubject);
552 cb->flags &= ~MCS_CASELESS;
557 /* If the host item is "+include_unknown" or "+ignore_unknown", remember it
558 in case there's a subsequent failed reverse lookup. There is similar
559 processing for "defer". */
561 else if (type == MCL_HOST && *ss == '+')
563 if (Ustrcmp(ss, "+include_unknown") == 0)
565 include_unknown = TRUE;
566 ignore_unknown = FALSE;
569 if (Ustrcmp(ss, "+ignore_unknown") == 0)
571 ignore_unknown = TRUE;
572 include_unknown = FALSE;
575 if (Ustrcmp(ss, "+include_defer") == 0)
577 include_defer = TRUE;
578 ignore_defer = FALSE;
581 if (Ustrcmp(ss, "+ignore_defer") == 0)
584 include_defer = FALSE;
589 /* Starting with ! specifies a negative item. It is theoretically possible
590 for a local part to start with !. In that case, a regex has to be used. */
595 while (isspace((*(++ss))));
600 /* If the item does not begin with '/', it might be a + item for a named
601 list. Otherwise, it is just a single list entry that has to be matched.
602 We recognize '+' only when supplied with a tree of named lists. */
606 if (*ss == '+' && anchorptr)
611 unsigned int *use_cache_bits = original_cache_bits;
612 uschar *cached = US"";
616 if (!(t = tree_search(*anchorptr, ss+1)))
618 log_write(0, LOG_MAIN|LOG_PANIC, "unknown named%s list \"%s\"",
619 type == MCL_DOMAIN ? " domain" :
620 type == MCL_HOST ? " host" :
621 type == MCL_ADDRESS ? " address" :
622 type == MCL_LOCALPART ? " local part" : "",
628 /* If the list number is negative, it means that this list is not
629 cacheable because it contains expansion items. */
631 if (nb->number < 0) use_cache_bits = NULL;
633 /* If we have got a cache pointer, get the bits. This is not an "else"
634 because the pointer may be NULL from the start if caching is not
639 offset = (nb->number)/16;
640 shift = ((nb->number)%16)*2;
641 bits = use_cache_bits[offset] & (3 << shift);
644 /* Not previously tested or no cache - run the full test */
648 switch (match_check_list(&(nb->string), 0, anchorptr, &use_cache_bits,
649 func, arg, type, name, valueptr))
651 case OK: bits = 1; break;
652 case FAIL: bits = 3; break;
653 case DEFER: goto DEFER_RETURN;
656 /* If this list was uncacheable, or a sublist turned out to be
657 uncacheable, the value of use_cache_bits will now be NULL, even if it
658 wasn't before. Ensure that this is passed up to the next level.
659 Otherwise, remember the result of the search in the cache. */
665 use_cache_bits[offset] |= bits << shift;
669 int old_pool = store_pool;
670 namedlist_cacheblock *p;
672 /* Cached data for hosts persists over more than one message,
673 so we use the permanent store pool */
675 store_pool = POOL_PERM;
676 p = store_get(sizeof(namedlist_cacheblock), GET_UNTAINTED);
677 p->key = string_copy(get_check_key(arg, type));
680 p->data = *valueptr ? string_copy(*valueptr) : NULL;
681 store_pool = old_pool;
683 p->next = nb->cache_data;
686 DEBUG(D_lists) debug_printf_indent("data from lookup saved for "
687 "cache for %s: key '%s' value '%s'\n", ss, p->key, *valueptr);
692 /* Previously cached; to find a lookup value, search a chain of values
693 and compare keys. Typically, there is only one such, but it is possible
694 for different keys to have matched the same named list. */
698 DEBUG(D_lists) debug_printf_indent("cached %s match for %s\n",
699 (bits & (-bits)) == bits ? "yes" : "no", ss);
701 cached = US" - cached";
704 const uschar *key = get_check_key(arg, type);
706 for (namedlist_cacheblock * p = nb->cache_data; p; p = p->next)
707 if (Ustrcmp(key, p->key) == 0)
712 DEBUG(D_lists) debug_printf_indent("cached lookup data = %s\n", *valueptr);
716 /* Result of test is indicated by value in bits. For each test, we
717 have 00 => untested, 01 => tested yes, 11 => tested no. */
719 if ((bits & (-bits)) == bits) /* Only one of the two bits is set */
721 HDEBUG(D_lists) debug_printf_indent("%s %s (matched \"%s\"%s)\n", ot,
722 yield == OK ? "yes" : "no", sss, cached);
727 /* Run the provided function to do the individual test. */
731 uschar * error = NULL;
732 switch ((func)(arg, ss, valueptr, &error))
735 HDEBUG(D_lists) debug_printf_indent("%s %s (matched \"%s\")\n", ot,
736 (yield == OK)? "yes" : "no", sss);
741 error = string_sprintf("DNS lookup of \"%s\" deferred", ss);
744 HDEBUG(D_lists) debug_printf_indent("%s: item ignored by +ignore_defer\n",
750 log_write(0, LOG_MAIN, "%s: accepted by +include_defer", error);
753 if (!search_error_message) search_error_message = error;
756 /* The ERROR return occurs when checking hosts, when either a forward
757 or reverse lookup has failed. It can also occur in a match_ip list if a
758 non-IP address item is encountered. The error string gives details of
764 HDEBUG(D_lists) debug_printf_indent("%s: item ignored by +ignore_unknown\n",
769 HDEBUG(D_lists) debug_printf_indent("%s %s (%s)\n", ot,
770 include_unknown? "yes":"no", error);
771 if (!include_unknown)
773 if (LOGGING(unknown_in_list))
774 log_write(0, LOG_MAIN, "list matching forced to fail: %s", error);
777 log_write(0, LOG_MAIN, "%s: accepted by +include_unknown", error);
784 /* If the item is a file name, we read the file and do a match attempt
785 on each line in the file, including possibly more negation processing. */
789 int file_yield = yield; /* In case empty file */
790 uschar * filename = ss;
791 FILE * f = Ufopen(filename, "rb");
792 uschar filebuffer[1024];
794 /* ot will be null in non-debugging cases, and anyway, we get better
795 wording by reworking it. */
799 uschar * listname = readconf_find_option(listptr);
800 if (listname[0] == 0)
801 listname = string_sprintf("\"%s\"", *listptr);
802 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "%s",
803 string_open_failed("%s when checking %s", sss, listname));
806 /* Trailing comments are introduced by #, but in an address list or local
807 part list, the # must be preceded by white space or the start of the line,
808 because the # character is a legal character in local parts. */
810 while (Ufgets(filebuffer, sizeof(filebuffer), f) != NULL)
813 uschar *sss = filebuffer;
815 while ((ss = Ustrchr(sss, '#')) != NULL)
817 if ((type != MCL_ADDRESS && type != MCL_LOCALPART) ||
818 ss == filebuffer || isspace(ss[-1]))
826 ss = filebuffer + Ustrlen(filebuffer); /* trailing space */
827 while (ss > filebuffer && isspace(ss[-1])) ss--;
831 while (isspace(*ss)) ss++; /* leading space */
833 if (!*ss) continue; /* ignore empty */
835 file_yield = yield; /* positive yield */
836 sss = ss; /* for debugging */
838 if (*ss == '!') /* negation */
840 file_yield = (file_yield == OK)? FAIL : OK;
841 while (isspace((*(++ss))));
844 switch ((func)(arg, ss, valueptr, &error))
848 HDEBUG(D_lists) debug_printf_indent("%s %s (matched \"%s\" in %s)\n", ot,
849 yield == OK ? "yes" : "no", sss, filename);
851 /* The "pattern" being matched came from the file; we use a stack-local.
852 Copy it to allocated memory now we know it matched. */
854 if (valueptr) *valueptr = string_copy(ss);
859 error = string_sprintf("DNS lookup of %s deferred", ss);
862 HDEBUG(D_lists) debug_printf_indent("%s: item ignored by +ignore_defer\n",
869 log_write(0, LOG_MAIN, "%s: accepted by +include_defer", error);
874 case ERROR: /* host name lookup failed - this can only */
875 if (ignore_unknown) /* be for an incoming host (not outgoing) */
877 HDEBUG(D_lists) debug_printf_indent("%s: item ignored by +ignore_unknown\n",
882 HDEBUG(D_lists) debug_printf_indent("%s %s (%s)\n", ot,
883 include_unknown? "yes":"no", error);
885 if (!include_unknown)
887 if (LOGGING(unknown_in_list))
888 log_write(0, LOG_MAIN, "list matching forced to fail: %s", error);
891 log_write(0, LOG_MAIN, "%s: accepted by +include_unknown", error);
897 /* At the end of the file, leave the yield setting at the final setting
898 for the file, in case this is the last item in the list. */
903 } /* Loop for the next item on the top-level list */
905 /* End of list reached: if the last item was negated yield OK, else FAIL. */
908 debug_printf_indent("%s %s (end of list)\n", ot, yield == OK ? "no":"yes");
909 return yield == OK ? FAIL : OK;
911 /* Something deferred */
914 HDEBUG(D_lists) debug_printf("%s list match deferred for %s\n", ot, sss);
919 /*************************************************
920 * Match in colon-separated list *
921 *************************************************/
923 /* This function is used for domain lists and local part lists. It is not used
924 for host lists or address lists, which have additional interpretation of the
925 patterns. Some calls of it set sep > UCHAR_MAX in order to use its matching
926 facilities on single items. When this is done, it arranges to set the numerical
927 variables as a result of the match.
929 This function is now just a short interface to match_check_list(), which does
930 list scanning in a general way. A good compiler will optimize the tail
934 s string to search for
935 listptr ptr to ptr to colon separated list of patterns, or NULL
936 sep a separator value for the list (see string_nextinlist())
937 anchorptr ptr to tree for named items, or NULL if no named items
938 cache_bits ptr to cache_bits for ditto, or NULL if not caching
939 type MCL_DOMAIN when matching a domain list
940 MCL_LOCALPART when matching a local part list (address lists
941 have their own function)
942 MCL_STRING for others (e.g. list of ciphers)
943 MCL_NOEXPAND (whose value is greater than any of them) may
944 be added to any value to suppress expansion of the list
945 caseless TRUE for (mostly) caseless matching - passed directly to
947 valueptr pointer to where any lookup data is to be passed back,
948 or NULL (just passed on to match_check_string)
950 Returns: OK if matched a non-negated item
951 OK if hit end of list after a negated item
952 FAIL if expansion force-failed
953 FAIL if matched a negated item
954 FAIL if hit end of list after a non-negated item
955 DEFER if a lookup deferred
959 match_isinlist(const uschar *s, const uschar **listptr, int sep,
960 tree_node **anchorptr,
961 unsigned int *cache_bits, int type, BOOL caseless, const uschar **valueptr)
963 unsigned int *local_cache_bits = cache_bits;
964 check_string_block cb;
966 cb.subject = caseless ? string_copylc(s) : string_copy(s);
967 cb.flags = caseless ? MCS_PARTIAL+MCS_CASELESS : MCS_PARTIAL;
968 switch (type & ~MCL_NOEXPAND)
970 case MCL_DOMAIN: cb.flags |= MCS_AT_SPECIAL; /*FALLTHROUGH*/
971 case MCL_LOCALPART: cb.expand_setup = 0; break;
972 default: cb.expand_setup = sep > UCHAR_MAX ? 0 : -1; break;
974 if (valueptr) *valueptr = NULL;
975 return match_check_list(listptr, sep, anchorptr, &local_cache_bits,
976 check_string, &cb, type, s, valueptr);
981 /*************************************************
982 * Match address to single address-list item *
983 *************************************************/
985 /* This function matches an address to an item from an address list. It is
986 called from match_address_list() via match_check_list(). That is why most of
987 its arguments are in an indirect block.
990 arg the argument block (see below)
991 pattern the pattern to match
992 valueptr where to return a value
993 error for error messages (not used in this function; it never
996 The argument block contains:
997 address the start of the subject address; when called from retry.c
998 it may be *@domain if the local part isn't relevant
999 origaddress the original, un-case-forced address (not used here, but used
1000 in match_check_list() when +caseful is encountered)
1001 expand_setup controls setting up of $n variables
1002 caseless TRUE for caseless local part matching
1004 Returns: OK for a match
1006 DEFER if a lookup deferred
1010 check_address(void * arg, const uschar * pattern, const uschar ** valueptr,
1013 check_address_block * cb = (check_address_block *)arg;
1014 check_string_block csb;
1017 unsigned int * null = NULL;
1018 const uschar * listptr;
1019 uschar * subject = cb->address;
1021 uschar * pdomain, * sdomain;
1022 uschar * value = NULL;
1024 DEBUG(D_lists) debug_printf_indent("address match test: subject=%s pattern=%s\n",
1027 /* Find the subject's domain */
1029 sdomain = Ustrrchr(subject, '@');
1031 /* The only case where a subject may not have a domain is if the subject is
1032 empty. Otherwise, a subject with no domain is a serious configuration error. */
1034 if (!sdomain && *subject)
1036 log_write(0, LOG_MAIN|LOG_PANIC, "no @ found in the subject of an "
1037 "address list match: subject=\"%s\" pattern=\"%s\"", subject, pattern);
1041 /* Handle a regular expression, which must match the entire incoming address.
1042 This may be the empty address. */
1044 if (*pattern == '^')
1045 return match_check_string(subject, pattern, cb->expand_setup,
1046 cb->flags | MCS_PARTIAL, NULL);
1048 /* Handle a pattern that is just a lookup. Skip over possible lookup names
1049 (letters, digits, hyphens). Skip over a possible * or *@ at the end. Then we
1050 must have a semicolon for it to be a lookup. */
1052 for (s = pattern; isalnum(*s) || *s == '-'; s++) ;
1056 /* If it is a straight lookup, do a lookup for the whole address. This may be
1057 the empty address. Partial matching doesn't make sense here, so we ignore it,
1058 but write a panic log entry. However, *@ matching will be honoured. */
1062 if (Ustrncmp(pattern, "partial-", 8) == 0)
1063 log_write(0, LOG_MAIN|LOG_PANIC, "partial matching is not applicable to "
1064 "whole-address lookups: ignored \"partial-\" in \"%s\"", pattern);
1065 return match_check_string(subject, pattern, -1, cb->flags, valueptr);
1068 /* For the remaining cases, an empty subject matches only an empty pattern,
1069 because other patterns expect to have a local part and a domain to match
1072 if (!*subject) return *pattern ? FAIL : OK;
1074 /* If the pattern starts with "@@" we have a split lookup, where the domain is
1075 looked up to obtain a list of local parts. If the subject's local part is just
1076 "*" (called from retry) the match always fails. */
1078 if (pattern[0] == '@' && pattern[1] == '@')
1083 if (sdomain == subject + 1 && *subject == '*') return FAIL;
1085 /* Loop for handling chains. The last item in any list may be of the form
1086 ">name" in order to chain on to another list. */
1088 for (const uschar * key = sdomain + 1; key && watchdog-- > 0; )
1092 if ((rc = match_check_string(key, pattern + 2, -1, MCS_PARTIAL, CUSS &list))
1096 /* Check for chaining from the last item; set up the next key if one
1099 ss = Ustrrchr(list, ':');
1100 if (!ss) ss = list; else ss++;
1101 Uskip_whitespace(&ss);
1105 Uskip_whitespace(&ss);
1106 key = string_copy(ss);
1110 /* Look up the local parts provided by the list; negation is permitted.
1111 If a local part has to begin with !, a regex can be used. */
1113 while ((ss = string_nextinlist(CUSS &list, &sep, NULL, 0)))
1120 while (isspace((*(++ss))));
1122 else local_yield = OK;
1125 rc = match_check_string(subject, ss, -1, cb->flags + MCS_PARTIAL, valueptr);
1139 /* End of chain loop; panic if too many times */
1142 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "Loop detected in lookup of "
1143 "local part of %s in %s", subject, pattern);
1145 /* Otherwise the local part check has failed, so the whole match
1152 /* We get here if the pattern is not a lookup or a regular expression. If it
1153 contains an @ there is both a local part and a domain. */
1155 if ((pdomain = Ustrrchr(pattern, '@')))
1159 /* If the domain in the pattern is empty or one of the special cases [] or
1160 mx_{any,primary,secondary}, and the local part in the pattern ends in "@",
1161 we have a pattern of the form <something>@@, <something>@@[], or
1162 <something>@@mx_{any,primary,secondary}. These magic "domains" are
1163 automatically interpreted in match_check_string. We just need to arrange that
1164 the leading @ is included in the domain. */
1166 if (pdomain > pattern && pdomain[-1] == '@' &&
1168 Ustrcmp(pdomain+1, "[]") == 0 ||
1169 Ustrcmp(pdomain+1, "mx_any") == 0 ||
1170 Ustrcmp(pdomain+1, "mx_primary") == 0 ||
1171 Ustrcmp(pdomain+1, "mx_secondary") == 0))
1174 pllen = pdomain - pattern;
1175 sllen = sdomain - subject;
1177 /* Compare the local parts in the subject and the pattern */
1179 if (*pattern == '*')
1181 int cllen = pllen - 1;
1182 if (sllen < cllen) return FAIL;
1183 if (cb->flags & MCS_CASELESS
1184 ? strncmpic(subject+sllen-cllen, pattern + 1, cllen) != 0
1185 : Ustrncmp(subject+sllen-cllen, pattern + 1, cllen) != 0)
1187 if (cb->expand_setup > 0)
1189 expand_nstring[cb->expand_setup] = subject;
1190 expand_nlength[cb->expand_setup] = sllen - cllen;
1193 value = string_copyn(pattern + 1, cllen);
1197 if (sllen != pllen) return FAIL;
1198 if (cb->flags & MCS_CASELESS
1199 ? strncmpic(subject, pattern, sllen) != 0
1200 : Ustrncmp(subject, pattern, sllen) != 0) return FAIL;
1202 value = string_copyn(pattern, sllen);
1205 /* If the local part matched, or was not being checked, check the domain using
1206 the generalized function, which supports file lookups (which may defer). The
1207 original code read as follows:
1209 return match_check_string(sdomain + 1,
1210 pdomain ? pdomain + 1 : pattern,
1211 cb->expand_setup + expand_inc, cb->flags, NULL);
1213 This supported only literal domains and *.x.y patterns. In order to allow for
1214 named domain lists (so that you can write, for example, "senders=+xxxx"), it
1215 was changed to use the list scanning function. */
1217 csb.origsubject = sdomain + 1;
1218 csb.subject = cb->flags & MCS_CASELESS
1219 ? string_copylc(sdomain+1) : string_copy(sdomain+1);
1220 csb.expand_setup = cb->expand_setup + expand_inc;
1221 csb.flags = MCS_PARTIAL | MCS_AT_SPECIAL | cb->flags & MCS_CASELESS;
1223 listptr = pdomain ? pdomain + 1 : pattern;
1224 if (valueptr) *valueptr = NULL;
1227 const uschar * dvalue = NULL;
1228 rc = match_check_list(
1229 &listptr, /* list of one item */
1230 UCHAR_MAX+1, /* impossible separator; single item */
1231 &domainlist_anchor, /* it's a domain list */
1232 &null, /* ptr to NULL means no caching */
1233 check_string, /* the function to do one test */
1234 &csb, /* its data */
1235 MCL_DOMAIN + MCL_NOEXPAND, /* domain list; don't expand */
1236 csb.subject, /* string for messages */
1237 &dvalue); /* where to pass back lookup data */
1238 if (valueptr && (value || dvalue))
1239 *valueptr = string_sprintf("%s@%s",
1240 value ? value : US"", dvalue ? dvalue : US"");
1248 /*************************************************
1249 * Test whether address matches address list *
1250 *************************************************/
1252 /* This function is given an address and a list of things to match it against.
1253 The list may contain individual addresses, regular expressions, lookup
1254 specifications, and indirection via bare files. Negation is supported. The
1255 address to check can consist of just a domain, which will then match only
1256 domain items or items specified as *@domain.
1258 Domains are always lower cased before the match. Local parts are also lower
1259 cased unless "caseless" is false. The work of actually scanning the list is
1260 done by match_check_list(), with an appropriate block of arguments and a
1261 callback to check_address(). During caseless matching, it will recognize
1262 +caseful and revert to caseful matching.
1265 address address to test
1266 caseless TRUE to start in caseless state
1267 expand TRUE to allow list expansion
1268 listptr list to check against
1269 cache_bits points to cache bits for named address lists, or NULL
1270 expand_setup controls setting up of $n variables - passed through
1271 to check_address (q.v.)
1272 sep separator character for the list;
1273 may be 0 to get separator from the list;
1274 may be UCHAR_MAX+1 for one-item list
1275 valueptr where to return a lookup value, or NULL
1277 Returns: OK for a positive match, or end list after a negation;
1278 FAIL for a negative match, or end list after non-negation;
1279 DEFER if a lookup deferred
1283 match_address_list(const uschar *address, BOOL caseless, BOOL expand,
1284 const uschar **listptr, unsigned int *cache_bits, int expand_setup, int sep,
1285 const uschar **valueptr)
1287 check_address_block ab;
1288 unsigned int *local_cache_bits = cache_bits;
1291 /* RFC 2505 recommends that for spam checking, local parts should be caselessly
1292 compared. Therefore, Exim now forces the entire address into lower case here,
1293 provided that "caseless" is set. (It is FALSE for calls for matching rewriting
1294 patterns.) Otherwise just the domain is lower cases. A magic item "+caseful" in
1295 the list can be used to restore a caseful copy of the local part from the
1297 Limit the subject address size to avoid mem-exhaustion attacks. The size chosen
1298 is historical (we used to use big_buffer here). */
1300 if ((len = Ustrlen(address)) > BIG_BUFFER_SIZE) len = BIG_BUFFER_SIZE;
1301 ab.address = string_copyn(address, len);
1303 for (uschar * p = ab.address + len - 1; p >= ab.address; p--)
1305 if (!caseless && *p == '@') break;
1309 /* If expand_setup is zero, we need to set up $0 to the whole thing, in
1310 case there is a match. Can't use the built-in facilities of match_check_string
1311 (via check_address), as we may just be calling that for part of the address
1314 if (expand_setup == 0)
1316 expand_nstring[0] = string_copy(address);
1317 expand_nlength[0] = Ustrlen(address);
1321 /* Set up the data to be passed ultimately to check_address. */
1323 ab.origaddress = address;
1324 /* ab.address is above */
1325 ab.expand_setup = expand_setup;
1326 ab.flags = caseless ? MCS_CASELESS : 0;
1328 return match_check_list(listptr, sep, &addresslist_anchor, &local_cache_bits,
1329 check_address, &ab, MCL_ADDRESS + (expand ? 0 : MCL_NOEXPAND), address,
1333 /* Simpler version of match_address_list; always caseless, expanding,
1334 no cache bits, no value-return.
1337 address address to test
1338 listptr list to check against
1339 sep separator character for the list;
1340 may be 0 to get separator from the list;
1341 may be UCHAR_MAX+1 for one-item list
1343 Returns: OK for a positive match, or end list after a negation;
1344 FAIL for a negative match, or end list after non-negation;
1345 DEFER if a lookup deferred
1349 match_address_list_basic(const uschar *address, const uschar **listptr, int sep)
1351 return match_address_list(address, TRUE, TRUE, listptr, NULL, -1, sep, NULL);
1354 /* End of match.c */