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