testcases for value return
[exim.git] / src / src / match.c
CommitLineData
059ec3d9
PH
1/*************************************************
2* Exim - an Internet mail transport agent *
3*************************************************/
4
f9ba5e22 5/* Copyright (c) University of Cambridge 1995 - 2018 */
1e1ddfac 6/* Copyright (c) The Exim Maintainers 2020 */
059ec3d9
PH
7/* See the file NOTICE for conditions of use and distribution. */
8
9/* Functions for matching strings */
10
11
12#include "exim.h"
13
14
15/* Argument block for the check_string() function. This is used for general
16strings, domains, and local parts. */
17
18typedef struct check_string_block {
1dc92d5a
JH
19 const uschar *origsubject; /* caseful; keep these two first, in */
20 const uschar *subject; /* step with the block below */
059ec3d9
PH
21 int expand_setup;
22 BOOL use_partial;
23 BOOL caseless;
24 BOOL at_is_special;
25} check_string_block;
26
27
28/* Argument block for the check_address() function. This is used for whole
29addresses. */
30
31typedef struct check_address_block {
55414b25 32 const uschar *origaddress; /* caseful; keep these two first, in */
059ec3d9
PH
33 uschar *address; /* step with the block above */
34 int expand_setup;
35 BOOL caseless;
36} check_address_block;
37
38
39
40/*************************************************
41* Generalized string match *
42*************************************************/
43
44/* This function does a single match of a subject against a pattern, and
45optionally sets up the numeric variables according to what it matched. It is
46called from match_isinlist() via match_check_list() when scanning a list, and
47from match_check_string() when testing just a single item. The subject and
48options arguments are passed in a check_string_block so as to make it easier to
49pass them through match_check_list.
50
51The possible types of pattern are:
52
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
63
64Any of the @mx_xxx options can be followed by "/ignore=<list>" where <list> is
65a list of IP addresses that are to be ignored (typically 127.0.0.1).
66
67Arguments:
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
73 returns ERROR)
74
75Contents of the argument block:
366fc9f0
PH
76 origsubject the subject in its original casing
77 subject the subject string to be checked, lowercased if caseless
059ec3d9
PH
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 @
89
90Returns: OK if matched
91 FAIL if not matched
92 DEFER if lookup deferred
93*/
94
95static int
55414b25 96check_string(void *arg, const uschar *pattern, const uschar **valueptr, uschar **error)
059ec3d9 97{
1dc92d5a 98const check_string_block *cb = arg;
059ec3d9
PH
99int search_type, partial, affixlen, starflags;
100int expand_setup = cb->expand_setup;
67a57a5a 101const uschar * affix, * opts;
366fc9f0 102uschar *s;
059ec3d9
PH
103uschar *filename = NULL;
104uschar *keyquery, *result, *semicolon;
105void *handle;
106
107error = error; /* Keep clever compilers from complaining */
108
109if (valueptr != NULL) *valueptr = NULL; /* For non-lookup matches */
110
366fc9f0
PH
111/* For regular expressions, use cb->origsubject rather than cb->subject so that
112it works if the pattern uses (?-i) to turn off case-independence, overriding
113"caseless". */
114
1dc92d5a 115s = string_copy(pattern[0] == '^' ? cb->origsubject : cb->subject);
366fc9f0 116
059ec3d9
PH
117/* If required to set up $0, initialize the data but don't turn on by setting
118expand_nmax until the match is assured. */
119
120expand_nmax = -1;
121if (expand_setup == 0)
122 {
824ac956 123 expand_nstring[0] = s; /* $0 (might be) the matched subject in full */
059ec3d9
PH
124 expand_nlength[0] = Ustrlen(s);
125 }
126else if (expand_setup > 0) expand_setup--;
127
128/* Regular expression match: compile, match, and set up $ variables if
129required. */
130
131if (pattern[0] == '^')
132 {
fa0798c0 133 const pcre * re = regex_must_compile(pattern, cb->caseless, FALSE);
824ac956
JH
134 if (expand_setup < 0
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)
137 )
138 return FAIL;
139 /* assume the above wrote $0, $n... TODO: CHECK THAT !! */
140 if (valueptr) *valueptr = pattern; /* "value" gets the RE */
141 return OK;
059ec3d9
PH
142 }
143
144/* Tail match */
145
146if (pattern[0] == '*')
147 {
059ec3d9
PH
148 int slen = Ustrlen(s);
149 int patlen; /* Sun compiler doesn't like non-constant initializer */
150
151 patlen = Ustrlen(++pattern);
152 if (patlen > slen) return FAIL;
fa0798c0
JH
153 if (cb->caseless
154 ? strncmpic(s + slen - patlen, pattern, patlen) != 0
155 : Ustrncmp(s + slen - patlen, pattern, patlen) != 0)
156 return FAIL;
157 if (expand_setup >= 0)
059ec3d9 158 {
824ac956 159 expand_nstring[++expand_setup] = s; /* write a $n, the matched subject variable-part */
059ec3d9
PH
160 expand_nlength[expand_setup] = slen - patlen;
161 expand_nmax = expand_setup;
162 }
2a53e246 163 if (valueptr) *valueptr = pattern - 1; /* "value" gets the (original) pattern */
fa0798c0 164 return OK;
059ec3d9
PH
165 }
166
167/* Match a special item starting with @ if so enabled. On its own, "@" matches
168the primary host name - implement this by changing the pattern. For the other
169cases we have to do some more work. If we don't recognize a special pattern,
170just fall through - the match will fail. */
171
172if (cb->at_is_special && pattern[0] == '@')
173 {
174 if (pattern[1] == 0)
175 {
176 pattern = primary_hostname;
177 goto NOT_AT_SPECIAL; /* Handle as exact string match */
178 }
179
180 if (Ustrcmp(pattern, "@[]") == 0)
181 {
059ec3d9 182 int slen = Ustrlen(s);
824ac956 183 if (s[0] != '[' && s[slen-1] != ']') return FAIL; /*XXX should this be || ? */
d7978c0f 184 for (ip_address_item * ip = host_find_interfaces(); ip; ip = ip->next)
95d1f782
PH
185 if (Ustrncmp(ip->address, s+1, slen - 2) == 0
186 && ip->address[slen - 2] == 0)
fa0798c0 187 {
824ac956
JH
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 */
95d1f782 190 return OK;
fa0798c0 191 }
059ec3d9
PH
192 return FAIL;
193 }
194
195 if (strncmpic(pattern, US"@mx_", 4) == 0)
196 {
197 int rc;
198 host_item h;
199 BOOL prim = FALSE;
200 BOOL secy = FALSE;
201 BOOL removed = FALSE;
55414b25
JH
202 const uschar *ss = pattern + 4;
203 const uschar *ignore_target_hosts = NULL;
059ec3d9
PH
204
205 if (strncmpic(ss, US"any", 3) == 0) ss += 3;
206 else if (strncmpic(ss, US"primary", 7) == 0)
207 {
208 ss += 7;
209 prim = TRUE;
210 }
211 else if (strncmpic(ss, US"secondary", 9) == 0)
212 {
213 ss += 9;
214 secy = TRUE;
215 }
216 else goto NOT_AT_SPECIAL;
217
218 if (strncmpic(ss, US"/ignore=", 8) == 0) ignore_target_hosts = ss + 8;
fa0798c0 219 else if (*ss) goto NOT_AT_SPECIAL;
059ec3d9
PH
220
221 h.next = NULL;
222 h.name = s;
223 h.address = NULL;
224
225 rc = host_find_bydns(&h,
226 ignore_target_hosts,
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 */
7cd171b7 231 NULL, /* no dnssec request/require XXX ? */
059ec3d9
PH
232 NULL, /* no feedback FQDN */
233 &removed); /* feedback if local removed */
234
235 if (rc == HOST_FIND_AGAIN)
236 {
237 search_error_message = string_sprintf("DNS lookup of \"%s\" deferred", s);
238 return DEFER;
239 }
240
fa0798c0
JH
241 if (rc != HOST_FOUND_LOCAL || secy)
242 if (prim || !removed) return FAIL;
824ac956
JH
243
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 */
fa0798c0 246 return OK;
059ec3d9
PH
247
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.
252
253 return (rc == HOST_FOUND && removed)? OK : FAIL;
254 ***/
255 }
256 }
257
258/* Escape point from code for specials that start with "@" */
259
260NOT_AT_SPECIAL:
261
262/* This is an exact string match if there is no semicolon in the pattern. */
263
264if ((semicolon = Ustrchr(pattern, ';')) == NULL)
265 {
fa0798c0
JH
266 if (cb->caseless ? strcmpic(s, pattern) != 0 : Ustrcmp(s, pattern) != 0)
267 return FAIL;
824ac956
JH
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 */
fa0798c0
JH
270 return OK;
271
272/*
273XXX looks like $0 may be usable
fa0798c0 274*/
059ec3d9
PH
275 }
276
277/* Otherwise we have a lookup item. The lookup type, including partial, etc. is
278the part of the string preceding the semicolon. */
279
280*semicolon = 0;
281search_type = search_findtype_partial(pattern, &partial, &affix, &affixlen,
67a57a5a 282 &starflags, &opts);
059ec3d9
PH
283*semicolon = ';';
284if (search_type < 0) log_write(0, LOG_MAIN|LOG_PANIC_DIE, "%s",
285 search_error_message);
286
287/* Partial matching is not appropriate for certain lookups (e.g. when looking
288up user@domain for sender rejection). There's a flag to disable it. */
289
290if (!cb->use_partial) partial = -1;
291
13b685f9 292/* Set the parameters for the three different kinds of lookup. */
059ec3d9
PH
293
294keyquery = semicolon + 1;
137ae145 295Uskip_whitespace(&keyquery);
059ec3d9 296
13b685f9
PH
297if (mac_islookup(search_type, lookup_absfilequery))
298 {
299 filename = keyquery;
137ae145 300 while (*keyquery && !isspace(*keyquery)) keyquery++;
13b685f9 301 filename = string_copyn(filename, keyquery - filename);
137ae145 302 Uskip_whitespace(&keyquery);
13b685f9
PH
303 }
304
305else if (!mac_islookup(search_type, lookup_querystyle))
059ec3d9
PH
306 {
307 filename = keyquery;
308 keyquery = s;
309 }
310
311/* Now do the actual lookup; throw away the data returned unless it was asked
312for; partial matching is all handled inside search_find(). Note that there is
313no search_close() because of the caching arrangements. */
314
8768d548
JH
315if (!(handle = search_open(filename, search_type, 0, NULL, NULL)))
316 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "%s", search_error_message);
059ec3d9 317result = search_find(handle, filename, keyquery, partial, affix, affixlen,
67a57a5a 318 starflags, &expand_setup, opts);
059ec3d9 319
137ae145 320if (!result) return f.search_find_defer ? DEFER : FAIL;
8768d548 321if (valueptr) *valueptr = result;
059ec3d9
PH
322
323expand_nmax = expand_setup;
324return OK;
325}
326
327
328
329/*************************************************
330* Public interface to check_string() *
331*************************************************/
332
333/* This function is called from several places where is it most convenient to
334pass the arguments individually. It places them in a check_string_block
335structure, and then calls check_string().
336
337Arguments:
338 s the subject string to be checked
339 pattern the pattern to check it against
340 expand_setup expansion setup option (see check_string())
341 use_partial if FALSE, override any partial- search types
342 caseless TRUE for caseless matching where possible
343 at_is_special TRUE to recognize @, @[], etc.
344 valueptr if not NULL, and a file lookup was done, return the result
345 here instead of discarding it; else set it to point to NULL
346
347Returns: OK if matched
348 FAIL if not matched
349 DEFER if lookup deferred
350*/
351
352int
55414b25
JH
353match_check_string(const uschar *s, const uschar *pattern, int expand_setup,
354 BOOL use_partial, BOOL caseless, BOOL at_is_special, const uschar **valueptr)
059ec3d9
PH
355{
356check_string_block cb;
357cb.origsubject = s;
358cb.subject = caseless? string_copylc(s) : string_copy(s);
359cb.expand_setup = expand_setup;
360cb.use_partial = use_partial;
361cb.caseless = caseless;
362cb.at_is_special = at_is_special;
363return check_string(&cb, pattern, valueptr, NULL);
364}
365
366
367
368/*************************************************
369* Get key string from check block *
370*************************************************/
371
372/* When caching the data from a lookup for a named list, we have to save the
373key that was found, because other lookups of different keys on the same list
374may occur. This function has knowledge of the different lookup types, and
375extracts the appropriate key.
376
377Arguments:
378 arg the check block
379 type MCL_STRING, MCL_DOMAIN, MCL_HOST, MCL_ADDRESS, or MCL_LOCALPART
380*/
381
1dc92d5a 382static const uschar *
059ec3d9
PH
383get_check_key(void *arg, int type)
384{
385switch(type)
386 {
387 case MCL_STRING:
388 case MCL_DOMAIN:
389 case MCL_LOCALPART:
824ac956 390 return ((check_string_block *)arg)->subject;
059ec3d9
PH
391
392 case MCL_HOST:
824ac956 393 return ((check_host_block *)arg)->host_address;
059ec3d9
PH
394
395 case MCL_ADDRESS:
824ac956 396 return ((check_address_block *)arg)->address;
059ec3d9
PH
397 }
398return US""; /* In practice, should never happen */
399}
400
401
402
403/*************************************************
404* Scan list and run matching function *
405*************************************************/
406
407/* This function scans a list of patterns, and runs a matching function for
408each item in the list. It is called from the functions that match domains,
409local parts, hosts, and addresses, because its overall structure is the same in
410all cases. However, the details of each particular match is different, so it
411calls back to a given function do perform an actual match.
412
413We can't quite keep the different types anonymous here because they permit
414different special cases. A pity.
415
416If a list item starts with !, that implies negation if the subject matches the
417rest of the item (ignoring white space after the !). The result when the end of
418the list is reached is FALSE unless the last item on the list is negated, in
419which case it is TRUE. A file name in the list causes its lines to be
420interpolated as if items in the list. An item starting with + is a named
421sublist, obtained by searching the tree pointed to by anchorptr, with possible
422cached match results in cache_bits.
423
424Arguments:
425 listptr pointer to the pointer to the list
426 sep separator character for string_nextinlist();
427 normally zero for a standard list;
428 sometimes UCHAR_MAX+1 for single items;
429 anchorptr -> tree of named items, or NULL if no named items
430 cache_ptr pointer to pointer to cache bits for named items, or
431 pointer to NULL if not caching; may get set NULL if an
432 uncacheable named list is encountered
433 func function to call back to do one test
434 arg pointer to pass to the function; the string to be matched is
435 in the structure it points to
436 type MCL_STRING, MCL_DOMAIN, MCL_HOST, MCL_ADDRESS, or MCL_LOCALPART
437 these are used for some special handling
438 MCL_NOEXPAND (whose value is greater than any of them) may
439 be added to any value to suppress expansion of the list
440 name string to use in debugging info
441 valueptr where to pass back data from a lookup
442
443Returns: OK if matched a non-negated item
444 OK if hit end of list after a negated item
445 FAIL if expansion force-failed
446 FAIL if matched a negated item
447 FAIL if hit end of list after a non-negated item
485aa451 448 DEFER if a something deferred or expansion failed
059ec3d9
PH
449*/
450
451int
55414b25
JH
452match_check_list(const uschar **listptr, int sep, tree_node **anchorptr,
453 unsigned int **cache_ptr, int (*func)(void *,const uschar *,const uschar **,uschar **),
454 void *arg, int type, const uschar *name, const uschar **valueptr)
059ec3d9
PH
455{
456int yield = OK;
457unsigned int *original_cache_bits = *cache_ptr;
458BOOL include_unknown = FALSE;
459BOOL ignore_unknown = FALSE;
d52120f2
PH
460BOOL include_defer = FALSE;
461BOOL ignore_defer = FALSE;
55414b25 462const uschar *list;
059ec3d9
PH
463uschar *sss;
464uschar *ot = NULL;
059ec3d9
PH
465
466/* Save time by not scanning for the option name when we don't need it. */
467
468HDEBUG(D_any)
469 {
470 uschar *listname = readconf_find_option(listptr);
471 if (listname[0] != 0) ot = string_sprintf("%s in %s?", name, listname);
472 }
473
474/* If the list is empty, the answer is no. Skip the debugging output for
475an unnamed list. */
476
72934ba7 477if (!*listptr)
059ec3d9 478 {
72934ba7 479 HDEBUG(D_lists) if (ot) debug_printf("%s no (option unset)\n", ot);
059ec3d9
PH
480 return FAIL;
481 }
482
483/* Expand the list before we scan it. A forced expansion gives the answer
484"not in list"; other expansion errors cause DEFER to be returned. However,
485if the type value is greater than or equal to than MCL_NOEXPAND, do not expand
486the list. */
487
488if (type >= MCL_NOEXPAND)
489 {
490 list = *listptr;
491 type -= MCL_NOEXPAND; /* Remove the "no expand" flag */
492 }
493else
494 {
1bf43b78
PH
495 /* If we are searching a domain list, and $domain is not set, set it to the
496 subject that is being sought for the duration of the expansion. */
497
72934ba7 498 if (type == MCL_DOMAIN && !deliver_domain)
1bf43b78
PH
499 {
500 check_string_block *cb = (check_string_block *)arg;
1dc92d5a 501 deliver_domain = string_copy(cb->subject);
55414b25 502 list = expand_cstring(*listptr);
1bf43b78
PH
503 deliver_domain = NULL;
504 }
72934ba7
JH
505 else
506 list = expand_cstring(*listptr);
1bf43b78 507
72934ba7 508 if (!list)
059ec3d9 509 {
8768d548 510 if (f.expand_string_forcedfail)
059ec3d9
PH
511 {
512 HDEBUG(D_lists) debug_printf("expansion of \"%s\" forced failure: "
513 "assume not in this list\n", *listptr);
514 return FAIL;
515 }
516 log_write(0, LOG_MAIN|LOG_PANIC, "failed to expand \"%s\" while checking "
517 "a list: %s", *listptr, expand_string_message);
518 return DEFER;
519 }
520 }
521
522/* For an unnamed list, use the expanded version in comments */
523
ba74fb8d 524HDEBUG(D_any) if (!ot) ot = string_sprintf("%s in \"%s\"?", name, list);
059ec3d9
PH
525
526/* Now scan the list and process each item in turn, until one of them matches,
527or we hit an error. */
528
ba74fb8d 529while ((sss = string_nextinlist(&list, &sep, NULL, 0)))
059ec3d9 530 {
72934ba7 531 uschar * ss = sss;
059ec3d9
PH
532
533 /* Address lists may contain +caseful, to restore caseful matching of the
534 local part. We have to know the layout of the control block, unfortunately.
535 The lower cased address is in a temporary buffer, so we just copy the local
536 part back to the start of it (if a local part exists). */
537
538 if (type == MCL_ADDRESS)
539 {
540 if (Ustrcmp(ss, "+caseful") == 0)
541 {
542 check_address_block *cb = (check_address_block *)arg;
543 uschar *at = Ustrrchr(cb->origaddress, '@');
72934ba7
JH
544
545 if (at)
059ec3d9
PH
546 Ustrncpy(cb->address, cb->origaddress, at - cb->origaddress);
547 cb->caseless = FALSE;
548 continue;
549 }
550 }
551
552 /* Similar processing for local parts */
553
554 else if (type == MCL_LOCALPART)
555 {
556 if (Ustrcmp(ss, "+caseful") == 0)
557 {
558 check_string_block *cb = (check_string_block *)arg;
f3ebb786 559 Ustrcpy(US cb->subject, cb->origsubject);
059ec3d9
PH
560 cb->caseless = FALSE;
561 continue;
562 }
563 }
564
d52120f2
PH
565 /* If the host item is "+include_unknown" or "+ignore_unknown", remember it
566 in case there's a subsequent failed reverse lookup. There is similar
567 processing for "defer". */
059ec3d9 568
d52120f2 569 else if (type == MCL_HOST && *ss == '+')
059ec3d9
PH
570 {
571 if (Ustrcmp(ss, "+include_unknown") == 0)
572 {
573 include_unknown = TRUE;
574 ignore_unknown = FALSE;
575 continue;
576 }
577 if (Ustrcmp(ss, "+ignore_unknown") == 0)
578 {
579 ignore_unknown = TRUE;
580 include_unknown = FALSE;
581 continue;
582 }
d52120f2
PH
583 if (Ustrcmp(ss, "+include_defer") == 0)
584 {
585 include_defer = TRUE;
586 ignore_defer = FALSE;
587 continue;
588 }
589 if (Ustrcmp(ss, "+ignore_defer") == 0)
590 {
591 ignore_defer = TRUE;
592 include_defer = FALSE;
593 continue;
594 }
059ec3d9
PH
595 }
596
597 /* Starting with ! specifies a negative item. It is theoretically possible
598 for a local part to start with !. In that case, a regex has to be used. */
599
600 if (*ss == '!')
601 {
602 yield = FAIL;
603 while (isspace((*(++ss))));
604 }
72934ba7
JH
605 else
606 yield = OK;
059ec3d9
PH
607
608 /* If the item does not begin with '/', it might be a + item for a named
609 list. Otherwise, it is just a single list entry that has to be matched.
610 We recognize '+' only when supplied with a tree of named lists. */
611
612 if (*ss != '/')
613 {
72934ba7 614 if (*ss == '+' && anchorptr)
059ec3d9
PH
615 {
616 int bits = 0;
617 int offset = 0;
618 int shift = 0;
619 unsigned int *use_cache_bits = original_cache_bits;
620 uschar *cached = US"";
621 namedlist_block *nb;
72934ba7
JH
622 tree_node * t;
623
624 if (!(t = tree_search(*anchorptr, ss+1)))
625 {
626 log_write(0, LOG_MAIN|LOG_PANIC, "unknown named%s list \"%s\"",
627 type == MCL_DOMAIN ? " domain" :
628 type == MCL_HOST ? " host" :
629 type == MCL_ADDRESS ? " address" :
630 type == MCL_LOCALPART ? " local part" : "",
059ec3d9 631 ss);
72934ba7
JH
632 return DEFER;
633 }
059ec3d9
PH
634 nb = t->data.ptr;
635
636 /* If the list number is negative, it means that this list is not
637 cacheable because it contains expansion items. */
638
639 if (nb->number < 0) use_cache_bits = NULL;
640
641 /* If we have got a cache pointer, get the bits. This is not an "else"
642 because the pointer may be NULL from the start if caching is not
643 required. */
644
72934ba7 645 if (use_cache_bits)
059ec3d9
PH
646 {
647 offset = (nb->number)/16;
648 shift = ((nb->number)%16)*2;
649 bits = use_cache_bits[offset] & (3 << shift);
650 }
651
652 /* Not previously tested or no cache - run the full test */
653
654 if (bits == 0)
655 {
656 switch (match_check_list(&(nb->string), 0, anchorptr, &use_cache_bits,
657 func, arg, type, name, valueptr))
658 {
659 case OK: bits = 1; break;
660 case FAIL: bits = 3; break;
661 case DEFER: goto DEFER_RETURN;
662 }
663
664 /* If this list was uncacheable, or a sublist turned out to be
665 uncacheable, the value of use_cache_bits will now be NULL, even if it
666 wasn't before. Ensure that this is passed up to the next level.
667 Otherwise, remember the result of the search in the cache. */
668
72934ba7 669 if (!use_cache_bits)
059ec3d9 670 *cache_ptr = NULL;
059ec3d9
PH
671 else
672 {
673 use_cache_bits[offset] |= bits << shift;
674
72934ba7 675 if (valueptr)
059ec3d9
PH
676 {
677 int old_pool = store_pool;
678 namedlist_cacheblock *p;
679
680 /* Cached data for hosts persists over more than one message,
681 so we use the permanent store pool */
682
683 store_pool = POOL_PERM;
f3ebb786 684 p = store_get(sizeof(namedlist_cacheblock), FALSE);
059ec3d9 685 p->key = string_copy(get_check_key(arg, type));
60dc5e56
PH
686
687
72934ba7 688 p->data = *valueptr ? string_copy(*valueptr) : NULL;
059ec3d9
PH
689 store_pool = old_pool;
690
059ec3d9
PH
691 p->next = nb->cache_data;
692 nb->cache_data = p;
72934ba7 693 if (*valueptr)
059ec3d9 694 DEBUG(D_lists) debug_printf("data from lookup saved for "
a368cc11 695 "cache for %s: key '%s' value '%s'\n", ss, p->key, *valueptr);
059ec3d9
PH
696 }
697 }
698 }
699
700 /* Previously cached; to find a lookup value, search a chain of values
701 and compare keys. Typically, there is only one such, but it is possible
702 for different keys to have matched the same named list. */
703
704 else
705 {
706 DEBUG(D_lists) debug_printf("cached %s match for %s\n",
a368cc11 707 (bits & (-bits)) == bits ? "yes" : "no", ss);
72934ba7 708
059ec3d9 709 cached = US" - cached";
72934ba7 710 if (valueptr)
059ec3d9 711 {
1dc92d5a 712 const uschar *key = get_check_key(arg, type);
d7978c0f
JH
713
714 for (namedlist_cacheblock * p = nb->cache_data; p; p = p->next)
059ec3d9
PH
715 if (Ustrcmp(key, p->key) == 0)
716 {
717 *valueptr = p->data;
718 break;
719 }
059ec3d9
PH
720 DEBUG(D_lists) debug_printf("cached lookup data = %s\n", *valueptr);
721 }
722 }
723
724 /* Result of test is indicated by value in bits. For each test, we
725 have 00 => untested, 01 => tested yes, 11 => tested no. */
726
727 if ((bits & (-bits)) == bits) /* Only one of the two bits is set */
728 {
729 HDEBUG(D_lists) debug_printf("%s %s (matched \"%s\"%s)\n", ot,
730 (yield == OK)? "yes" : "no", sss, cached);
731 return yield;
732 }
733 }
734
735 /* Run the provided function to do the individual test. */
736
737 else
738 {
72934ba7 739 uschar * error = NULL;
059ec3d9
PH
740 switch ((func)(arg, ss, valueptr, &error))
741 {
742 case OK:
72934ba7
JH
743 HDEBUG(D_lists) debug_printf("%s %s (matched \"%s\")\n", ot,
744 (yield == OK)? "yes" : "no", sss);
745 return yield;
059ec3d9
PH
746
747 case DEFER:
72934ba7
JH
748 if (!error)
749 error = string_sprintf("DNS lookup of \"%s\" deferred", ss);
750 if (ignore_defer)
751 {
752 HDEBUG(D_lists) debug_printf("%s: item ignored by +ignore_defer\n",
753 error);
754 break;
755 }
756 if (include_defer)
757 {
758 log_write(0, LOG_MAIN, "%s: accepted by +include_defer", error);
759 return OK;
760 }
761 if (!search_error_message) search_error_message = error;
762 goto DEFER_RETURN;
059ec3d9 763
32d668a5
PH
764 /* The ERROR return occurs when checking hosts, when either a forward
765 or reverse lookup has failed. It can also occur in a match_ip list if a
766 non-IP address item is encountered. The error string gives details of
059ec3d9
PH
767 which it was. */
768
769 case ERROR:
72934ba7
JH
770 if (ignore_unknown)
771 {
772 HDEBUG(D_lists) debug_printf("%s: item ignored by +ignore_unknown\n",
773 error);
774 }
775 else
776 {
777 HDEBUG(D_lists) debug_printf("%s %s (%s)\n", ot,
778 include_unknown? "yes":"no", error);
779 if (!include_unknown)
780 {
781 if (LOGGING(unknown_in_list))
782 log_write(0, LOG_MAIN, "list matching forced to fail: %s", error);
783 return FAIL;
784 }
785 log_write(0, LOG_MAIN, "%s: accepted by +include_unknown", error);
786 return OK;
787 }
059ec3d9
PH
788 }
789 }
790 }
791
792 /* If the item is a file name, we read the file and do a match attempt
793 on each line in the file, including possibly more negation processing. */
794
795 else
796 {
797 int file_yield = yield; /* In case empty file */
72934ba7
JH
798 uschar * filename = ss;
799 FILE * f = Ufopen(filename, "rb");
059ec3d9
PH
800 uschar filebuffer[1024];
801
802 /* ot will be null in non-debugging cases, and anyway, we get better
803 wording by reworking it. */
804
72934ba7 805 if (!f)
059ec3d9 806 {
72934ba7 807 uschar * listname = readconf_find_option(listptr);
059ec3d9
PH
808 if (listname[0] == 0)
809 listname = string_sprintf("\"%s\"", *listptr);
810 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "%s",
811 string_open_failed(errno, "%s when checking %s", sss, listname));
812 }
813
814 /* Trailing comments are introduced by #, but in an address list or local
815 part list, the # must be preceded by white space or the start of the line,
816 because the # character is a legal character in local parts. */
817
818 while (Ufgets(filebuffer, sizeof(filebuffer), f) != NULL)
819 {
820 uschar *error;
821 uschar *sss = filebuffer;
822
823 while ((ss = Ustrchr(sss, '#')) != NULL)
824 {
825 if ((type != MCL_ADDRESS && type != MCL_LOCALPART) ||
826 ss == filebuffer || isspace(ss[-1]))
827 {
828 *ss = 0;
829 break;
830 }
831 sss = ss + 1;
832 }
833
834 ss = filebuffer + Ustrlen(filebuffer); /* trailing space */
835 while (ss > filebuffer && isspace(ss[-1])) ss--;
836 *ss = 0;
837
838 ss = filebuffer;
839 while (isspace(*ss)) ss++; /* leading space */
840
841 if (*ss == 0) continue; /* ignore empty */
842
843 file_yield = yield; /* positive yield */
844 sss = ss; /* for debugging */
845
846 if (*ss == '!') /* negation */
847 {
848 file_yield = (file_yield == OK)? FAIL : OK;
849 while (isspace((*(++ss))));
850 }
851
852 switch ((func)(arg, ss, valueptr, &error))
853 {
854 case OK:
72934ba7
JH
855 (void)fclose(f);
856 HDEBUG(D_lists) debug_printf("%s %s (matched \"%s\" in %s)\n", ot,
857 yield == OK ? "yes" : "no", sss, filename);
858 return file_yield;
059ec3d9
PH
859
860 case DEFER:
72934ba7
JH
861 if (!error)
862 error = string_sprintf("DNS lookup of %s deferred", ss);
863 if (ignore_defer)
864 {
865 HDEBUG(D_lists) debug_printf("%s: item ignored by +ignore_defer\n",
866 error);
867 break;
868 }
869 (void)fclose(f);
870 if (include_defer)
871 {
872 log_write(0, LOG_MAIN, "%s: accepted by +include_defer", error);
873 return OK;
874 }
875 goto DEFER_RETURN;
876
877 case ERROR: /* host name lookup failed - this can only */
878 if (ignore_unknown) /* be for an incoming host (not outgoing) */
879 {
880 HDEBUG(D_lists) debug_printf("%s: item ignored by +ignore_unknown\n",
881 error);
882 }
883 else
884 {
885 HDEBUG(D_lists) debug_printf("%s %s (%s)\n", ot,
886 include_unknown? "yes":"no", error);
887 (void)fclose(f);
888 if (!include_unknown)
889 {
890 if (LOGGING(unknown_in_list))
891 log_write(0, LOG_MAIN, "list matching forced to fail: %s", error);
892 return FAIL;
893 }
894 log_write(0, LOG_MAIN, "%s: accepted by +include_unknown", error);
895 return OK;
896 }
059ec3d9
PH
897 }
898 }
899
900 /* At the end of the file, leave the yield setting at the final setting
901 for the file, in case this is the last item in the list. */
902
903 yield = file_yield;
f1e894f3 904 (void)fclose(f);
059ec3d9
PH
905 }
906 } /* Loop for the next item on the top-level list */
907
908/* End of list reached: if the last item was negated yield OK, else FAIL. */
909
910HDEBUG(D_lists)
72934ba7
JH
911 debug_printf("%s %s (end of list)\n", ot, yield == OK ? "no":"yes");
912return yield == OK ? FAIL : OK;
059ec3d9 913
485aa451 914/* Something deferred */
059ec3d9
PH
915
916DEFER_RETURN:
485aa451 917HDEBUG(D_lists) debug_printf("%s list match deferred for %s\n", ot, sss);
059ec3d9
PH
918return DEFER;
919}
920
921
922/*************************************************
923* Match in colon-separated list *
924*************************************************/
925
926/* This function is used for domain lists and local part lists. It is not used
927for host lists or address lists, which have additional interpretation of the
928patterns. Some calls of it set sep > UCHAR_MAX in order to use its matching
929facilities on single items. When this is done, it arranges to set the numerical
930variables as a result of the match.
931
932This function is now just a short interface to match_check_list(), which does
933list scanning in a general way. A good compiler will optimize the tail
934recursion.
935
936Arguments:
937 s string to search for
938 listptr ptr to ptr to colon separated list of patterns, or NULL
939 sep a separator value for the list (see string_nextinlist())
940 anchorptr ptr to tree for named items, or NULL if no named items
941 cache_bits ptr to cache_bits for ditto, or NULL if not caching
942 type MCL_DOMAIN when matching a domain list
943 MCL_LOCALPART when matching a local part list (address lists
944 have their own function)
945 MCL_STRING for others (e.g. list of ciphers)
946 MCL_NOEXPAND (whose value is greater than any of them) may
947 be added to any value to suppress expansion of the list
948 caseless TRUE for (mostly) caseless matching - passed directly to
949 match_check_string()
950 valueptr pointer to where any lookup data is to be passed back,
951 or NULL (just passed on to match_check_string)
952
953Returns: OK if matched a non-negated item
954 OK if hit end of list after a negated item
955 FAIL if expansion force-failed
956 FAIL if matched a negated item
957 FAIL if hit end of list after a non-negated item
958 DEFER if a lookup deferred
959*/
960
961int
55414b25 962match_isinlist(const uschar *s, const uschar **listptr, int sep,
1dc92d5a 963 tree_node **anchorptr,
55414b25 964 unsigned int *cache_bits, int type, BOOL caseless, const uschar **valueptr)
059ec3d9
PH
965{
966unsigned int *local_cache_bits = cache_bits;
967check_string_block cb;
968cb.origsubject = s;
969cb.subject = caseless? string_copylc(s) : string_copy(s);
970cb.expand_setup = (sep > UCHAR_MAX)? 0 : -1;
971cb.use_partial = TRUE;
972cb.caseless = caseless;
973cb.at_is_special = (type == MCL_DOMAIN || type == MCL_DOMAIN + MCL_NOEXPAND);
974if (valueptr != NULL) *valueptr = NULL;
975return match_check_list(listptr, sep, anchorptr, &local_cache_bits,
976 check_string, &cb, type, s, valueptr);
977}
978
979
980
981/*************************************************
982* Match address to single address-list item *
983*************************************************/
984
985/* This function matches an address to an item from an address list. It is
986called from match_address_list() via match_check_list(). That is why most of
987its arguments are in an indirect block.
988
989Arguments:
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
994 returns ERROR)
995
996The 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
1003
1004Returns: OK for a match
1005 FAIL for no match
1006 DEFER if a lookup deferred
1007*/
1008
1009static int
55414b25 1010check_address(void *arg, const uschar *pattern, const uschar **valueptr, uschar **error)
059ec3d9
PH
1011{
1012check_address_block *cb = (check_address_block *)arg;
1013check_string_block csb;
1014int rc;
1015int expand_inc = 0;
1016unsigned int *null = NULL;
55414b25 1017const uschar *listptr;
059ec3d9 1018uschar *subject = cb->address;
55414b25
JH
1019const uschar *s;
1020uschar *pdomain, *sdomain;
059ec3d9
PH
1021
1022error = error; /* Keep clever compilers from complaining */
1023
333b9d0d 1024DEBUG(D_lists) debug_printf("address match test: subject=%s pattern=%s\n",
059ec3d9
PH
1025 subject, pattern);
1026
f0917727
PH
1027/* Find the subject's domain */
1028
1029sdomain = Ustrrchr(subject, '@');
1030
1031/* The only case where a subject may not have a domain is if the subject is
1032empty. Otherwise, a subject with no domain is a serious configuration error. */
1033
1034if (sdomain == NULL && *subject != 0)
1035 {
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);
1038 return FAIL;
1039 }
1040
8e669ac1 1041/* Handle a regular expression, which must match the entire incoming address.
90af77f4 1042This may be the empty address. */
059ec3d9
PH
1043
1044if (*pattern == '^')
1045 return match_check_string(subject, pattern, cb->expand_setup, TRUE,
1046 cb->caseless, FALSE, NULL);
1047
90af77f4
PH
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
1050must have a semicolon for it to be a lookup. */
059ec3d9
PH
1051
1052for (s = pattern; isalnum(*s) || *s == '-'; s++);
1053if (*s == '*') s++;
1054if (*s == '@') s++;
1055
8e669ac1 1056/* If it is a straight lookup, do a lookup for the whole address. This may be
90af77f4
PH
1057the empty address. Partial matching doesn't make sense here, so we ignore it,
1058but write a panic log entry. However, *@ matching will be honoured. */
059ec3d9
PH
1059
1060if (*s == ';')
1061 {
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, FALSE, cb->caseless, FALSE,
1066 valueptr);
1067 }
1068
8e669ac1
PH
1069/* For the remaining cases, an empty subject matches only an empty pattern,
1070because other patterns expect to have a local part and a domain to match
90af77f4
PH
1071against. */
1072
1073if (*subject == 0) return (*pattern == 0)? OK : FAIL;
1074
059ec3d9
PH
1075/* If the pattern starts with "@@" we have a split lookup, where the domain is
1076looked up to obtain a list of local parts. If the subject's local part is just
1077"*" (called from retry) the match always fails. */
1078
1079if (pattern[0] == '@' && pattern[1] == '@')
1080 {
1081 int watchdog = 50;
55414b25 1082 uschar *list, *ss;
059ec3d9
PH
1083 uschar buffer[1024];
1084
1085 if (sdomain == subject + 1 && *subject == '*') return FAIL;
1086
1087 /* Loop for handling chains. The last item in any list may be of the form
1088 ">name" in order to chain on to another list. */
1089
d7978c0f 1090 for (const uschar * key = sdomain + 1; key && watchdog-- > 0; )
059ec3d9
PH
1091 {
1092 int sep = 0;
1093
1094 if ((rc = match_check_string(key, pattern + 2, -1, TRUE, FALSE, FALSE,
55414b25 1095 CUSS &list)) != OK) return rc;
059ec3d9
PH
1096
1097 /* Check for chaining from the last item; set up the next key if one
1098 is found. */
1099
1100 ss = Ustrrchr(list, ':');
1101 if (ss == NULL) ss = list; else ss++;
1102 while (isspace(*ss)) ss++;
1103 if (*ss == '>')
1104 {
1105 *ss++ = 0;
1106 while (isspace(*ss)) ss++;
1107 key = string_copy(ss);
1108 }
1109 else key = NULL;
1110
1111 /* Look up the local parts provided by the list; negation is permitted.
1112 If a local part has to begin with !, a regex can be used. */
1113
55414b25 1114 while ((ss = string_nextinlist(CUSS &list, &sep, buffer, sizeof(buffer))))
059ec3d9
PH
1115 {
1116 int local_yield;
1117
1118 if (*ss == '!')
1119 {
1120 local_yield = FAIL;
1121 while (isspace((*(++ss))));
1122 }
1123 else local_yield = OK;
1124
1125 *sdomain = 0;
1126 rc = match_check_string(subject, ss, -1, TRUE, cb->caseless, FALSE,
1127 valueptr);
1128 *sdomain = '@';
1129
1130 switch(rc)
1131 {
1132 case OK:
1133 return local_yield;
1134
1135 case DEFER:
1136 return DEFER;
1137 }
1138 }
1139 }
1140
1141 /* End of chain loop; panic if too many times */
1142
1143 if (watchdog <= 0)
1144 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "Loop detected in lookup of "
1145 "local part of %s in %s", subject, pattern);
1146
1147 /* Otherwise the local part check has failed, so the whole match
1148 fails. */
1149
1150 return FAIL;
1151 }
1152
1153
1154/* We get here if the pattern is not a lookup or a regular expression. If it
1155contains an @ there is both a local part and a domain. */
1156
1157pdomain = Ustrrchr(pattern, '@');
1158if (pdomain != NULL)
1159 {
1160 int pllen, sllen;
1161
1162 /* If the domain in the pattern is empty or one of the special cases [] or
1163 mx_{any,primary,secondary}, and the local part in the pattern ends in "@",
1164 we have a pattern of the form <something>@@, <something>@@[], or
1165 <something>@@mx_{any,primary,secondary}. These magic "domains" are
1166 automatically interpreted in match_check_string. We just need to arrange that
1167 the leading @ is included in the domain. */
1168
1169 if (pdomain > pattern && pdomain[-1] == '@' &&
1170 (pdomain[1] == 0 ||
1171 Ustrcmp(pdomain+1, "[]") == 0 ||
1172 Ustrcmp(pdomain+1, "mx_any") == 0 ||
1173 Ustrcmp(pdomain+1, "mx_primary") == 0 ||
1174 Ustrcmp(pdomain+1, "mx_secondary") == 0))
1175 pdomain--;
1176
1177 pllen = pdomain - pattern;
1178 sllen = sdomain - subject;
1179
1180 /* Compare the local parts in the subject and the pattern */
1181
1182 if (*pattern == '*')
1183 {
1184 int cllen = pllen - 1;
1185 if (sllen < cllen) return FAIL;
fa0798c0
JH
1186 if (cb->caseless
1187 ? strncmpic(subject+sllen-cllen, pattern + 1, cllen) != 0
1188 : Ustrncmp(subject+sllen-cllen, pattern + 1, cllen) != 0)
059ec3d9 1189 return FAIL;
059ec3d9
PH
1190 if (cb->expand_setup > 0)
1191 {
1192 expand_nstring[cb->expand_setup] = subject;
1193 expand_nlength[cb->expand_setup] = sllen - cllen;
1194 expand_inc = 1;
1195 }
1196 }
1197 else
1198 {
1199 if (sllen != pllen) return FAIL;
fa0798c0
JH
1200 if (cb->caseless
1201 ? strncmpic(subject, pattern, sllen) != 0
1202 : Ustrncmp(subject, pattern, sllen) != 0) return FAIL;
059ec3d9
PH
1203 }
1204 }
1205
1206/* If the local part matched, or was not being checked, check the domain using
1207the generalized function, which supports file lookups (which may defer). The
1208original code read as follows:
1209
1210 return match_check_string(sdomain + 1,
fa0798c0 1211 pdomain ? pdomain + 1 : pattern,
059ec3d9
PH
1212 cb->expand_setup + expand_inc, TRUE, cb->caseless, TRUE, NULL);
1213
1214This supported only literal domains and *.x.y patterns. In order to allow for
1215named domain lists (so that you can right, for example, "senders=+xxxx"), it
1216was changed to use the list scanning function. */
1217
1218csb.origsubject = sdomain + 1;
fa0798c0 1219csb.subject = cb->caseless ? string_copylc(sdomain+1) : string_copy(sdomain+1);
059ec3d9
PH
1220csb.expand_setup = cb->expand_setup + expand_inc;
1221csb.use_partial = TRUE;
1222csb.caseless = cb->caseless;
1223csb.at_is_special = TRUE;
1224
fa0798c0
JH
1225listptr = pdomain ? pdomain + 1 : pattern;
1226if (valueptr) *valueptr = NULL;
059ec3d9
PH
1227
1228return 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 valueptr); /* where to pass back lookup data */
1238}
1239
1240
1241
1242
1243/*************************************************
1244* Test whether address matches address list *
1245*************************************************/
1246
1247/* This function is given an address and a list of things to match it against.
1248The list may contain individual addresses, regular expressions, lookup
1249specifications, and indirection via bare files. Negation is supported. The
1250address to check can consist of just a domain, which will then match only
1251domain items or items specified as *@domain.
1252
1253Domains are always lower cased before the match. Local parts are also lower
1254cased unless "caseless" is false. The work of actually scanning the list is
1255done by match_check_list(), with an appropriate block of arguments and a
1256callback to check_address(). During caseless matching, it will recognize
1257+caseful and revert to caseful matching.
1258
1259Arguments:
1260 address address to test
1261 caseless TRUE to start in caseless state
1262 expand TRUE to allow list expansion
1263 listptr list to check against
1264 cache_bits points to cache bits for named address lists, or NULL
1265 expand_setup controls setting up of $n variables - passed through
1266 to check_address (q.v.)
1267 sep separator character for the list;
1268 may be 0 to get separator from the list;
1269 may be UCHAR_MAX+1 for one-item list
1270 valueptr where to return a lookup value, or NULL
1271
1272Returns: OK for a positive match, or end list after a negation;
1273 FAIL for a negative match, or end list after non-negation;
1274 DEFER if a lookup deferred
1275*/
1276
1277int
55414b25
JH
1278match_address_list(const uschar *address, BOOL caseless, BOOL expand,
1279 const uschar **listptr, unsigned int *cache_bits, int expand_setup, int sep,
1280 const uschar **valueptr)
059ec3d9 1281{
059ec3d9
PH
1282check_address_block ab;
1283unsigned int *local_cache_bits = cache_bits;
f3ebb786 1284int len;
059ec3d9
PH
1285
1286/* RFC 2505 recommends that for spam checking, local parts should be caselessly
1287compared. Therefore, Exim now forces the entire address into lower case here,
1288provided that "caseless" is set. (It is FALSE for calls for matching rewriting
1289patterns.) Otherwise just the domain is lower cases. A magic item "+caseful" in
1290the list can be used to restore a caseful copy of the local part from the
1291original address. */
1292
f3ebb786
JH
1293if ((len = Ustrlen(address)) > 255) len = 255;
1294ab.address = string_copyn(address, len);
1295
1296for (uschar * p = ab.address + len - 1; p >= ab.address; p--)
059ec3d9
PH
1297 {
1298 if (!caseless && *p == '@') break;
1299 *p = tolower(*p);
1300 }
1301
1302/* If expand_setup is zero, we need to set up $0 to the whole thing, in
1303case there is a match. Can't use the built-in facilities of match_check_string
1304(via check_address), as we may just be calling that for part of the address
1305(the domain). */
1306
1307if (expand_setup == 0)
1308 {
1309 expand_nstring[0] = string_copy(address);
1310 expand_nlength[0] = Ustrlen(address);
1311 expand_setup++;
1312 }
1313
1314/* Set up the data to be passed ultimately to check_address. */
1315
1316ab.origaddress = address;
f3ebb786 1317/* ab.address is above */
059ec3d9
PH
1318ab.expand_setup = expand_setup;
1319ab.caseless = caseless;
1320
1321return match_check_list(listptr, sep, &addresslist_anchor, &local_cache_bits,
1322 check_address, &ab, MCL_ADDRESS + (expand? 0:MCL_NOEXPAND), address,
1323 valueptr);
1324}
1325
36d295f1
JH
1326/* Simpler version of match_address_list; always caseless, expanding,
1327no cache bits, no value-return.
1328
1329Arguments:
1330 address address to test
1331 listptr list to check against
1332 sep separator character for the list;
1333 may be 0 to get separator from the list;
1334 may be UCHAR_MAX+1 for one-item list
1335
1336Returns: OK for a positive match, or end list after a negation;
1337 FAIL for a negative match, or end list after non-negation;
1338 DEFER if a lookup deferred
1339*/
1340
1341int
1342match_address_list_basic(const uschar *address, const uschar **listptr, int sep)
1343{
1344return match_address_list(address, TRUE, TRUE, listptr, NULL, -1, sep, NULL);
1345}
1346
059ec3d9 1347/* End of match.c */