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; /* $0 (might be) the matched subject in full */
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);
135 ? pcre_exec(re, NULL, CCS s, Ustrlen(s), 0, PCRE_EOPT, NULL, 0) < 0
136 : !regex_match_and_setup(re, s, 0, expand_setup)
139 /* assume the above wrote $0, $n... TODO: CHECK THAT !! */
140 if (valueptr) *valueptr = pattern; /* "value" gets the RE */
146 if (pattern[0] == '*')
148 int slen = Ustrlen(s);
149 int patlen; /* Sun compiler doesn't like non-constant initializer */
151 patlen = Ustrlen(++pattern);
152 if (patlen > slen) return FAIL;
154 ? strncmpic(s + slen - patlen, pattern, patlen) != 0
155 : Ustrncmp(s + slen - patlen, pattern, patlen) != 0)
157 if (expand_setup >= 0)
159 expand_nstring[++expand_setup] = s; /* write a $n, the matched subject variable-part */
160 expand_nlength[expand_setup] = slen - patlen;
161 expand_nmax = expand_setup;
163 if (valueptr) *valueptr = pattern; /* "value" gets the pattern */
167 /* Match a special item starting with @ if so enabled. On its own, "@" matches
168 the primary host name - implement this by changing the pattern. For the other
169 cases we have to do some more work. If we don't recognize a special pattern,
170 just fall through - the match will fail. */
172 if (cb->at_is_special && pattern[0] == '@')
176 pattern = primary_hostname;
177 goto NOT_AT_SPECIAL; /* Handle as exact string match */
180 if (Ustrcmp(pattern, "@[]") == 0)
182 int slen = Ustrlen(s);
183 if (s[0] != '[' && s[slen-1] != ']') return FAIL; /*XXX should this be || ? */
184 for (ip_address_item * ip = host_find_interfaces(); ip; ip = ip->next)
185 if (Ustrncmp(ip->address, s+1, slen - 2) == 0
186 && ip->address[slen - 2] == 0)
188 /* I see no reason not to return $0, the matchd IP. if (expand_setup >= 0) expand_nmax = expand_setup; */
189 if (valueptr) *valueptr = pattern; /* "value" gets the pattern */
195 if (strncmpic(pattern, US"@mx_", 4) == 0)
201 BOOL removed = FALSE;
202 const uschar *ss = pattern + 4;
203 const uschar *ignore_target_hosts = NULL;
205 if (strncmpic(ss, US"any", 3) == 0) ss += 3;
206 else if (strncmpic(ss, US"primary", 7) == 0)
211 else if (strncmpic(ss, US"secondary", 9) == 0)
216 else goto NOT_AT_SPECIAL;
218 if (strncmpic(ss, US"/ignore=", 8) == 0) ignore_target_hosts = ss + 8;
219 else if (*ss) goto NOT_AT_SPECIAL;
225 rc = host_find_bydns(&h,
227 HOST_FIND_BY_MX, /* search only for MX, not SRV or A */
228 NULL, /* service name not relevant */
229 NULL, /* srv_fail_domains not relevant */
230 NULL, /* mx_fail_domains not relevant */
231 NULL, /* no dnssec request/require XXX ? */
232 NULL, /* no feedback FQDN */
233 &removed); /* feedback if local removed */
235 if (rc == HOST_FIND_AGAIN)
237 search_error_message = string_sprintf("DNS lookup of \"%s\" deferred", s);
241 if (rc != HOST_FOUND_LOCAL || secy)
242 if (prim || !removed) return FAIL;
244 /* again, $0 getting the subject, the matched IP. if (expand_setup >= 0) expand_nmax = expand_setup; */
245 if (valueptr) *valueptr = pattern; /* "vaulue" gets the patterm */
248 /*** The above line used to be the following line, but this is incorrect,
249 because host_find_bydns() may return HOST_NOT_FOUND if it removed some MX
250 hosts, but the remaining ones were non-existent. All we are interested in
251 is whether or not it removed some hosts.
253 return (rc == HOST_FOUND && removed)? OK : FAIL;
258 /* Escape point from code for specials that start with "@" */
262 /* This is an exact string match if there is no semicolon in the pattern. */
264 if ((semicolon = Ustrchr(pattern, ';')) == NULL)
266 if (cb->caseless ? strcmpic(s, pattern) != 0 : Ustrcmp(s, pattern) != 0)
268 if (expand_setup >= 0) expand_nmax = expand_setup; /* Original code! $0 gets the matched subject */
269 if (valueptr) *valueptr = pattern; /* "value" gets the pattern */
273 XXX looks like $0 may be usable
274 XXX could add setting of *valueptr to all the OK returns; seems doable here, the Q
275 is: what effect would it have at config-file level. domain_data & local_part_data
276 would get filled in... might anyone be checking it for emptiness? I think the docs
277 do not say "will be empty otherwise", so that seems ok.
278 XXX WORRY: we get new caching of named-list match results. Is that cache checked
279 for the key being matched?
283 /* Otherwise we have a lookup item. The lookup type, including partial, etc. is
284 the part of the string preceding the semicolon. */
287 search_type = search_findtype_partial(pattern, &partial, &affix, &affixlen,
290 if (search_type < 0) log_write(0, LOG_MAIN|LOG_PANIC_DIE, "%s",
291 search_error_message);
293 /* Partial matching is not appropriate for certain lookups (e.g. when looking
294 up user@domain for sender rejection). There's a flag to disable it. */
296 if (!cb->use_partial) partial = -1;
298 /* Set the parameters for the three different kinds of lookup. */
300 keyquery = semicolon + 1;
301 Uskip_whitespace(&keyquery);
303 if (mac_islookup(search_type, lookup_absfilequery))
306 while (*keyquery && !isspace(*keyquery)) keyquery++;
307 filename = string_copyn(filename, keyquery - filename);
308 Uskip_whitespace(&keyquery);
311 else if (!mac_islookup(search_type, lookup_querystyle))
317 /* Now do the actual lookup; throw away the data returned unless it was asked
318 for; partial matching is all handled inside search_find(). Note that there is
319 no search_close() because of the caching arrangements. */
321 if (!(handle = search_open(filename, search_type, 0, NULL, NULL)))
322 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "%s", search_error_message);
323 result = search_find(handle, filename, keyquery, partial, affix, affixlen,
324 starflags, &expand_setup, opts);
326 if (!result) return f.search_find_defer ? DEFER : FAIL;
327 if (valueptr) *valueptr = result;
329 expand_nmax = expand_setup;
335 /*************************************************
336 * Public interface to check_string() *
337 *************************************************/
339 /* This function is called from several places where is it most convenient to
340 pass the arguments individually. It places them in a check_string_block
341 structure, and then calls check_string().
344 s the subject string to be checked
345 pattern the pattern to check it against
346 expand_setup expansion setup option (see check_string())
347 use_partial if FALSE, override any partial- search types
348 caseless TRUE for caseless matching where possible
349 at_is_special TRUE to recognize @, @[], etc.
350 valueptr if not NULL, and a file lookup was done, return the result
351 here instead of discarding it; else set it to point to NULL
353 Returns: OK if matched
355 DEFER if lookup deferred
359 match_check_string(const uschar *s, const uschar *pattern, int expand_setup,
360 BOOL use_partial, BOOL caseless, BOOL at_is_special, const uschar **valueptr)
362 check_string_block cb;
364 cb.subject = caseless? string_copylc(s) : string_copy(s);
365 cb.expand_setup = expand_setup;
366 cb.use_partial = use_partial;
367 cb.caseless = caseless;
368 cb.at_is_special = at_is_special;
369 return check_string(&cb, pattern, valueptr, NULL);
374 /*************************************************
375 * Get key string from check block *
376 *************************************************/
378 /* When caching the data from a lookup for a named list, we have to save the
379 key that was found, because other lookups of different keys on the same list
380 may occur. This function has knowledge of the different lookup types, and
381 extracts the appropriate key.
385 type MCL_STRING, MCL_DOMAIN, MCL_HOST, MCL_ADDRESS, or MCL_LOCALPART
388 static const uschar *
389 get_check_key(void *arg, int type)
396 return ((check_string_block *)arg)->subject;
399 return ((check_host_block *)arg)->host_address;
402 return ((check_address_block *)arg)->address;
404 return US""; /* In practice, should never happen */
409 /*************************************************
410 * Scan list and run matching function *
411 *************************************************/
413 /* This function scans a list of patterns, and runs a matching function for
414 each item in the list. It is called from the functions that match domains,
415 local parts, hosts, and addresses, because its overall structure is the same in
416 all cases. However, the details of each particular match is different, so it
417 calls back to a given function do perform an actual match.
419 We can't quite keep the different types anonymous here because they permit
420 different special cases. A pity.
422 If a list item starts with !, that implies negation if the subject matches the
423 rest of the item (ignoring white space after the !). The result when the end of
424 the list is reached is FALSE unless the last item on the list is negated, in
425 which case it is TRUE. A file name in the list causes its lines to be
426 interpolated as if items in the list. An item starting with + is a named
427 sublist, obtained by searching the tree pointed to by anchorptr, with possible
428 cached match results in cache_bits.
431 listptr pointer to the pointer to the list
432 sep separator character for string_nextinlist();
433 normally zero for a standard list;
434 sometimes UCHAR_MAX+1 for single items;
435 anchorptr -> tree of named items, or NULL if no named items
436 cache_ptr pointer to pointer to cache bits for named items, or
437 pointer to NULL if not caching; may get set NULL if an
438 uncacheable named list is encountered
439 func function to call back to do one test
440 arg pointer to pass to the function; the string to be matched is
441 in the structure it points to
442 type MCL_STRING, MCL_DOMAIN, MCL_HOST, MCL_ADDRESS, or MCL_LOCALPART
443 these are used for some special handling
444 MCL_NOEXPAND (whose value is greater than any of them) may
445 be added to any value to suppress expansion of the list
446 name string to use in debugging info
447 valueptr where to pass back data from a lookup
449 Returns: OK if matched a non-negated item
450 OK if hit end of list after a negated item
451 FAIL if expansion force-failed
452 FAIL if matched a negated item
453 FAIL if hit end of list after a non-negated item
454 DEFER if a something deferred or expansion failed
458 match_check_list(const uschar **listptr, int sep, tree_node **anchorptr,
459 unsigned int **cache_ptr, int (*func)(void *,const uschar *,const uschar **,uschar **),
460 void *arg, int type, const uschar *name, const uschar **valueptr)
463 unsigned int *original_cache_bits = *cache_ptr;
464 BOOL include_unknown = FALSE;
465 BOOL ignore_unknown = FALSE;
466 BOOL include_defer = FALSE;
467 BOOL ignore_defer = FALSE;
472 /* Save time by not scanning for the option name when we don't need it. */
476 uschar *listname = readconf_find_option(listptr);
477 if (listname[0] != 0) ot = string_sprintf("%s in %s?", name, listname);
480 /* If the list is empty, the answer is no. Skip the debugging output for
485 HDEBUG(D_lists) if (ot) debug_printf("%s no (option unset)\n", ot);
489 /* Expand the list before we scan it. A forced expansion gives the answer
490 "not in list"; other expansion errors cause DEFER to be returned. However,
491 if the type value is greater than or equal to than MCL_NOEXPAND, do not expand
494 if (type >= MCL_NOEXPAND)
497 type -= MCL_NOEXPAND; /* Remove the "no expand" flag */
501 /* If we are searching a domain list, and $domain is not set, set it to the
502 subject that is being sought for the duration of the expansion. */
504 if (type == MCL_DOMAIN && !deliver_domain)
506 check_string_block *cb = (check_string_block *)arg;
507 deliver_domain = string_copy(cb->subject);
508 list = expand_cstring(*listptr);
509 deliver_domain = NULL;
512 list = expand_cstring(*listptr);
516 if (f.expand_string_forcedfail)
518 HDEBUG(D_lists) debug_printf("expansion of \"%s\" forced failure: "
519 "assume not in this list\n", *listptr);
522 log_write(0, LOG_MAIN|LOG_PANIC, "failed to expand \"%s\" while checking "
523 "a list: %s", *listptr, expand_string_message);
528 /* For an unnamed list, use the expanded version in comments */
530 HDEBUG(D_any) if (!ot) ot = string_sprintf("%s in \"%s\"?", name, list);
532 /* Now scan the list and process each item in turn, until one of them matches,
533 or we hit an error. */
535 while ((sss = string_nextinlist(&list, &sep, NULL, 0)))
539 /* Address lists may contain +caseful, to restore caseful matching of the
540 local part. We have to know the layout of the control block, unfortunately.
541 The lower cased address is in a temporary buffer, so we just copy the local
542 part back to the start of it (if a local part exists). */
544 if (type == MCL_ADDRESS)
546 if (Ustrcmp(ss, "+caseful") == 0)
548 check_address_block *cb = (check_address_block *)arg;
549 uschar *at = Ustrrchr(cb->origaddress, '@');
552 Ustrncpy(cb->address, cb->origaddress, at - cb->origaddress);
553 cb->caseless = FALSE;
558 /* Similar processing for local parts */
560 else if (type == MCL_LOCALPART)
562 if (Ustrcmp(ss, "+caseful") == 0)
564 check_string_block *cb = (check_string_block *)arg;
565 Ustrcpy(US cb->subject, cb->origsubject);
566 cb->caseless = FALSE;
571 /* If the host item is "+include_unknown" or "+ignore_unknown", remember it
572 in case there's a subsequent failed reverse lookup. There is similar
573 processing for "defer". */
575 else if (type == MCL_HOST && *ss == '+')
577 if (Ustrcmp(ss, "+include_unknown") == 0)
579 include_unknown = TRUE;
580 ignore_unknown = FALSE;
583 if (Ustrcmp(ss, "+ignore_unknown") == 0)
585 ignore_unknown = TRUE;
586 include_unknown = FALSE;
589 if (Ustrcmp(ss, "+include_defer") == 0)
591 include_defer = TRUE;
592 ignore_defer = FALSE;
595 if (Ustrcmp(ss, "+ignore_defer") == 0)
598 include_defer = FALSE;
603 /* Starting with ! specifies a negative item. It is theoretically possible
604 for a local part to start with !. In that case, a regex has to be used. */
609 while (isspace((*(++ss))));
614 /* If the item does not begin with '/', it might be a + item for a named
615 list. Otherwise, it is just a single list entry that has to be matched.
616 We recognize '+' only when supplied with a tree of named lists. */
620 if (*ss == '+' && anchorptr)
625 unsigned int *use_cache_bits = original_cache_bits;
626 uschar *cached = US"";
630 if (!(t = tree_search(*anchorptr, ss+1)))
632 log_write(0, LOG_MAIN|LOG_PANIC, "unknown named%s list \"%s\"",
633 type == MCL_DOMAIN ? " domain" :
634 type == MCL_HOST ? " host" :
635 type == MCL_ADDRESS ? " address" :
636 type == MCL_LOCALPART ? " local part" : "",
642 /* If the list number is negative, it means that this list is not
643 cacheable because it contains expansion items. */
645 if (nb->number < 0) use_cache_bits = NULL;
647 /* If we have got a cache pointer, get the bits. This is not an "else"
648 because the pointer may be NULL from the start if caching is not
653 offset = (nb->number)/16;
654 shift = ((nb->number)%16)*2;
655 bits = use_cache_bits[offset] & (3 << shift);
658 /* Not previously tested or no cache - run the full test */
662 switch (match_check_list(&(nb->string), 0, anchorptr, &use_cache_bits,
663 func, arg, type, name, valueptr))
665 case OK: bits = 1; break;
666 case FAIL: bits = 3; break;
667 case DEFER: goto DEFER_RETURN;
670 /* If this list was uncacheable, or a sublist turned out to be
671 uncacheable, the value of use_cache_bits will now be NULL, even if it
672 wasn't before. Ensure that this is passed up to the next level.
673 Otherwise, remember the result of the search in the cache. */
679 use_cache_bits[offset] |= bits << shift;
683 int old_pool = store_pool;
684 namedlist_cacheblock *p;
686 /* Cached data for hosts persists over more than one message,
687 so we use the permanent store pool */
689 store_pool = POOL_PERM;
690 p = store_get(sizeof(namedlist_cacheblock), FALSE);
691 p->key = string_copy(get_check_key(arg, type));
694 p->data = *valueptr ? string_copy(*valueptr) : NULL;
695 store_pool = old_pool;
697 p->next = nb->cache_data;
700 DEBUG(D_lists) debug_printf("data from lookup saved for "
701 "cache for %s: %s\n", ss, *valueptr);
706 /* Previously cached; to find a lookup value, search a chain of values
707 and compare keys. Typically, there is only one such, but it is possible
708 for different keys to have matched the same named list. */
712 DEBUG(D_lists) debug_printf("cached %s match for %s\n",
713 ((bits & (-bits)) == bits)? "yes" : "no", ss);
715 cached = US" - cached";
718 const uschar *key = get_check_key(arg, type);
720 for (namedlist_cacheblock * p = nb->cache_data; p; p = p->next)
721 if (Ustrcmp(key, p->key) == 0)
726 DEBUG(D_lists) debug_printf("cached lookup data = %s\n", *valueptr);
730 /* Result of test is indicated by value in bits. For each test, we
731 have 00 => untested, 01 => tested yes, 11 => tested no. */
733 if ((bits & (-bits)) == bits) /* Only one of the two bits is set */
735 HDEBUG(D_lists) debug_printf("%s %s (matched \"%s\"%s)\n", ot,
736 (yield == OK)? "yes" : "no", sss, cached);
741 /* Run the provided function to do the individual test. */
745 uschar * error = NULL;
746 switch ((func)(arg, ss, valueptr, &error))
749 HDEBUG(D_lists) debug_printf("%s %s (matched \"%s\")\n", ot,
750 (yield == OK)? "yes" : "no", sss);
755 error = string_sprintf("DNS lookup of \"%s\" deferred", ss);
758 HDEBUG(D_lists) debug_printf("%s: item ignored by +ignore_defer\n",
764 log_write(0, LOG_MAIN, "%s: accepted by +include_defer", error);
767 if (!search_error_message) search_error_message = error;
770 /* The ERROR return occurs when checking hosts, when either a forward
771 or reverse lookup has failed. It can also occur in a match_ip list if a
772 non-IP address item is encountered. The error string gives details of
778 HDEBUG(D_lists) debug_printf("%s: item ignored by +ignore_unknown\n",
783 HDEBUG(D_lists) debug_printf("%s %s (%s)\n", ot,
784 include_unknown? "yes":"no", error);
785 if (!include_unknown)
787 if (LOGGING(unknown_in_list))
788 log_write(0, LOG_MAIN, "list matching forced to fail: %s", error);
791 log_write(0, LOG_MAIN, "%s: accepted by +include_unknown", error);
798 /* If the item is a file name, we read the file and do a match attempt
799 on each line in the file, including possibly more negation processing. */
803 int file_yield = yield; /* In case empty file */
804 uschar * filename = ss;
805 FILE * f = Ufopen(filename, "rb");
806 uschar filebuffer[1024];
808 /* ot will be null in non-debugging cases, and anyway, we get better
809 wording by reworking it. */
813 uschar * listname = readconf_find_option(listptr);
814 if (listname[0] == 0)
815 listname = string_sprintf("\"%s\"", *listptr);
816 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "%s",
817 string_open_failed(errno, "%s when checking %s", sss, listname));
820 /* Trailing comments are introduced by #, but in an address list or local
821 part list, the # must be preceded by white space or the start of the line,
822 because the # character is a legal character in local parts. */
824 while (Ufgets(filebuffer, sizeof(filebuffer), f) != NULL)
827 uschar *sss = filebuffer;
829 while ((ss = Ustrchr(sss, '#')) != NULL)
831 if ((type != MCL_ADDRESS && type != MCL_LOCALPART) ||
832 ss == filebuffer || isspace(ss[-1]))
840 ss = filebuffer + Ustrlen(filebuffer); /* trailing space */
841 while (ss > filebuffer && isspace(ss[-1])) ss--;
845 while (isspace(*ss)) ss++; /* leading space */
847 if (*ss == 0) continue; /* ignore empty */
849 file_yield = yield; /* positive yield */
850 sss = ss; /* for debugging */
852 if (*ss == '!') /* negation */
854 file_yield = (file_yield == OK)? FAIL : OK;
855 while (isspace((*(++ss))));
858 switch ((func)(arg, ss, valueptr, &error))
862 HDEBUG(D_lists) debug_printf("%s %s (matched \"%s\" in %s)\n", ot,
863 yield == OK ? "yes" : "no", sss, filename);
868 error = string_sprintf("DNS lookup of %s deferred", ss);
871 HDEBUG(D_lists) debug_printf("%s: item ignored by +ignore_defer\n",
878 log_write(0, LOG_MAIN, "%s: accepted by +include_defer", error);
883 case ERROR: /* host name lookup failed - this can only */
884 if (ignore_unknown) /* be for an incoming host (not outgoing) */
886 HDEBUG(D_lists) debug_printf("%s: item ignored by +ignore_unknown\n",
891 HDEBUG(D_lists) debug_printf("%s %s (%s)\n", ot,
892 include_unknown? "yes":"no", error);
894 if (!include_unknown)
896 if (LOGGING(unknown_in_list))
897 log_write(0, LOG_MAIN, "list matching forced to fail: %s", error);
900 log_write(0, LOG_MAIN, "%s: accepted by +include_unknown", error);
906 /* At the end of the file, leave the yield setting at the final setting
907 for the file, in case this is the last item in the list. */
912 } /* Loop for the next item on the top-level list */
914 /* End of list reached: if the last item was negated yield OK, else FAIL. */
917 debug_printf("%s %s (end of list)\n", ot, yield == OK ? "no":"yes");
918 return yield == OK ? FAIL : OK;
920 /* Something deferred */
923 HDEBUG(D_lists) debug_printf("%s list match deferred for %s\n", ot, sss);
928 /*************************************************
929 * Match in colon-separated list *
930 *************************************************/
932 /* This function is used for domain lists and local part lists. It is not used
933 for host lists or address lists, which have additional interpretation of the
934 patterns. Some calls of it set sep > UCHAR_MAX in order to use its matching
935 facilities on single items. When this is done, it arranges to set the numerical
936 variables as a result of the match.
938 This function is now just a short interface to match_check_list(), which does
939 list scanning in a general way. A good compiler will optimize the tail
943 s string to search for
944 listptr ptr to ptr to colon separated list of patterns, or NULL
945 sep a separator value for the list (see string_nextinlist())
946 anchorptr ptr to tree for named items, or NULL if no named items
947 cache_bits ptr to cache_bits for ditto, or NULL if not caching
948 type MCL_DOMAIN when matching a domain list
949 MCL_LOCALPART when matching a local part list (address lists
950 have their own function)
951 MCL_STRING for others (e.g. list of ciphers)
952 MCL_NOEXPAND (whose value is greater than any of them) may
953 be added to any value to suppress expansion of the list
954 caseless TRUE for (mostly) caseless matching - passed directly to
956 valueptr pointer to where any lookup data is to be passed back,
957 or NULL (just passed on to match_check_string)
959 Returns: OK if matched a non-negated item
960 OK if hit end of list after a negated item
961 FAIL if expansion force-failed
962 FAIL if matched a negated item
963 FAIL if hit end of list after a non-negated item
964 DEFER if a lookup deferred
968 match_isinlist(const uschar *s, const uschar **listptr, int sep,
969 tree_node **anchorptr,
970 unsigned int *cache_bits, int type, BOOL caseless, const uschar **valueptr)
972 unsigned int *local_cache_bits = cache_bits;
973 check_string_block cb;
975 cb.subject = caseless? string_copylc(s) : string_copy(s);
976 cb.expand_setup = (sep > UCHAR_MAX)? 0 : -1;
977 cb.use_partial = TRUE;
978 cb.caseless = caseless;
979 cb.at_is_special = (type == MCL_DOMAIN || type == MCL_DOMAIN + MCL_NOEXPAND);
980 if (valueptr != NULL) *valueptr = NULL;
981 return match_check_list(listptr, sep, anchorptr, &local_cache_bits,
982 check_string, &cb, type, s, valueptr);
987 /*************************************************
988 * Match address to single address-list item *
989 *************************************************/
991 /* This function matches an address to an item from an address list. It is
992 called from match_address_list() via match_check_list(). That is why most of
993 its arguments are in an indirect block.
996 arg the argument block (see below)
997 pattern the pattern to match
998 valueptr where to return a value
999 error for error messages (not used in this function; it never
1002 The argument block contains:
1003 address the start of the subject address; when called from retry.c
1004 it may be *@domain if the local part isn't relevant
1005 origaddress the original, un-case-forced address (not used here, but used
1006 in match_check_list() when +caseful is encountered)
1007 expand_setup controls setting up of $n variables
1008 caseless TRUE for caseless local part matching
1010 Returns: OK for a match
1012 DEFER if a lookup deferred
1016 check_address(void *arg, const uschar *pattern, const uschar **valueptr, uschar **error)
1018 check_address_block *cb = (check_address_block *)arg;
1019 check_string_block csb;
1022 unsigned int *null = NULL;
1023 const uschar *listptr;
1024 uschar *subject = cb->address;
1026 uschar *pdomain, *sdomain;
1028 error = error; /* Keep clever compilers from complaining */
1030 DEBUG(D_lists) debug_printf("address match test: subject=%s pattern=%s\n",
1033 /* Find the subject's domain */
1035 sdomain = Ustrrchr(subject, '@');
1037 /* The only case where a subject may not have a domain is if the subject is
1038 empty. Otherwise, a subject with no domain is a serious configuration error. */
1040 if (sdomain == NULL && *subject != 0)
1042 log_write(0, LOG_MAIN|LOG_PANIC, "no @ found in the subject of an "
1043 "address list match: subject=\"%s\" pattern=\"%s\"", subject, pattern);
1047 /* Handle a regular expression, which must match the entire incoming address.
1048 This may be the empty address. */
1050 if (*pattern == '^')
1051 return match_check_string(subject, pattern, cb->expand_setup, TRUE,
1052 cb->caseless, FALSE, NULL);
1054 /* Handle a pattern that is just a lookup. Skip over possible lookup names
1055 (letters, digits, hyphens). Skip over a possible * or *@ at the end. Then we
1056 must have a semicolon for it to be a lookup. */
1058 for (s = pattern; isalnum(*s) || *s == '-'; s++);
1062 /* If it is a straight lookup, do a lookup for the whole address. This may be
1063 the empty address. Partial matching doesn't make sense here, so we ignore it,
1064 but write a panic log entry. However, *@ matching will be honoured. */
1068 if (Ustrncmp(pattern, "partial-", 8) == 0)
1069 log_write(0, LOG_MAIN|LOG_PANIC, "partial matching is not applicable to "
1070 "whole-address lookups: ignored \"partial-\" in \"%s\"", pattern);
1071 return match_check_string(subject, pattern, -1, FALSE, cb->caseless, FALSE,
1075 /* For the remaining cases, an empty subject matches only an empty pattern,
1076 because other patterns expect to have a local part and a domain to match
1079 if (*subject == 0) return (*pattern == 0)? OK : FAIL;
1081 /* If the pattern starts with "@@" we have a split lookup, where the domain is
1082 looked up to obtain a list of local parts. If the subject's local part is just
1083 "*" (called from retry) the match always fails. */
1085 if (pattern[0] == '@' && pattern[1] == '@')
1089 uschar buffer[1024];
1091 if (sdomain == subject + 1 && *subject == '*') return FAIL;
1093 /* Loop for handling chains. The last item in any list may be of the form
1094 ">name" in order to chain on to another list. */
1096 for (const uschar * key = sdomain + 1; key && watchdog-- > 0; )
1100 if ((rc = match_check_string(key, pattern + 2, -1, TRUE, FALSE, FALSE,
1101 CUSS &list)) != OK) return rc;
1103 /* Check for chaining from the last item; set up the next key if one
1106 ss = Ustrrchr(list, ':');
1107 if (ss == NULL) ss = list; else ss++;
1108 while (isspace(*ss)) ss++;
1112 while (isspace(*ss)) ss++;
1113 key = string_copy(ss);
1117 /* Look up the local parts provided by the list; negation is permitted.
1118 If a local part has to begin with !, a regex can be used. */
1120 while ((ss = string_nextinlist(CUSS &list, &sep, buffer, sizeof(buffer))))
1127 while (isspace((*(++ss))));
1129 else local_yield = OK;
1132 rc = match_check_string(subject, ss, -1, TRUE, cb->caseless, FALSE,
1147 /* End of chain loop; panic if too many times */
1150 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "Loop detected in lookup of "
1151 "local part of %s in %s", subject, pattern);
1153 /* Otherwise the local part check has failed, so the whole match
1160 /* We get here if the pattern is not a lookup or a regular expression. If it
1161 contains an @ there is both a local part and a domain. */
1163 pdomain = Ustrrchr(pattern, '@');
1164 if (pdomain != NULL)
1168 /* If the domain in the pattern is empty or one of the special cases [] or
1169 mx_{any,primary,secondary}, and the local part in the pattern ends in "@",
1170 we have a pattern of the form <something>@@, <something>@@[], or
1171 <something>@@mx_{any,primary,secondary}. These magic "domains" are
1172 automatically interpreted in match_check_string. We just need to arrange that
1173 the leading @ is included in the domain. */
1175 if (pdomain > pattern && pdomain[-1] == '@' &&
1177 Ustrcmp(pdomain+1, "[]") == 0 ||
1178 Ustrcmp(pdomain+1, "mx_any") == 0 ||
1179 Ustrcmp(pdomain+1, "mx_primary") == 0 ||
1180 Ustrcmp(pdomain+1, "mx_secondary") == 0))
1183 pllen = pdomain - pattern;
1184 sllen = sdomain - subject;
1186 /* Compare the local parts in the subject and the pattern */
1188 if (*pattern == '*')
1190 int cllen = pllen - 1;
1191 if (sllen < cllen) return FAIL;
1193 ? strncmpic(subject+sllen-cllen, pattern + 1, cllen) != 0
1194 : Ustrncmp(subject+sllen-cllen, pattern + 1, cllen) != 0)
1196 if (cb->expand_setup > 0)
1198 expand_nstring[cb->expand_setup] = subject;
1199 expand_nlength[cb->expand_setup] = sllen - cllen;
1205 if (sllen != pllen) return FAIL;
1207 ? strncmpic(subject, pattern, sllen) != 0
1208 : Ustrncmp(subject, pattern, sllen) != 0) return FAIL;
1212 /* If the local part matched, or was not being checked, check the domain using
1213 the generalized function, which supports file lookups (which may defer). The
1214 original code read as follows:
1216 return match_check_string(sdomain + 1,
1217 pdomain ? pdomain + 1 : pattern,
1218 cb->expand_setup + expand_inc, TRUE, cb->caseless, TRUE, NULL);
1220 This supported only literal domains and *.x.y patterns. In order to allow for
1221 named domain lists (so that you can right, for example, "senders=+xxxx"), it
1222 was changed to use the list scanning function. */
1224 csb.origsubject = sdomain + 1;
1225 csb.subject = cb->caseless ? string_copylc(sdomain+1) : string_copy(sdomain+1);
1226 csb.expand_setup = cb->expand_setup + expand_inc;
1227 csb.use_partial = TRUE;
1228 csb.caseless = cb->caseless;
1229 csb.at_is_special = TRUE;
1231 listptr = pdomain ? pdomain + 1 : pattern;
1232 if (valueptr) *valueptr = NULL;
1234 return match_check_list(
1235 &listptr, /* list of one item */
1236 UCHAR_MAX+1, /* impossible separator; single item */
1237 &domainlist_anchor, /* it's a domain list */
1238 &null, /* ptr to NULL means no caching */
1239 check_string, /* the function to do one test */
1240 &csb, /* its data */
1241 MCL_DOMAIN + MCL_NOEXPAND, /* domain list; don't expand */
1242 csb.subject, /* string for messages */
1243 valueptr); /* where to pass back lookup data */
1249 /*************************************************
1250 * Test whether address matches address list *
1251 *************************************************/
1253 /* This function is given an address and a list of things to match it against.
1254 The list may contain individual addresses, regular expressions, lookup
1255 specifications, and indirection via bare files. Negation is supported. The
1256 address to check can consist of just a domain, which will then match only
1257 domain items or items specified as *@domain.
1259 Domains are always lower cased before the match. Local parts are also lower
1260 cased unless "caseless" is false. The work of actually scanning the list is
1261 done by match_check_list(), with an appropriate block of arguments and a
1262 callback to check_address(). During caseless matching, it will recognize
1263 +caseful and revert to caseful matching.
1266 address address to test
1267 caseless TRUE to start in caseless state
1268 expand TRUE to allow list expansion
1269 listptr list to check against
1270 cache_bits points to cache bits for named address lists, or NULL
1271 expand_setup controls setting up of $n variables - passed through
1272 to check_address (q.v.)
1273 sep separator character for the list;
1274 may be 0 to get separator from the list;
1275 may be UCHAR_MAX+1 for one-item list
1276 valueptr where to return a lookup value, or NULL
1278 Returns: OK for a positive match, or end list after a negation;
1279 FAIL for a negative match, or end list after non-negation;
1280 DEFER if a lookup deferred
1284 match_address_list(const uschar *address, BOOL caseless, BOOL expand,
1285 const uschar **listptr, unsigned int *cache_bits, int expand_setup, int sep,
1286 const uschar **valueptr)
1288 check_address_block ab;
1289 unsigned int *local_cache_bits = cache_bits;
1292 /* RFC 2505 recommends that for spam checking, local parts should be caselessly
1293 compared. Therefore, Exim now forces the entire address into lower case here,
1294 provided that "caseless" is set. (It is FALSE for calls for matching rewriting
1295 patterns.) Otherwise just the domain is lower cases. A magic item "+caseful" in
1296 the list can be used to restore a caseful copy of the local part from the
1297 original address. */
1299 if ((len = Ustrlen(address)) > 255) len = 255;
1300 ab.address = string_copyn(address, len);
1302 for (uschar * p = ab.address + len - 1; p >= ab.address; p--)
1304 if (!caseless && *p == '@') break;
1308 /* If expand_setup is zero, we need to set up $0 to the whole thing, in
1309 case there is a match. Can't use the built-in facilities of match_check_string
1310 (via check_address), as we may just be calling that for part of the address
1313 if (expand_setup == 0)
1315 expand_nstring[0] = string_copy(address);
1316 expand_nlength[0] = Ustrlen(address);
1320 /* Set up the data to be passed ultimately to check_address. */
1322 ab.origaddress = address;
1323 /* ab.address is above */
1324 ab.expand_setup = expand_setup;
1325 ab.caseless = caseless;
1327 return match_check_list(listptr, sep, &addresslist_anchor, &local_cache_bits,
1328 check_address, &ab, MCL_ADDRESS + (expand? 0:MCL_NOEXPAND), address,
1332 /* Simpler version of match_address_list; always caseless, expanding,
1333 no cache bits, no value-return.
1336 address address to test
1337 listptr list to check against
1338 sep separator character for the list;
1339 may be 0 to get separator from the list;
1340 may be UCHAR_MAX+1 for one-item list
1342 Returns: OK for a positive match, or end list after a negation;
1343 FAIL for a negative match, or end list after non-negation;
1344 DEFER if a lookup deferred
1348 match_address_list_basic(const uschar *address, const uschar **listptr, int sep)
1350 return match_address_list(address, TRUE, TRUE, listptr, NULL, -1, sep, NULL);
1353 /* End of match.c */