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