testcases for value return
[exim.git] / src / src / match.c
1 /*************************************************
2 * Exim - an Internet mail transport agent *
3 *************************************************/
4
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. */
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
16 strings, domains, and local parts. */
17
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 */
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
29 addresses. */
30
31 typedef struct check_address_block {
32 const uschar *origaddress; /* caseful; keep these two first, in */
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
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.
50
51 The 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
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).
66
67 Arguments:
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
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 @
89
90 Returns: OK if matched
91 FAIL if not matched
92 DEFER if lookup deferred
93 */
94
95 static int
96 check_string(void *arg, const uschar *pattern, const uschar **valueptr, uschar **error)
97 {
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;
102 uschar *s;
103 uschar *filename = NULL;
104 uschar *keyquery, *result, *semicolon;
105 void *handle;
106
107 error = error; /* Keep clever compilers from complaining */
108
109 if (valueptr != NULL) *valueptr = NULL; /* For non-lookup matches */
110
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
113 "caseless". */
114
115 s = string_copy(pattern[0] == '^' ? cb->origsubject : cb->subject);
116
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. */
119
120 expand_nmax = -1;
121 if (expand_setup == 0)
122 {
123 expand_nstring[0] = s; /* $0 (might be) the matched subject in full */
124 expand_nlength[0] = Ustrlen(s);
125 }
126 else if (expand_setup > 0) expand_setup--;
127
128 /* Regular expression match: compile, match, and set up $ variables if
129 required. */
130
131 if (pattern[0] == '^')
132 {
133 const pcre * re = regex_must_compile(pattern, cb->caseless, FALSE);
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;
142 }
143
144 /* Tail match */
145
146 if (pattern[0] == '*')
147 {
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;
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)
158 {
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;
162 }
163 if (valueptr) *valueptr = pattern - 1; /* "value" gets the (original) pattern */
164 return OK;
165 }
166
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. */
171
172 if (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 {
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)
187 {
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 */
190 return OK;
191 }
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;
202 const uschar *ss = pattern + 4;
203 const uschar *ignore_target_hosts = NULL;
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;
219 else if (*ss) goto NOT_AT_SPECIAL;
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 */
231 NULL, /* no dnssec request/require XXX ? */
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
241 if (rc != HOST_FOUND_LOCAL || secy)
242 if (prim || !removed) return FAIL;
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 */
246 return OK;
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
260 NOT_AT_SPECIAL:
261
262 /* This is an exact string match if there is no semicolon in the pattern. */
263
264 if ((semicolon = Ustrchr(pattern, ';')) == NULL)
265 {
266 if (cb->caseless ? strcmpic(s, pattern) != 0 : Ustrcmp(s, pattern) != 0)
267 return FAIL;
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 */
270 return OK;
271
272 /*
273 XXX looks like $0 may be usable
274 */
275 }
276
277 /* Otherwise we have a lookup item. The lookup type, including partial, etc. is
278 the part of the string preceding the semicolon. */
279
280 *semicolon = 0;
281 search_type = search_findtype_partial(pattern, &partial, &affix, &affixlen,
282 &starflags, &opts);
283 *semicolon = ';';
284 if (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
288 up user@domain for sender rejection). There's a flag to disable it. */
289
290 if (!cb->use_partial) partial = -1;
291
292 /* Set the parameters for the three different kinds of lookup. */
293
294 keyquery = semicolon + 1;
295 Uskip_whitespace(&keyquery);
296
297 if (mac_islookup(search_type, lookup_absfilequery))
298 {
299 filename = keyquery;
300 while (*keyquery && !isspace(*keyquery)) keyquery++;
301 filename = string_copyn(filename, keyquery - filename);
302 Uskip_whitespace(&keyquery);
303 }
304
305 else if (!mac_islookup(search_type, lookup_querystyle))
306 {
307 filename = keyquery;
308 keyquery = s;
309 }
310
311 /* Now do the actual lookup; throw away the data returned unless it was asked
312 for; partial matching is all handled inside search_find(). Note that there is
313 no search_close() because of the caching arrangements. */
314
315 if (!(handle = search_open(filename, search_type, 0, NULL, NULL)))
316 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "%s", search_error_message);
317 result = search_find(handle, filename, keyquery, partial, affix, affixlen,
318 starflags, &expand_setup, opts);
319
320 if (!result) return f.search_find_defer ? DEFER : FAIL;
321 if (valueptr) *valueptr = result;
322
323 expand_nmax = expand_setup;
324 return 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
334 pass the arguments individually. It places them in a check_string_block
335 structure, and then calls check_string().
336
337 Arguments:
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
347 Returns: OK if matched
348 FAIL if not matched
349 DEFER if lookup deferred
350 */
351
352 int
353 match_check_string(const uschar *s, const uschar *pattern, int expand_setup,
354 BOOL use_partial, BOOL caseless, BOOL at_is_special, const uschar **valueptr)
355 {
356 check_string_block cb;
357 cb.origsubject = s;
358 cb.subject = caseless? string_copylc(s) : string_copy(s);
359 cb.expand_setup = expand_setup;
360 cb.use_partial = use_partial;
361 cb.caseless = caseless;
362 cb.at_is_special = at_is_special;
363 return 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
373 key that was found, because other lookups of different keys on the same list
374 may occur. This function has knowledge of the different lookup types, and
375 extracts the appropriate key.
376
377 Arguments:
378 arg the check block
379 type MCL_STRING, MCL_DOMAIN, MCL_HOST, MCL_ADDRESS, or MCL_LOCALPART
380 */
381
382 static const uschar *
383 get_check_key(void *arg, int type)
384 {
385 switch(type)
386 {
387 case MCL_STRING:
388 case MCL_DOMAIN:
389 case MCL_LOCALPART:
390 return ((check_string_block *)arg)->subject;
391
392 case MCL_HOST:
393 return ((check_host_block *)arg)->host_address;
394
395 case MCL_ADDRESS:
396 return ((check_address_block *)arg)->address;
397 }
398 return 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
408 each item in the list. It is called from the functions that match domains,
409 local parts, hosts, and addresses, because its overall structure is the same in
410 all cases. However, the details of each particular match is different, so it
411 calls back to a given function do perform an actual match.
412
413 We can't quite keep the different types anonymous here because they permit
414 different special cases. A pity.
415
416 If a list item starts with !, that implies negation if the subject matches the
417 rest of the item (ignoring white space after the !). The result when the end of
418 the list is reached is FALSE unless the last item on the list is negated, in
419 which case it is TRUE. A file name in the list causes its lines to be
420 interpolated as if items in the list. An item starting with + is a named
421 sublist, obtained by searching the tree pointed to by anchorptr, with possible
422 cached match results in cache_bits.
423
424 Arguments:
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
443 Returns: 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
448 DEFER if a something deferred or expansion failed
449 */
450
451 int
452 match_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)
455 {
456 int yield = OK;
457 unsigned int *original_cache_bits = *cache_ptr;
458 BOOL include_unknown = FALSE;
459 BOOL ignore_unknown = FALSE;
460 BOOL include_defer = FALSE;
461 BOOL ignore_defer = FALSE;
462 const uschar *list;
463 uschar *sss;
464 uschar *ot = NULL;
465
466 /* Save time by not scanning for the option name when we don't need it. */
467
468 HDEBUG(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
475 an unnamed list. */
476
477 if (!*listptr)
478 {
479 HDEBUG(D_lists) if (ot) debug_printf("%s no (option unset)\n", ot);
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,
485 if the type value is greater than or equal to than MCL_NOEXPAND, do not expand
486 the list. */
487
488 if (type >= MCL_NOEXPAND)
489 {
490 list = *listptr;
491 type -= MCL_NOEXPAND; /* Remove the "no expand" flag */
492 }
493 else
494 {
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
498 if (type == MCL_DOMAIN && !deliver_domain)
499 {
500 check_string_block *cb = (check_string_block *)arg;
501 deliver_domain = string_copy(cb->subject);
502 list = expand_cstring(*listptr);
503 deliver_domain = NULL;
504 }
505 else
506 list = expand_cstring(*listptr);
507
508 if (!list)
509 {
510 if (f.expand_string_forcedfail)
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
524 HDEBUG(D_any) if (!ot) ot = string_sprintf("%s in \"%s\"?", name, list);
525
526 /* Now scan the list and process each item in turn, until one of them matches,
527 or we hit an error. */
528
529 while ((sss = string_nextinlist(&list, &sep, NULL, 0)))
530 {
531 uschar * ss = sss;
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, '@');
544
545 if (at)
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;
559 Ustrcpy(US cb->subject, cb->origsubject);
560 cb->caseless = FALSE;
561 continue;
562 }
563 }
564
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". */
568
569 else if (type == MCL_HOST && *ss == '+')
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 }
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 }
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 }
605 else
606 yield = OK;
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 {
614 if (*ss == '+' && anchorptr)
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;
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" : "",
631 ss);
632 return DEFER;
633 }
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
645 if (use_cache_bits)
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
669 if (!use_cache_bits)
670 *cache_ptr = NULL;
671 else
672 {
673 use_cache_bits[offset] |= bits << shift;
674
675 if (valueptr)
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;
684 p = store_get(sizeof(namedlist_cacheblock), FALSE);
685 p->key = string_copy(get_check_key(arg, type));
686
687
688 p->data = *valueptr ? string_copy(*valueptr) : NULL;
689 store_pool = old_pool;
690
691 p->next = nb->cache_data;
692 nb->cache_data = p;
693 if (*valueptr)
694 DEBUG(D_lists) debug_printf("data from lookup saved for "
695 "cache for %s: key '%s' value '%s'\n", ss, p->key, *valueptr);
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",
707 (bits & (-bits)) == bits ? "yes" : "no", ss);
708
709 cached = US" - cached";
710 if (valueptr)
711 {
712 const uschar *key = get_check_key(arg, type);
713
714 for (namedlist_cacheblock * p = nb->cache_data; p; p = p->next)
715 if (Ustrcmp(key, p->key) == 0)
716 {
717 *valueptr = p->data;
718 break;
719 }
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 {
739 uschar * error = NULL;
740 switch ((func)(arg, ss, valueptr, &error))
741 {
742 case OK:
743 HDEBUG(D_lists) debug_printf("%s %s (matched \"%s\")\n", ot,
744 (yield == OK)? "yes" : "no", sss);
745 return yield;
746
747 case DEFER:
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;
763
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
767 which it was. */
768
769 case ERROR:
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 }
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 */
798 uschar * filename = ss;
799 FILE * f = Ufopen(filename, "rb");
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
805 if (!f)
806 {
807 uschar * listname = readconf_find_option(listptr);
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:
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;
859
860 case DEFER:
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 }
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;
904 (void)fclose(f);
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
910 HDEBUG(D_lists)
911 debug_printf("%s %s (end of list)\n", ot, yield == OK ? "no":"yes");
912 return yield == OK ? FAIL : OK;
913
914 /* Something deferred */
915
916 DEFER_RETURN:
917 HDEBUG(D_lists) debug_printf("%s list match deferred for %s\n", ot, sss);
918 return 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
927 for host lists or address lists, which have additional interpretation of the
928 patterns. Some calls of it set sep > UCHAR_MAX in order to use its matching
929 facilities on single items. When this is done, it arranges to set the numerical
930 variables as a result of the match.
931
932 This function is now just a short interface to match_check_list(), which does
933 list scanning in a general way. A good compiler will optimize the tail
934 recursion.
935
936 Arguments:
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
953 Returns: 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
961 int
962 match_isinlist(const uschar *s, const uschar **listptr, int sep,
963 tree_node **anchorptr,
964 unsigned int *cache_bits, int type, BOOL caseless, const uschar **valueptr)
965 {
966 unsigned int *local_cache_bits = cache_bits;
967 check_string_block cb;
968 cb.origsubject = s;
969 cb.subject = caseless? string_copylc(s) : string_copy(s);
970 cb.expand_setup = (sep > UCHAR_MAX)? 0 : -1;
971 cb.use_partial = TRUE;
972 cb.caseless = caseless;
973 cb.at_is_special = (type == MCL_DOMAIN || type == MCL_DOMAIN + MCL_NOEXPAND);
974 if (valueptr != NULL) *valueptr = NULL;
975 return 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
986 called from match_address_list() via match_check_list(). That is why most of
987 its arguments are in an indirect block.
988
989 Arguments:
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
996 The argument block contains:
997 address the start of the subject address; when called from retry.c
998 it may be *@domain if the local part isn't relevant
999 origaddress the original, un-case-forced address (not used here, but used
1000 in match_check_list() when +caseful is encountered)
1001 expand_setup controls setting up of $n variables
1002 caseless TRUE for caseless local part matching
1003
1004 Returns: OK for a match
1005 FAIL for no match
1006 DEFER if a lookup deferred
1007 */
1008
1009 static int
1010 check_address(void *arg, const uschar *pattern, const uschar **valueptr, uschar **error)
1011 {
1012 check_address_block *cb = (check_address_block *)arg;
1013 check_string_block csb;
1014 int rc;
1015 int expand_inc = 0;
1016 unsigned int *null = NULL;
1017 const uschar *listptr;
1018 uschar *subject = cb->address;
1019 const uschar *s;
1020 uschar *pdomain, *sdomain;
1021
1022 error = error; /* Keep clever compilers from complaining */
1023
1024 DEBUG(D_lists) debug_printf("address match test: subject=%s pattern=%s\n",
1025 subject, pattern);
1026
1027 /* Find the subject's domain */
1028
1029 sdomain = Ustrrchr(subject, '@');
1030
1031 /* The only case where a subject may not have a domain is if the subject is
1032 empty. Otherwise, a subject with no domain is a serious configuration error. */
1033
1034 if (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
1041 /* Handle a regular expression, which must match the entire incoming address.
1042 This may be the empty address. */
1043
1044 if (*pattern == '^')
1045 return match_check_string(subject, pattern, cb->expand_setup, TRUE,
1046 cb->caseless, FALSE, NULL);
1047
1048 /* Handle a pattern that is just a lookup. Skip over possible lookup names
1049 (letters, digits, hyphens). Skip over a possible * or *@ at the end. Then we
1050 must have a semicolon for it to be a lookup. */
1051
1052 for (s = pattern; isalnum(*s) || *s == '-'; s++);
1053 if (*s == '*') s++;
1054 if (*s == '@') s++;
1055
1056 /* If it is a straight lookup, do a lookup for the whole address. This may be
1057 the empty address. Partial matching doesn't make sense here, so we ignore it,
1058 but write a panic log entry. However, *@ matching will be honoured. */
1059
1060 if (*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
1069 /* For the remaining cases, an empty subject matches only an empty pattern,
1070 because other patterns expect to have a local part and a domain to match
1071 against. */
1072
1073 if (*subject == 0) return (*pattern == 0)? OK : FAIL;
1074
1075 /* If the pattern starts with "@@" we have a split lookup, where the domain is
1076 looked 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
1079 if (pattern[0] == '@' && pattern[1] == '@')
1080 {
1081 int watchdog = 50;
1082 uschar *list, *ss;
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
1090 for (const uschar * key = sdomain + 1; key && watchdog-- > 0; )
1091 {
1092 int sep = 0;
1093
1094 if ((rc = match_check_string(key, pattern + 2, -1, TRUE, FALSE, FALSE,
1095 CUSS &list)) != OK) return rc;
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
1114 while ((ss = string_nextinlist(CUSS &list, &sep, buffer, sizeof(buffer))))
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
1155 contains an @ there is both a local part and a domain. */
1156
1157 pdomain = Ustrrchr(pattern, '@');
1158 if (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;
1186 if (cb->caseless
1187 ? strncmpic(subject+sllen-cllen, pattern + 1, cllen) != 0
1188 : Ustrncmp(subject+sllen-cllen, pattern + 1, cllen) != 0)
1189 return FAIL;
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;
1200 if (cb->caseless
1201 ? strncmpic(subject, pattern, sllen) != 0
1202 : Ustrncmp(subject, pattern, sllen) != 0) return FAIL;
1203 }
1204 }
1205
1206 /* If the local part matched, or was not being checked, check the domain using
1207 the generalized function, which supports file lookups (which may defer). The
1208 original code read as follows:
1209
1210 return match_check_string(sdomain + 1,
1211 pdomain ? pdomain + 1 : pattern,
1212 cb->expand_setup + expand_inc, TRUE, cb->caseless, TRUE, NULL);
1213
1214 This supported only literal domains and *.x.y patterns. In order to allow for
1215 named domain lists (so that you can right, for example, "senders=+xxxx"), it
1216 was changed to use the list scanning function. */
1217
1218 csb.origsubject = sdomain + 1;
1219 csb.subject = cb->caseless ? string_copylc(sdomain+1) : string_copy(sdomain+1);
1220 csb.expand_setup = cb->expand_setup + expand_inc;
1221 csb.use_partial = TRUE;
1222 csb.caseless = cb->caseless;
1223 csb.at_is_special = TRUE;
1224
1225 listptr = pdomain ? pdomain + 1 : pattern;
1226 if (valueptr) *valueptr = NULL;
1227
1228 return 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.
1248 The list may contain individual addresses, regular expressions, lookup
1249 specifications, and indirection via bare files. Negation is supported. The
1250 address to check can consist of just a domain, which will then match only
1251 domain items or items specified as *@domain.
1252
1253 Domains are always lower cased before the match. Local parts are also lower
1254 cased unless "caseless" is false. The work of actually scanning the list is
1255 done by match_check_list(), with an appropriate block of arguments and a
1256 callback to check_address(). During caseless matching, it will recognize
1257 +caseful and revert to caseful matching.
1258
1259 Arguments:
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
1272 Returns: 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
1277 int
1278 match_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)
1281 {
1282 check_address_block ab;
1283 unsigned int *local_cache_bits = cache_bits;
1284 int len;
1285
1286 /* RFC 2505 recommends that for spam checking, local parts should be caselessly
1287 compared. Therefore, Exim now forces the entire address into lower case here,
1288 provided that "caseless" is set. (It is FALSE for calls for matching rewriting
1289 patterns.) Otherwise just the domain is lower cases. A magic item "+caseful" in
1290 the list can be used to restore a caseful copy of the local part from the
1291 original address. */
1292
1293 if ((len = Ustrlen(address)) > 255) len = 255;
1294 ab.address = string_copyn(address, len);
1295
1296 for (uschar * p = ab.address + len - 1; p >= ab.address; p--)
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
1303 case 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
1307 if (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
1316 ab.origaddress = address;
1317 /* ab.address is above */
1318 ab.expand_setup = expand_setup;
1319 ab.caseless = caseless;
1320
1321 return 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
1326 /* Simpler version of match_address_list; always caseless, expanding,
1327 no cache bits, no value-return.
1328
1329 Arguments:
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
1336 Returns: 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
1341 int
1342 match_address_list_basic(const uschar *address, const uschar **listptr, int sep)
1343 {
1344 return match_address_list(address, TRUE, TRUE, listptr, NULL, -1, sep, NULL);
1345 }
1346
1347 /* End of match.c */