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