1 /* $Cambridge: exim/src/src/match.c,v 1.9 2005/09/12 13:39:31 ph10 Exp $ */
3 /*************************************************
4 * Exim - an Internet mail transport agent *
5 *************************************************/
7 /* Copyright (c) University of Cambridge 1995 - 2005 */
8 /* See the file NOTICE for conditions of use and distribution. */
10 /* Functions for matching strings */
16 /* Argument block for the check_string() function. This is used for general
17 strings, domains, and local parts. */
19 typedef struct check_string_block
{
20 uschar
*origsubject
; /* caseful; keep these two first, in */
21 uschar
*subject
; /* step with the block below */
29 /* Argument block for the check_address() function. This is used for whole
32 typedef struct check_address_block
{
33 uschar
*origaddress
; /* caseful; keep these two first, in */
34 uschar
*address
; /* step with the block above */
37 } check_address_block
;
41 /*************************************************
42 * Generalized string match *
43 *************************************************/
45 /* This function does a single match of a subject against a pattern, and
46 optionally sets up the numeric variables according to what it matched. It is
47 called from match_isinlist() via match_check_list() when scanning a list, and
48 from match_check_string() when testing just a single item. The subject and
49 options arguments are passed in a check_string_block so as to make it easier to
50 pass them through match_check_list.
52 The possible types of pattern are:
54 . regular expression - starts with ^
55 . tail match - starts with *
56 . lookup - starts with search type
57 . if at_is_special is set in the argument block:
58 @ matches the primary host name
59 @[] matches a local IP address in brackets
60 @mx_any matches any domain with an MX to the local host
61 @mx_primary matches any domain with a primary MX to the local host
62 @mx_secondary matches any domain with a secondary MX to the local host
63 . literal - anything else
65 Any of the @mx_xxx options can be followed by "/ignore=<list>" where <list> is
66 a list of IP addresses that are to be ignored (typically 127.0.0.1).
69 arg check_string_block pointer - see below
70 pattern the pattern to be matched
71 valueptr if not NULL, and a lookup is done, return the result here
72 instead of discarding it; else set it to point to NULL
73 error for error messages (not used in this function; it never
76 Contents of the argument block:
77 subject the subject string to be checked
78 expand_setup if < 0, don't set up any numeric expansion variables;
79 if = 0, set $0 to whole subject, and either
80 $1 to what matches * or
81 $1, $2, ... to r.e. bracketed items
82 if > 0, don't set $0, but do set either
83 $n to what matches *, or
84 $n, $n+1, ... to r.e. bracketed items
85 (where n = expand_setup)
86 use_partial if FALSE, override any partial- search types
87 caseless TRUE for caseless matching where possible
88 at_is_special enable special handling of items starting with @
90 Returns: OK if matched
92 DEFER if lookup deferred
96 check_string(void *arg
, uschar
*pattern
, uschar
**valueptr
, uschar
**error
)
98 check_string_block
*cb
= (check_string_block
*)arg
;
99 int search_type
, partial
, affixlen
, starflags
;
100 int expand_setup
= cb
->expand_setup
;
102 uschar
*s
= cb
->subject
;
103 uschar
*filename
= NULL
;
104 uschar
*keyquery
, *result
, *semicolon
;
107 error
= error
; /* Keep clever compilers from complaining */
109 if (valueptr
!= NULL
) *valueptr
= NULL
; /* For non-lookup matches */
111 /* If required to set up $0, initialize the data but don't turn on by setting
112 expand_nmax until the match is assured. */
115 if (expand_setup
== 0)
117 expand_nstring
[0] = s
;
118 expand_nlength
[0] = Ustrlen(s
);
120 else if (expand_setup
> 0) expand_setup
--;
122 /* Regular expression match: compile, match, and set up $ variables if
125 if (pattern
[0] == '^')
127 const pcre
*re
= regex_must_compile(pattern
, cb
->caseless
, FALSE
);
128 return ((expand_setup
< 0)?
129 pcre_exec(re
, NULL
, CS s
, Ustrlen(s
), 0, PCRE_EOPT
, NULL
, 0) >= 0
131 regex_match_and_setup(re
, s
, 0, expand_setup
)
138 if (pattern
[0] == '*')
141 int slen
= Ustrlen(s
);
142 int patlen
; /* Sun compiler doesn't like non-constant initializer */
144 patlen
= Ustrlen(++pattern
);
145 if (patlen
> slen
) return FAIL
;
146 yield
= cb
->caseless
?
147 (strncmpic(s
+ slen
- patlen
, pattern
, patlen
) == 0) :
148 (Ustrncmp(s
+ slen
- patlen
, pattern
, patlen
) == 0);
149 if (yield
&& expand_setup
>= 0)
151 expand_nstring
[++expand_setup
] = s
;
152 expand_nlength
[expand_setup
] = slen
- patlen
;
153 expand_nmax
= expand_setup
;
155 return yield
? OK
: FAIL
;
158 /* Match a special item starting with @ if so enabled. On its own, "@" matches
159 the primary host name - implement this by changing the pattern. For the other
160 cases we have to do some more work. If we don't recognize a special pattern,
161 just fall through - the match will fail. */
163 if (cb
->at_is_special
&& pattern
[0] == '@')
167 pattern
= primary_hostname
;
168 goto NOT_AT_SPECIAL
; /* Handle as exact string match */
171 if (Ustrcmp(pattern
, "@[]") == 0)
174 int slen
= Ustrlen(s
);
175 if (s
[0] != '[' && s
[slen
-1] != ']') return FAIL
;
176 for (ip
= host_find_interfaces(); ip
!= NULL
; ip
= ip
->next
)
177 if (Ustrncmp(ip
->address
, s
+1, slen
- 2) == 0) return OK
;
181 if (strncmpic(pattern
, US
"@mx_", 4) == 0)
187 BOOL removed
= FALSE
;
188 uschar
*ss
= pattern
+ 4;
189 uschar
*ignore_target_hosts
= NULL
;
191 if (strncmpic(ss
, US
"any", 3) == 0) ss
+= 3;
192 else if (strncmpic(ss
, US
"primary", 7) == 0)
197 else if (strncmpic(ss
, US
"secondary", 9) == 0)
202 else goto NOT_AT_SPECIAL
;
204 if (strncmpic(ss
, US
"/ignore=", 8) == 0) ignore_target_hosts
= ss
+ 8;
205 else if (*ss
!= 0) goto NOT_AT_SPECIAL
;
211 rc
= host_find_bydns(&h
,
213 HOST_FIND_BY_MX
, /* search only for MX, not SRV or A */
214 NULL
, /* service name not relevant */
215 NULL
, /* srv_fail_domains not relevant */
216 NULL
, /* mx_fail_domains not relevant */
217 NULL
, /* no feedback FQDN */
218 &removed
); /* feedback if local removed */
220 if (rc
== HOST_FIND_AGAIN
)
222 search_error_message
= string_sprintf("DNS lookup of \"%s\" deferred", s
);
226 if (rc
== HOST_FOUND_LOCAL
&& !secy
) return OK
;
227 if (prim
) return FAIL
;
228 return removed
? OK
: FAIL
;
230 /*** The above line used to be the following line, but this is incorrect,
231 because host_find_bydns() may return HOST_NOT_FOUND if it removed some MX
232 hosts, but the remaining ones were non-existent. All we are interested in
233 is whether or not it removed some hosts.
235 return (rc == HOST_FOUND && removed)? OK : FAIL;
240 /* Escape point from code for specials that start with "@" */
244 /* This is an exact string match if there is no semicolon in the pattern. */
246 if ((semicolon
= Ustrchr(pattern
, ';')) == NULL
)
248 BOOL yield
= cb
->caseless
?
249 (strcmpic(s
, pattern
) == 0) : (Ustrcmp(s
, pattern
) == 0);
250 if (yield
&& expand_setup
>= 0) expand_nmax
= expand_setup
;
251 return yield
? OK
: FAIL
;
254 /* Otherwise we have a lookup item. The lookup type, including partial, etc. is
255 the part of the string preceding the semicolon. */
258 search_type
= search_findtype_partial(pattern
, &partial
, &affix
, &affixlen
,
261 if (search_type
< 0) log_write(0, LOG_MAIN
|LOG_PANIC_DIE
, "%s",
262 search_error_message
);
264 /* Partial matching is not appropriate for certain lookups (e.g. when looking
265 up user@domain for sender rejection). There's a flag to disable it. */
267 if (!cb
->use_partial
) partial
= -1;
269 /* Set the parameters for the three different kinds of lookup. */
271 keyquery
= semicolon
+ 1;
272 while (isspace(*keyquery
)) keyquery
++;
274 if (mac_islookup(search_type
, lookup_absfilequery
))
277 while (*keyquery
!= 0 && !isspace(*keyquery
)) keyquery
++;
278 filename
= string_copyn(filename
, keyquery
- filename
);
279 while (isspace(*keyquery
)) keyquery
++;
282 else if (!mac_islookup(search_type
, lookup_querystyle
))
288 /* Now do the actual lookup; throw away the data returned unless it was asked
289 for; partial matching is all handled inside search_find(). Note that there is
290 no search_close() because of the caching arrangements. */
292 handle
= search_open(filename
, search_type
, 0, NULL
, NULL
);
293 if (handle
== NULL
) log_write(0, LOG_MAIN
|LOG_PANIC_DIE
, "%s",
294 search_error_message
);
295 result
= search_find(handle
, filename
, keyquery
, partial
, affix
, affixlen
,
296 starflags
, &expand_setup
);
298 if (result
== NULL
) return search_find_defer
? DEFER
: FAIL
;
299 if (valueptr
!= NULL
) *valueptr
= result
;
301 expand_nmax
= expand_setup
;
307 /*************************************************
308 * Public interface to check_string() *
309 *************************************************/
311 /* This function is called from several places where is it most convenient to
312 pass the arguments individually. It places them in a check_string_block
313 structure, and then calls check_string().
316 s the subject string to be checked
317 pattern the pattern to check it against
318 expand_setup expansion setup option (see check_string())
319 use_partial if FALSE, override any partial- search types
320 caseless TRUE for caseless matching where possible
321 at_is_special TRUE to recognize @, @[], etc.
322 valueptr if not NULL, and a file lookup was done, return the result
323 here instead of discarding it; else set it to point to NULL
325 Returns: OK if matched
327 DEFER if lookup deferred
331 match_check_string(uschar
*s
, uschar
*pattern
, int expand_setup
,
332 BOOL use_partial
, BOOL caseless
, BOOL at_is_special
, uschar
**valueptr
)
334 check_string_block cb
;
336 cb
.subject
= caseless
? string_copylc(s
) : string_copy(s
);
337 cb
.expand_setup
= expand_setup
;
338 cb
.use_partial
= use_partial
;
339 cb
.caseless
= caseless
;
340 cb
.at_is_special
= at_is_special
;
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
361 get_check_key(void *arg
, int type
)
368 return ((check_string_block
*)arg
)->subject
;
371 return ((check_host_block
*)arg
)->host_address
;
374 return ((check_address_block
*)arg
)->address
;
376 return US
""; /* In practice, should never happen */
381 /*************************************************
382 * Scan list and run matching function *
383 *************************************************/
385 /* This function scans a list of patterns, and runs a matching function for
386 each item in the list. It is called from the functions that match domains,
387 local parts, hosts, and addresses, because its overall structure is the same in
388 all cases. However, the details of each particular match is different, so it
389 calls back to a given function do perform an actual match.
391 We can't quite keep the different types anonymous here because they permit
392 different special cases. A pity.
394 If a list item starts with !, that implies negation if the subject matches the
395 rest of the item (ignoring white space after the !). The result when the end of
396 the list is reached is FALSE unless the last item on the list is negated, in
397 which case it is TRUE. A file name in the list causes its lines to be
398 interpolated as if items in the list. An item starting with + is a named
399 sublist, obtained by searching the tree pointed to by anchorptr, with possible
400 cached match results in cache_bits.
403 listptr pointer to the pointer to the list
404 sep separator character for string_nextinlist();
405 normally zero for a standard list;
406 sometimes UCHAR_MAX+1 for single items;
407 anchorptr -> tree of named items, or NULL if no named items
408 cache_ptr pointer to pointer to cache bits for named items, or
409 pointer to NULL if not caching; may get set NULL if an
410 uncacheable named list is encountered
411 func function to call back to do one test
412 arg pointer to pass to the function; the string to be matched is
413 in the structure it points to
414 type MCL_STRING, MCL_DOMAIN, MCL_HOST, MCL_ADDRESS, or MCL_LOCALPART
415 these are used for some special handling
416 MCL_NOEXPAND (whose value is greater than any of them) may
417 be added to any value to suppress expansion of the list
418 name string to use in debugging info
419 valueptr where to pass back data from a lookup
421 Returns: OK if matched a non-negated item
422 OK if hit end of list after a negated item
423 FAIL if expansion force-failed
424 FAIL if matched a negated item
425 FAIL if hit end of list after a non-negated item
426 DEFER if a lookup deferred or expansion failed
430 match_check_list(uschar
**listptr
, int sep
, tree_node
**anchorptr
,
431 unsigned int **cache_ptr
, int (*func
)(void *,uschar
*,uschar
**,uschar
**),
432 void *arg
, int type
, uschar
*name
, uschar
**valueptr
)
435 unsigned int *original_cache_bits
= *cache_ptr
;
436 BOOL include_unknown
= FALSE
;
437 BOOL ignore_unknown
= FALSE
;
443 /* Save time by not scanning for the option name when we don't need it. */
447 uschar
*listname
= readconf_find_option(listptr
);
448 if (listname
[0] != 0) ot
= string_sprintf("%s in %s?", name
, listname
);
451 /* If the list is empty, the answer is no. Skip the debugging output for
454 if (*listptr
== NULL
)
458 if (ot
!= NULL
) debug_printf("%s no (option unset)\n", ot
);
463 /* Expand the list before we scan it. A forced expansion gives the answer
464 "not in list"; other expansion errors cause DEFER to be returned. However,
465 if the type value is greater than or equal to than MCL_NOEXPAND, do not expand
468 if (type
>= MCL_NOEXPAND
)
471 type
-= MCL_NOEXPAND
; /* Remove the "no expand" flag */
475 list
= expand_string(*listptr
);
478 if (expand_string_forcedfail
)
480 HDEBUG(D_lists
) debug_printf("expansion of \"%s\" forced failure: "
481 "assume not in this list\n", *listptr
);
484 log_write(0, LOG_MAIN
|LOG_PANIC
, "failed to expand \"%s\" while checking "
485 "a list: %s", *listptr
, expand_string_message
);
490 /* For an unnamed list, use the expanded version in comments */
494 if (ot
== NULL
) ot
= string_sprintf("%s in \"%s\"?", name
, list
);
497 /* Now scan the list and process each item in turn, until one of them matches,
498 or we hit an error. */
500 while ((sss
= string_nextinlist(&list
, &sep
, buffer
, sizeof(buffer
))) != NULL
)
504 /* Address lists may contain +caseful, to restore caseful matching of the
505 local part. We have to know the layout of the control block, unfortunately.
506 The lower cased address is in a temporary buffer, so we just copy the local
507 part back to the start of it (if a local part exists). */
509 if (type
== MCL_ADDRESS
)
511 if (Ustrcmp(ss
, "+caseful") == 0)
513 check_address_block
*cb
= (check_address_block
*)arg
;
514 uschar
*at
= Ustrrchr(cb
->origaddress
, '@');
516 Ustrncpy(cb
->address
, cb
->origaddress
, at
- cb
->origaddress
);
517 cb
->caseless
= FALSE
;
522 /* Similar processing for local parts */
524 else if (type
== MCL_LOCALPART
)
526 if (Ustrcmp(ss
, "+caseful") == 0)
528 check_string_block
*cb
= (check_string_block
*)arg
;
529 Ustrcpy(cb
->subject
, cb
->origsubject
);
530 cb
->caseless
= FALSE
;
535 /* If the host item is "+include_unknown", remember it in case there's a
536 subsequent failed reverse lookup. */
538 else if (type
== MCL_HOST
)
540 if (Ustrcmp(ss
, "+include_unknown") == 0)
542 include_unknown
= TRUE
;
543 ignore_unknown
= FALSE
;
546 if (Ustrcmp(ss
, "+ignore_unknown") == 0)
548 ignore_unknown
= TRUE
;
549 include_unknown
= FALSE
;
554 /* Starting with ! specifies a negative item. It is theoretically possible
555 for a local part to start with !. In that case, a regex has to be used. */
560 while (isspace((*(++ss
))));
564 /* If the item does not begin with '/', it might be a + item for a named
565 list. Otherwise, it is just a single list entry that has to be matched.
566 We recognize '+' only when supplied with a tree of named lists. */
570 if (*ss
== '+' && anchorptr
!= NULL
)
575 unsigned int *use_cache_bits
= original_cache_bits
;
576 uschar
*cached
= US
"";
578 tree_node
*t
= tree_search(*anchorptr
, ss
+1);
581 log_write(0, LOG_MAIN
|LOG_PANIC_DIE
, "unknown named%s list \"%s\"",
582 (type
== MCL_DOMAIN
)? " domain" :
583 (type
== MCL_HOST
)? " host" :
584 (type
== MCL_ADDRESS
)? " address" :
585 (type
== MCL_LOCALPART
)? " local part" : "",
589 /* If the list number is negative, it means that this list is not
590 cacheable because it contains expansion items. */
592 if (nb
->number
< 0) use_cache_bits
= NULL
;
594 /* If we have got a cache pointer, get the bits. This is not an "else"
595 because the pointer may be NULL from the start if caching is not
598 if (use_cache_bits
!= NULL
)
600 offset
= (nb
->number
)/16;
601 shift
= ((nb
->number
)%16)*2;
602 bits
= use_cache_bits
[offset
] & (3 << shift
);
605 /* Not previously tested or no cache - run the full test */
609 switch (match_check_list(&(nb
->string
), 0, anchorptr
, &use_cache_bits
,
610 func
, arg
, type
, name
, valueptr
))
612 case OK
: bits
= 1; break;
613 case FAIL
: bits
= 3; break;
614 case DEFER
: goto DEFER_RETURN
;
617 /* If this list was uncacheable, or a sublist turned out to be
618 uncacheable, the value of use_cache_bits will now be NULL, even if it
619 wasn't before. Ensure that this is passed up to the next level.
620 Otherwise, remember the result of the search in the cache. */
622 if (use_cache_bits
== NULL
)
628 use_cache_bits
[offset
] |= bits
<< shift
;
630 if (valueptr
!= NULL
)
632 int old_pool
= store_pool
;
633 namedlist_cacheblock
*p
;
635 /* Cached data for hosts persists over more than one message,
636 so we use the permanent store pool */
638 store_pool
= POOL_PERM
;
639 p
= store_get(sizeof(namedlist_cacheblock
));
640 p
->key
= string_copy(get_check_key(arg
, type
));
643 p
->data
= (*valueptr
== NULL
)? NULL
: string_copy(*valueptr
);
644 store_pool
= old_pool
;
646 p
->next
= nb
->cache_data
;
648 if (*valueptr
!= NULL
)
650 DEBUG(D_lists
) debug_printf("data from lookup saved for "
651 "cache for %s: %s\n", ss
, *valueptr
);
657 /* Previously cached; to find a lookup value, search a chain of values
658 and compare keys. Typically, there is only one such, but it is possible
659 for different keys to have matched the same named list. */
663 DEBUG(D_lists
) debug_printf("cached %s match for %s\n",
664 ((bits
& (-bits
)) == bits
)? "yes" : "no", ss
);
665 cached
= US
" - cached";
666 if (valueptr
!= NULL
)
668 uschar
*key
= get_check_key(arg
, type
);
669 namedlist_cacheblock
*p
;
670 for (p
= nb
->cache_data
; p
!= NULL
; p
= p
->next
)
672 if (Ustrcmp(key
, p
->key
) == 0)
678 DEBUG(D_lists
) debug_printf("cached lookup data = %s\n", *valueptr
);
682 /* Result of test is indicated by value in bits. For each test, we
683 have 00 => untested, 01 => tested yes, 11 => tested no. */
685 if ((bits
& (-bits
)) == bits
) /* Only one of the two bits is set */
687 HDEBUG(D_lists
) debug_printf("%s %s (matched \"%s\"%s)\n", ot
,
688 (yield
== OK
)? "yes" : "no", sss
, cached
);
693 /* Run the provided function to do the individual test. */
698 switch ((func
)(arg
, ss
, valueptr
, &error
))
701 HDEBUG(D_lists
) debug_printf("%s %s (matched \"%s\")\n", ot
,
702 (yield
== OK
)? "yes" : "no", sss
);
708 /* The ERROR return occurs when checking hosts, when either a forward
709 or reverse lookup has failed. It can also occur in a match_ip list if a
710 non-IP address item is encountered. The error string gives details of
716 HDEBUG(D_lists
) debug_printf("%s: item ignored by +ignore_unknown",
721 HDEBUG(D_lists
) debug_printf("%s %s (%s)\n", ot
,
722 include_unknown
? "yes":"no", error
);
723 if (!include_unknown
)
725 if ((log_extra_selector
& LX_unknown_in_list
) != 0)
726 log_write(0, LOG_MAIN
, "list matching forced to fail: %s", error
);
729 log_write(0, LOG_MAIN
, "%s: accepted by +include_unknown", error
);
736 /* If the item is a file name, we read the file and do a match attempt
737 on each line in the file, including possibly more negation processing. */
741 int file_yield
= yield
; /* In case empty file */
742 uschar
*filename
= ss
;
743 FILE *f
= Ufopen(filename
, "rb");
744 uschar filebuffer
[1024];
746 /* ot will be null in non-debugging cases, and anyway, we get better
747 wording by reworking it. */
751 uschar
*listname
= readconf_find_option(listptr
);
752 if (listname
[0] == 0)
753 listname
= string_sprintf("\"%s\"", *listptr
);
754 log_write(0, LOG_MAIN
|LOG_PANIC_DIE
, "%s",
755 string_open_failed(errno
, "%s when checking %s", sss
, listname
));
758 /* Trailing comments are introduced by #, but in an address list or local
759 part list, the # must be preceded by white space or the start of the line,
760 because the # character is a legal character in local parts. */
762 while (Ufgets(filebuffer
, sizeof(filebuffer
), f
) != NULL
)
765 uschar
*sss
= filebuffer
;
767 while ((ss
= Ustrchr(sss
, '#')) != NULL
)
769 if ((type
!= MCL_ADDRESS
&& type
!= MCL_LOCALPART
) ||
770 ss
== filebuffer
|| isspace(ss
[-1]))
778 ss
= filebuffer
+ Ustrlen(filebuffer
); /* trailing space */
779 while (ss
> filebuffer
&& isspace(ss
[-1])) ss
--;
783 while (isspace(*ss
)) ss
++; /* leading space */
785 if (*ss
== 0) continue; /* ignore empty */
787 file_yield
= yield
; /* positive yield */
788 sss
= ss
; /* for debugging */
790 if (*ss
== '!') /* negation */
792 file_yield
= (file_yield
== OK
)? FAIL
: OK
;
793 while (isspace((*(++ss
))));
796 switch ((func
)(arg
, ss
, valueptr
, &error
))
800 HDEBUG(D_lists
) debug_printf("%s %s (matched \"%s\" in %s)\n", ot
,
801 (yield
== OK
)? "yes" : "no", sss
, filename
);
808 case ERROR
: /* host name lookup failed - this can only */
809 if (ignore_unknown
) /* be for an incoming host (not outgoing) */
811 HDEBUG(D_lists
) debug_printf("%s: item ignored by +ignore_unknown",
816 HDEBUG(D_lists
) debug_printf("%s %s (%s)\n", ot
,
817 include_unknown
? "yes":"no", error
);
819 if (!include_unknown
)
821 if ((log_extra_selector
& LX_unknown_in_list
) != 0)
822 log_write(0, LOG_MAIN
, "list matching forced to fail: %s", error
);
825 log_write(0, LOG_MAIN
, "%s: accepted by +include_unknown", error
);
831 /* At the end of the file, leave the yield setting at the final setting
832 for the file, in case this is the last item in the list. */
837 } /* Loop for the next item on the top-level list */
839 /* End of list reached: if the last item was negated yield OK, else FAIL. */
842 debug_printf("%s %s (end of list)\n", ot
, (yield
== OK
)? "no":"yes");
843 return (yield
== OK
)? FAIL
: OK
;
845 /* Handle lookup defer */
848 HDEBUG(D_lists
) debug_printf("%s lookup deferred for %s\n", ot
, sss
);
853 /*************************************************
854 * Match in colon-separated list *
855 *************************************************/
857 /* This function is used for domain lists and local part lists. It is not used
858 for host lists or address lists, which have additional interpretation of the
859 patterns. Some calls of it set sep > UCHAR_MAX in order to use its matching
860 facilities on single items. When this is done, it arranges to set the numerical
861 variables as a result of the match.
863 This function is now just a short interface to match_check_list(), which does
864 list scanning in a general way. A good compiler will optimize the tail
868 s string to search for
869 listptr ptr to ptr to colon separated list of patterns, or NULL
870 sep a separator value for the list (see string_nextinlist())
871 anchorptr ptr to tree for named items, or NULL if no named items
872 cache_bits ptr to cache_bits for ditto, or NULL if not caching
873 type MCL_DOMAIN when matching a domain list
874 MCL_LOCALPART when matching a local part list (address lists
875 have their own function)
876 MCL_STRING for others (e.g. list of ciphers)
877 MCL_NOEXPAND (whose value is greater than any of them) may
878 be added to any value to suppress expansion of the list
879 caseless TRUE for (mostly) caseless matching - passed directly to
881 valueptr pointer to where any lookup data is to be passed back,
882 or NULL (just passed on to match_check_string)
884 Returns: OK if matched a non-negated item
885 OK if hit end of list after a negated item
886 FAIL if expansion force-failed
887 FAIL if matched a negated item
888 FAIL if hit end of list after a non-negated item
889 DEFER if a lookup deferred
893 match_isinlist(uschar
*s
, uschar
**listptr
, int sep
, tree_node
**anchorptr
,
894 unsigned int *cache_bits
, int type
, BOOL caseless
, uschar
**valueptr
)
896 unsigned int *local_cache_bits
= cache_bits
;
897 check_string_block cb
;
899 cb
.subject
= caseless
? string_copylc(s
) : string_copy(s
);
900 cb
.expand_setup
= (sep
> UCHAR_MAX
)? 0 : -1;
901 cb
.use_partial
= TRUE
;
902 cb
.caseless
= caseless
;
903 cb
.at_is_special
= (type
== MCL_DOMAIN
|| type
== MCL_DOMAIN
+ MCL_NOEXPAND
);
904 if (valueptr
!= NULL
) *valueptr
= NULL
;
905 return match_check_list(listptr
, sep
, anchorptr
, &local_cache_bits
,
906 check_string
, &cb
, type
, s
, valueptr
);
911 /*************************************************
912 * Match address to single address-list item *
913 *************************************************/
915 /* This function matches an address to an item from an address list. It is
916 called from match_address_list() via match_check_list(). That is why most of
917 its arguments are in an indirect block.
920 arg the argument block (see below)
921 pattern the pattern to match
922 valueptr where to return a value
923 error for error messages (not used in this function; it never
926 The argument block contains:
927 address the start of the subject address; when called from retry.c
928 it may be *@domain if the local part isn't relevant
929 origaddress the original, un-case-forced address (not used here, but used
930 in match_check_list() when +caseful is encountered)
931 expand_setup controls setting up of $n variables
932 caseless TRUE for caseless local part matching
934 Returns: OK for a match
936 DEFER if a lookup deferred
940 check_address(void *arg
, uschar
*pattern
, uschar
**valueptr
, uschar
**error
)
942 check_address_block
*cb
= (check_address_block
*)arg
;
943 check_string_block csb
;
946 unsigned int *null
= NULL
;
948 uschar
*subject
= cb
->address
;
949 uschar
*s
, *pdomain
, *sdomain
;
951 error
= error
; /* Keep clever compilers from complaining */
953 DEBUG(D_lists
) debug_printf("address match: subject=%s pattern=%s\n",
956 /* Handle a regular expression, which must match the entire incoming address.
957 This may be the empty address. */
960 return match_check_string(subject
, pattern
, cb
->expand_setup
, TRUE
,
961 cb
->caseless
, FALSE
, NULL
);
963 /* Handle a pattern that is just a lookup. Skip over possible lookup names
964 (letters, digits, hyphens). Skip over a possible * or *@ at the end. Then we
965 must have a semicolon for it to be a lookup. */
967 for (s
= pattern
; isalnum(*s
) || *s
== '-'; s
++);
971 /* If it is a straight lookup, do a lookup for the whole address. This may be
972 the empty address. Partial matching doesn't make sense here, so we ignore it,
973 but write a panic log entry. However, *@ matching will be honoured. */
977 if (Ustrncmp(pattern
, "partial-", 8) == 0)
978 log_write(0, LOG_MAIN
|LOG_PANIC
, "partial matching is not applicable to "
979 "whole-address lookups: ignored \"partial-\" in \"%s\"", pattern
);
980 return match_check_string(subject
, pattern
, -1, FALSE
, cb
->caseless
, FALSE
,
984 /* For the remaining cases, an empty subject matches only an empty pattern,
985 because other patterns expect to have a local part and a domain to match
988 if (*subject
== 0) return (*pattern
== 0)? OK
: FAIL
;
990 /* Find the subject's domain */
992 sdomain
= Ustrrchr(subject
, '@');
994 /* If the pattern starts with "@@" we have a split lookup, where the domain is
995 looked up to obtain a list of local parts. If the subject's local part is just
996 "*" (called from retry) the match always fails. */
998 if (pattern
[0] == '@' && pattern
[1] == '@')
1001 uschar
*list
, *key
, *ss
;
1002 uschar buffer
[1024];
1004 if (sdomain
== subject
+ 1 && *subject
== '*') return FAIL
;
1006 /* Loop for handling chains. The last item in any list may be of the form
1007 ">name" in order to chain on to another list. */
1009 for (key
= sdomain
+ 1; key
!= NULL
&& watchdog
-- > 0; )
1013 if ((rc
= match_check_string(key
, pattern
+ 2, -1, TRUE
, FALSE
, FALSE
,
1014 &list
)) != OK
) return rc
;
1016 /* Check for chaining from the last item; set up the next key if one
1019 ss
= Ustrrchr(list
, ':');
1020 if (ss
== NULL
) ss
= list
; else ss
++;
1021 while (isspace(*ss
)) ss
++;
1025 while (isspace(*ss
)) ss
++;
1026 key
= string_copy(ss
);
1030 /* Look up the local parts provided by the list; negation is permitted.
1031 If a local part has to begin with !, a regex can be used. */
1033 while ((ss
= string_nextinlist(&list
, &sep
, buffer
, sizeof(buffer
)))
1041 while (isspace((*(++ss
))));
1043 else local_yield
= OK
;
1046 rc
= match_check_string(subject
, ss
, -1, TRUE
, cb
->caseless
, FALSE
,
1061 /* End of chain loop; panic if too many times */
1064 log_write(0, LOG_MAIN
|LOG_PANIC_DIE
, "Loop detected in lookup of "
1065 "local part of %s in %s", subject
, pattern
);
1067 /* Otherwise the local part check has failed, so the whole match
1074 /* We get here if the pattern is not a lookup or a regular expression. If it
1075 contains an @ there is both a local part and a domain. */
1077 pdomain
= Ustrrchr(pattern
, '@');
1078 if (pdomain
!= NULL
)
1082 /* If the domain in the pattern is empty or one of the special cases [] or
1083 mx_{any,primary,secondary}, and the local part in the pattern ends in "@",
1084 we have a pattern of the form <something>@@, <something>@@[], or
1085 <something>@@mx_{any,primary,secondary}. These magic "domains" are
1086 automatically interpreted in match_check_string. We just need to arrange that
1087 the leading @ is included in the domain. */
1089 if (pdomain
> pattern
&& pdomain
[-1] == '@' &&
1091 Ustrcmp(pdomain
+1, "[]") == 0 ||
1092 Ustrcmp(pdomain
+1, "mx_any") == 0 ||
1093 Ustrcmp(pdomain
+1, "mx_primary") == 0 ||
1094 Ustrcmp(pdomain
+1, "mx_secondary") == 0))
1097 pllen
= pdomain
- pattern
;
1098 sllen
= sdomain
- subject
;
1100 /* Compare the local parts in the subject and the pattern */
1102 if (*pattern
== '*')
1104 int cllen
= pllen
- 1;
1105 if (sllen
< cllen
) return FAIL
;
1108 if (strncmpic(subject
+sllen
-cllen
, pattern
+ 1, cllen
) != 0)
1113 if (Ustrncmp(subject
+sllen
-cllen
, pattern
+ 1, cllen
) != 0)
1116 if (cb
->expand_setup
> 0)
1118 expand_nstring
[cb
->expand_setup
] = subject
;
1119 expand_nlength
[cb
->expand_setup
] = sllen
- cllen
;
1125 if (sllen
!= pllen
) return FAIL
;
1128 if (strncmpic(subject
, pattern
, sllen
) != 0) return FAIL
;
1132 if (Ustrncmp(subject
, pattern
, sllen
) != 0) return FAIL
;
1137 /* If the local part matched, or was not being checked, check the domain using
1138 the generalized function, which supports file lookups (which may defer). The
1139 original code read as follows:
1141 return match_check_string(sdomain + 1,
1142 (pdomain == NULL)? pattern : pdomain + 1,
1143 cb->expand_setup + expand_inc, TRUE, cb->caseless, TRUE, NULL);
1145 This supported only literal domains and *.x.y patterns. In order to allow for
1146 named domain lists (so that you can right, for example, "senders=+xxxx"), it
1147 was changed to use the list scanning function. */
1149 csb
.origsubject
= sdomain
+ 1;
1150 csb
.subject
= (cb
->caseless
)? string_copylc(sdomain
+1) : string_copy(sdomain
+1);
1151 csb
.expand_setup
= cb
->expand_setup
+ expand_inc
;
1152 csb
.use_partial
= TRUE
;
1153 csb
.caseless
= cb
->caseless
;
1154 csb
.at_is_special
= TRUE
;
1156 listptr
= (pdomain
== NULL
)? pattern
: pdomain
+ 1;
1157 if (valueptr
!= NULL
) *valueptr
= NULL
;
1159 return match_check_list(
1160 &listptr
, /* list of one item */
1161 UCHAR_MAX
+1, /* impossible separator; single item */
1162 &domainlist_anchor
, /* it's a domain list */
1163 &null
, /* ptr to NULL means no caching */
1164 check_string
, /* the function to do one test */
1165 &csb
, /* its data */
1166 MCL_DOMAIN
+ MCL_NOEXPAND
, /* domain list; don't expand */
1167 csb
.subject
, /* string for messages */
1168 valueptr
); /* where to pass back lookup data */
1174 /*************************************************
1175 * Test whether address matches address list *
1176 *************************************************/
1178 /* This function is given an address and a list of things to match it against.
1179 The list may contain individual addresses, regular expressions, lookup
1180 specifications, and indirection via bare files. Negation is supported. The
1181 address to check can consist of just a domain, which will then match only
1182 domain items or items specified as *@domain.
1184 Domains are always lower cased before the match. Local parts are also lower
1185 cased unless "caseless" is false. The work of actually scanning the list is
1186 done by match_check_list(), with an appropriate block of arguments and a
1187 callback to check_address(). During caseless matching, it will recognize
1188 +caseful and revert to caseful matching.
1191 address address to test
1192 caseless TRUE to start in caseless state
1193 expand TRUE to allow list expansion
1194 listptr list to check against
1195 cache_bits points to cache bits for named address lists, or NULL
1196 expand_setup controls setting up of $n variables - passed through
1197 to check_address (q.v.)
1198 sep separator character for the list;
1199 may be 0 to get separator from the list;
1200 may be UCHAR_MAX+1 for one-item list
1201 valueptr where to return a lookup value, or NULL
1203 Returns: OK for a positive match, or end list after a negation;
1204 FAIL for a negative match, or end list after non-negation;
1205 DEFER if a lookup deferred
1209 match_address_list(uschar
*address
, BOOL caseless
, BOOL expand
,
1210 uschar
**listptr
, unsigned int *cache_bits
, int expand_setup
, int sep
,
1214 check_address_block ab
;
1215 unsigned int *local_cache_bits
= cache_bits
;
1217 /* RFC 2505 recommends that for spam checking, local parts should be caselessly
1218 compared. Therefore, Exim now forces the entire address into lower case here,
1219 provided that "caseless" is set. (It is FALSE for calls for matching rewriting
1220 patterns.) Otherwise just the domain is lower cases. A magic item "+caseful" in
1221 the list can be used to restore a caseful copy of the local part from the
1222 original address. */
1224 sprintf(CS big_buffer
, "%.*s", big_buffer_size
- 1, address
);
1225 for (p
= big_buffer
+ Ustrlen(big_buffer
) - 1; p
>= big_buffer
; p
--)
1227 if (!caseless
&& *p
== '@') break;
1231 /* If expand_setup is zero, we need to set up $0 to the whole thing, in
1232 case there is a match. Can't use the built-in facilities of match_check_string
1233 (via check_address), as we may just be calling that for part of the address
1236 if (expand_setup
== 0)
1238 expand_nstring
[0] = string_copy(address
);
1239 expand_nlength
[0] = Ustrlen(address
);
1243 /* Set up the data to be passed ultimately to check_address. */
1245 ab
.origaddress
= address
;
1246 ab
.address
= big_buffer
;
1247 ab
.expand_setup
= expand_setup
;
1248 ab
.caseless
= caseless
;
1250 return match_check_list(listptr
, sep
, &addresslist_anchor
, &local_cache_bits
,
1251 check_address
, &ab
, MCL_ADDRESS
+ (expand
? 0:MCL_NOEXPAND
), address
,
1255 /* End of match.c */