Note post-DATA ACL ordering.
[exim.git] / src / src / match.c
1 /*************************************************
2 * Exim - an Internet mail transport agent *
3 *************************************************/
4
5 /* Copyright (c) University of Cambridge 1995 - 2009 */
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 uschar *origsubject; /* caseful; keep these two first, in */
19 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 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, uschar *pattern, uschar **valueptr, uschar **error)
96 {
97 check_string_block *cb = (check_string_block *)arg;
98 int search_type, partial, affixlen, starflags;
99 int expand_setup = cb->expand_setup;
100 uschar *affix;
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 = (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, CS 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 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)
182 if (Ustrncmp(ip->address, s+1, slen - 2) == 0
183 && ip->address[slen - 2] == 0)
184 return OK;
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;
195 uschar *ss = pattern + 4;
196 uschar *ignore_target_hosts = NULL;
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 */
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);
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 while (isspace(*keyquery)) keyquery++;
280
281 if (mac_islookup(search_type, lookup_absfilequery))
282 {
283 filename = keyquery;
284 while (*keyquery != 0 && !isspace(*keyquery)) keyquery++;
285 filename = string_copyn(filename, keyquery - filename);
286 while (isspace(*keyquery)) 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 handle = search_open(filename, search_type, 0, NULL, NULL);
300 if (handle == NULL) log_write(0, LOG_MAIN|LOG_PANIC_DIE, "%s",
301 search_error_message);
302 result = search_find(handle, filename, keyquery, partial, affix, affixlen,
303 starflags, &expand_setup);
304
305 if (result == NULL) return search_find_defer? DEFER : FAIL;
306 if (valueptr != NULL) *valueptr = result;
307
308 expand_nmax = expand_setup;
309 return OK;
310 }
311
312
313
314 /*************************************************
315 * Public interface to check_string() *
316 *************************************************/
317
318 /* This function is called from several places where is it most convenient to
319 pass the arguments individually. It places them in a check_string_block
320 structure, and then calls check_string().
321
322 Arguments:
323 s the subject string to be checked
324 pattern the pattern to check it against
325 expand_setup expansion setup option (see check_string())
326 use_partial if FALSE, override any partial- search types
327 caseless TRUE for caseless matching where possible
328 at_is_special TRUE to recognize @, @[], etc.
329 valueptr if not NULL, and a file lookup was done, return the result
330 here instead of discarding it; else set it to point to NULL
331
332 Returns: OK if matched
333 FAIL if not matched
334 DEFER if lookup deferred
335 */
336
337 int
338 match_check_string(uschar *s, uschar *pattern, int expand_setup,
339 BOOL use_partial, BOOL caseless, BOOL at_is_special, uschar **valueptr)
340 {
341 check_string_block cb;
342 cb.origsubject = s;
343 cb.subject = caseless? string_copylc(s) : string_copy(s);
344 cb.expand_setup = expand_setup;
345 cb.use_partial = use_partial;
346 cb.caseless = caseless;
347 cb.at_is_special = at_is_special;
348 return check_string(&cb, pattern, valueptr, NULL);
349 }
350
351
352
353 /*************************************************
354 * Get key string from check block *
355 *************************************************/
356
357 /* When caching the data from a lookup for a named list, we have to save the
358 key that was found, because other lookups of different keys on the same list
359 may occur. This function has knowledge of the different lookup types, and
360 extracts the appropriate key.
361
362 Arguments:
363 arg the check block
364 type MCL_STRING, MCL_DOMAIN, MCL_HOST, MCL_ADDRESS, or MCL_LOCALPART
365 */
366
367 static uschar *
368 get_check_key(void *arg, int type)
369 {
370 switch(type)
371 {
372 case MCL_STRING:
373 case MCL_DOMAIN:
374 case MCL_LOCALPART:
375 return ((check_string_block *)arg)->subject;
376
377 case MCL_HOST:
378 return ((check_host_block *)arg)->host_address;
379
380 case MCL_ADDRESS:
381 return ((check_address_block *)arg)->address;
382 }
383 return US""; /* In practice, should never happen */
384 }
385
386
387
388 /*************************************************
389 * Scan list and run matching function *
390 *************************************************/
391
392 /* This function scans a list of patterns, and runs a matching function for
393 each item in the list. It is called from the functions that match domains,
394 local parts, hosts, and addresses, because its overall structure is the same in
395 all cases. However, the details of each particular match is different, so it
396 calls back to a given function do perform an actual match.
397
398 We can't quite keep the different types anonymous here because they permit
399 different special cases. A pity.
400
401 If a list item starts with !, that implies negation if the subject matches the
402 rest of the item (ignoring white space after the !). The result when the end of
403 the list is reached is FALSE unless the last item on the list is negated, in
404 which case it is TRUE. A file name in the list causes its lines to be
405 interpolated as if items in the list. An item starting with + is a named
406 sublist, obtained by searching the tree pointed to by anchorptr, with possible
407 cached match results in cache_bits.
408
409 Arguments:
410 listptr pointer to the pointer to the list
411 sep separator character for string_nextinlist();
412 normally zero for a standard list;
413 sometimes UCHAR_MAX+1 for single items;
414 anchorptr -> tree of named items, or NULL if no named items
415 cache_ptr pointer to pointer to cache bits for named items, or
416 pointer to NULL if not caching; may get set NULL if an
417 uncacheable named list is encountered
418 func function to call back to do one test
419 arg pointer to pass to the function; the string to be matched is
420 in the structure it points to
421 type MCL_STRING, MCL_DOMAIN, MCL_HOST, MCL_ADDRESS, or MCL_LOCALPART
422 these are used for some special handling
423 MCL_NOEXPAND (whose value is greater than any of them) may
424 be added to any value to suppress expansion of the list
425 name string to use in debugging info
426 valueptr where to pass back data from a lookup
427
428 Returns: OK if matched a non-negated item
429 OK if hit end of list after a negated item
430 FAIL if expansion force-failed
431 FAIL if matched a negated item
432 FAIL if hit end of list after a non-negated item
433 DEFER if a something deferred or expansion failed
434 */
435
436 int
437 match_check_list(uschar **listptr, int sep, tree_node **anchorptr,
438 unsigned int **cache_ptr, int (*func)(void *,uschar *,uschar **,uschar **),
439 void *arg, int type, uschar *name, uschar **valueptr)
440 {
441 int yield = OK;
442 unsigned int *original_cache_bits = *cache_ptr;
443 BOOL include_unknown = FALSE;
444 BOOL ignore_unknown = FALSE;
445 BOOL include_defer = FALSE;
446 BOOL ignore_defer = FALSE;
447 uschar *list;
448 uschar *sss;
449 uschar *ot = NULL;
450 uschar buffer[1024];
451
452 /* Save time by not scanning for the option name when we don't need it. */
453
454 HDEBUG(D_any)
455 {
456 uschar *listname = readconf_find_option(listptr);
457 if (listname[0] != 0) ot = string_sprintf("%s in %s?", name, listname);
458 }
459
460 /* If the list is empty, the answer is no. Skip the debugging output for
461 an unnamed list. */
462
463 if (*listptr == NULL)
464 {
465 HDEBUG(D_lists)
466 {
467 if (ot != NULL) debug_printf("%s no (option unset)\n", ot);
468 }
469 return FAIL;
470 }
471
472 /* Expand the list before we scan it. A forced expansion gives the answer
473 "not in list"; other expansion errors cause DEFER to be returned. However,
474 if the type value is greater than or equal to than MCL_NOEXPAND, do not expand
475 the list. */
476
477 if (type >= MCL_NOEXPAND)
478 {
479 list = *listptr;
480 type -= MCL_NOEXPAND; /* Remove the "no expand" flag */
481 }
482 else
483 {
484 /* If we are searching a domain list, and $domain is not set, set it to the
485 subject that is being sought for the duration of the expansion. */
486
487 if (type == MCL_DOMAIN && deliver_domain == NULL)
488 {
489 check_string_block *cb = (check_string_block *)arg;
490 deliver_domain = cb->subject;
491 list = expand_string(*listptr);
492 deliver_domain = NULL;
493 }
494
495 else list = expand_string(*listptr);
496
497 if (list == NULL)
498 {
499 if (expand_string_forcedfail)
500 {
501 HDEBUG(D_lists) debug_printf("expansion of \"%s\" forced failure: "
502 "assume not in this list\n", *listptr);
503 return FAIL;
504 }
505 log_write(0, LOG_MAIN|LOG_PANIC, "failed to expand \"%s\" while checking "
506 "a list: %s", *listptr, expand_string_message);
507 return DEFER;
508 }
509 }
510
511 /* For an unnamed list, use the expanded version in comments */
512
513 HDEBUG(D_any)
514 {
515 if (ot == NULL) ot = string_sprintf("%s in \"%s\"?", name, list);
516 }
517
518 /* Now scan the list and process each item in turn, until one of them matches,
519 or we hit an error. */
520
521 while ((sss = string_nextinlist(&list, &sep, buffer, sizeof(buffer))) != NULL)
522 {
523 uschar *ss = sss;
524
525 /* Address lists may contain +caseful, to restore caseful matching of the
526 local part. We have to know the layout of the control block, unfortunately.
527 The lower cased address is in a temporary buffer, so we just copy the local
528 part back to the start of it (if a local part exists). */
529
530 if (type == MCL_ADDRESS)
531 {
532 if (Ustrcmp(ss, "+caseful") == 0)
533 {
534 check_address_block *cb = (check_address_block *)arg;
535 uschar *at = Ustrrchr(cb->origaddress, '@');
536 if (at != NULL)
537 Ustrncpy(cb->address, cb->origaddress, at - cb->origaddress);
538 cb->caseless = FALSE;
539 continue;
540 }
541 }
542
543 /* Similar processing for local parts */
544
545 else if (type == MCL_LOCALPART)
546 {
547 if (Ustrcmp(ss, "+caseful") == 0)
548 {
549 check_string_block *cb = (check_string_block *)arg;
550 Ustrcpy(cb->subject, cb->origsubject);
551 cb->caseless = FALSE;
552 continue;
553 }
554 }
555
556 /* If the host item is "+include_unknown" or "+ignore_unknown", remember it
557 in case there's a subsequent failed reverse lookup. There is similar
558 processing for "defer". */
559
560 else if (type == MCL_HOST && *ss == '+')
561 {
562 if (Ustrcmp(ss, "+include_unknown") == 0)
563 {
564 include_unknown = TRUE;
565 ignore_unknown = FALSE;
566 continue;
567 }
568 if (Ustrcmp(ss, "+ignore_unknown") == 0)
569 {
570 ignore_unknown = TRUE;
571 include_unknown = FALSE;
572 continue;
573 }
574 if (Ustrcmp(ss, "+include_defer") == 0)
575 {
576 include_defer = TRUE;
577 ignore_defer = FALSE;
578 continue;
579 }
580 if (Ustrcmp(ss, "+ignore_defer") == 0)
581 {
582 ignore_defer = TRUE;
583 include_defer = FALSE;
584 continue;
585 }
586 }
587
588 /* Starting with ! specifies a negative item. It is theoretically possible
589 for a local part to start with !. In that case, a regex has to be used. */
590
591 if (*ss == '!')
592 {
593 yield = FAIL;
594 while (isspace((*(++ss))));
595 }
596 else yield = OK;
597
598 /* If the item does not begin with '/', it might be a + item for a named
599 list. Otherwise, it is just a single list entry that has to be matched.
600 We recognize '+' only when supplied with a tree of named lists. */
601
602 if (*ss != '/')
603 {
604 if (*ss == '+' && anchorptr != NULL)
605 {
606 int bits = 0;
607 int offset = 0;
608 int shift = 0;
609 unsigned int *use_cache_bits = original_cache_bits;
610 uschar *cached = US"";
611 namedlist_block *nb;
612 tree_node *t = tree_search(*anchorptr, ss+1);
613
614 if (t == NULL)
615 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "unknown named%s list \"%s\"",
616 (type == MCL_DOMAIN)? " domain" :
617 (type == MCL_HOST)? " host" :
618 (type == MCL_ADDRESS)? " address" :
619 (type == MCL_LOCALPART)? " local part" : "",
620 ss);
621 nb = t->data.ptr;
622
623 /* If the list number is negative, it means that this list is not
624 cacheable because it contains expansion items. */
625
626 if (nb->number < 0) use_cache_bits = NULL;
627
628 /* If we have got a cache pointer, get the bits. This is not an "else"
629 because the pointer may be NULL from the start if caching is not
630 required. */
631
632 if (use_cache_bits != NULL)
633 {
634 offset = (nb->number)/16;
635 shift = ((nb->number)%16)*2;
636 bits = use_cache_bits[offset] & (3 << shift);
637 }
638
639 /* Not previously tested or no cache - run the full test */
640
641 if (bits == 0)
642 {
643 switch (match_check_list(&(nb->string), 0, anchorptr, &use_cache_bits,
644 func, arg, type, name, valueptr))
645 {
646 case OK: bits = 1; break;
647 case FAIL: bits = 3; break;
648 case DEFER: goto DEFER_RETURN;
649 }
650
651 /* If this list was uncacheable, or a sublist turned out to be
652 uncacheable, the value of use_cache_bits will now be NULL, even if it
653 wasn't before. Ensure that this is passed up to the next level.
654 Otherwise, remember the result of the search in the cache. */
655
656 if (use_cache_bits == NULL)
657 {
658 *cache_ptr = NULL;
659 }
660 else
661 {
662 use_cache_bits[offset] |= bits << shift;
663
664 if (valueptr != NULL)
665 {
666 int old_pool = store_pool;
667 namedlist_cacheblock *p;
668
669 /* Cached data for hosts persists over more than one message,
670 so we use the permanent store pool */
671
672 store_pool = POOL_PERM;
673 p = store_get(sizeof(namedlist_cacheblock));
674 p->key = string_copy(get_check_key(arg, type));
675
676
677 p->data = (*valueptr == NULL)? NULL : string_copy(*valueptr);
678 store_pool = old_pool;
679
680 p->next = nb->cache_data;
681 nb->cache_data = p;
682 if (*valueptr != NULL)
683 {
684 DEBUG(D_lists) debug_printf("data from lookup saved for "
685 "cache for %s: %s\n", ss, *valueptr);
686 }
687 }
688 }
689 }
690
691 /* Previously cached; to find a lookup value, search a chain of values
692 and compare keys. Typically, there is only one such, but it is possible
693 for different keys to have matched the same named list. */
694
695 else
696 {
697 DEBUG(D_lists) debug_printf("cached %s match for %s\n",
698 ((bits & (-bits)) == bits)? "yes" : "no", ss);
699 cached = US" - cached";
700 if (valueptr != NULL)
701 {
702 uschar *key = get_check_key(arg, type);
703 namedlist_cacheblock *p;
704 for (p = nb->cache_data; p != NULL; p = p->next)
705 {
706 if (Ustrcmp(key, p->key) == 0)
707 {
708 *valueptr = p->data;
709 break;
710 }
711 }
712 DEBUG(D_lists) debug_printf("cached lookup data = %s\n", *valueptr);
713 }
714 }
715
716 /* Result of test is indicated by value in bits. For each test, we
717 have 00 => untested, 01 => tested yes, 11 => tested no. */
718
719 if ((bits & (-bits)) == bits) /* Only one of the two bits is set */
720 {
721 HDEBUG(D_lists) debug_printf("%s %s (matched \"%s\"%s)\n", ot,
722 (yield == OK)? "yes" : "no", sss, cached);
723 return yield;
724 }
725 }
726
727 /* Run the provided function to do the individual test. */
728
729 else
730 {
731 uschar *error = NULL;
732 switch ((func)(arg, ss, valueptr, &error))
733 {
734 case OK:
735 HDEBUG(D_lists) debug_printf("%s %s (matched \"%s\")\n", ot,
736 (yield == OK)? "yes" : "no", sss);
737 return yield;
738
739 case DEFER:
740 if (error == NULL)
741 error = string_sprintf("DNS lookup of %s deferred", ss);
742 if (ignore_defer)
743 {
744 HDEBUG(D_lists) debug_printf("%s: item ignored by +ignore_defer\n",
745 error);
746 break;
747 }
748 if (include_defer)
749 {
750 log_write(0, LOG_MAIN, "%s: accepted by +include_defer", error);
751 return OK;
752 }
753 goto DEFER_RETURN;
754
755 /* The ERROR return occurs when checking hosts, when either a forward
756 or reverse lookup has failed. It can also occur in a match_ip list if a
757 non-IP address item is encountered. The error string gives details of
758 which it was. */
759
760 case ERROR:
761 if (ignore_unknown)
762 {
763 HDEBUG(D_lists) debug_printf("%s: item ignored by +ignore_unknown\n",
764 error);
765 }
766 else
767 {
768 HDEBUG(D_lists) debug_printf("%s %s (%s)\n", ot,
769 include_unknown? "yes":"no", error);
770 if (!include_unknown)
771 {
772 if ((log_extra_selector & LX_unknown_in_list) != 0)
773 log_write(0, LOG_MAIN, "list matching forced to fail: %s", error);
774 return FAIL;
775 }
776 log_write(0, LOG_MAIN, "%s: accepted by +include_unknown", error);
777 return OK;
778 }
779 }
780 }
781 }
782
783 /* If the item is a file name, we read the file and do a match attempt
784 on each line in the file, including possibly more negation processing. */
785
786 else
787 {
788 int file_yield = yield; /* In case empty file */
789 uschar *filename = ss;
790 FILE *f = Ufopen(filename, "rb");
791 uschar filebuffer[1024];
792
793 /* ot will be null in non-debugging cases, and anyway, we get better
794 wording by reworking it. */
795
796 if (f == NULL)
797 {
798 uschar *listname = readconf_find_option(listptr);
799 if (listname[0] == 0)
800 listname = string_sprintf("\"%s\"", *listptr);
801 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "%s",
802 string_open_failed(errno, "%s when checking %s", sss, listname));
803 }
804
805 /* Trailing comments are introduced by #, but in an address list or local
806 part list, the # must be preceded by white space or the start of the line,
807 because the # character is a legal character in local parts. */
808
809 while (Ufgets(filebuffer, sizeof(filebuffer), f) != NULL)
810 {
811 uschar *error;
812 uschar *sss = filebuffer;
813
814 while ((ss = Ustrchr(sss, '#')) != NULL)
815 {
816 if ((type != MCL_ADDRESS && type != MCL_LOCALPART) ||
817 ss == filebuffer || isspace(ss[-1]))
818 {
819 *ss = 0;
820 break;
821 }
822 sss = ss + 1;
823 }
824
825 ss = filebuffer + Ustrlen(filebuffer); /* trailing space */
826 while (ss > filebuffer && isspace(ss[-1])) ss--;
827 *ss = 0;
828
829 ss = filebuffer;
830 while (isspace(*ss)) ss++; /* leading space */
831
832 if (*ss == 0) continue; /* ignore empty */
833
834 file_yield = yield; /* positive yield */
835 sss = ss; /* for debugging */
836
837 if (*ss == '!') /* negation */
838 {
839 file_yield = (file_yield == OK)? FAIL : OK;
840 while (isspace((*(++ss))));
841 }
842
843 switch ((func)(arg, ss, valueptr, &error))
844 {
845 case OK:
846 (void)fclose(f);
847 HDEBUG(D_lists) debug_printf("%s %s (matched \"%s\" in %s)\n", ot,
848 (yield == OK)? "yes" : "no", sss, filename);
849 return file_yield;
850
851 case DEFER:
852 if (error == NULL)
853 error = string_sprintf("DNS lookup of %s deferred", ss);
854 if (ignore_defer)
855 {
856 HDEBUG(D_lists) debug_printf("%s: item ignored by +ignore_defer\n",
857 error);
858 break;
859 }
860 (void)fclose(f);
861 if (include_defer)
862 {
863 log_write(0, LOG_MAIN, "%s: accepted by +include_defer", error);
864 return OK;
865 }
866 goto DEFER_RETURN;
867
868 case ERROR: /* host name lookup failed - this can only */
869 if (ignore_unknown) /* be for an incoming host (not outgoing) */
870 {
871 HDEBUG(D_lists) debug_printf("%s: item ignored by +ignore_unknown\n",
872 error);
873 }
874 else
875 {
876 HDEBUG(D_lists) debug_printf("%s %s (%s)\n", ot,
877 include_unknown? "yes":"no", error);
878 (void)fclose(f);
879 if (!include_unknown)
880 {
881 if ((log_extra_selector & LX_unknown_in_list) != 0)
882 log_write(0, LOG_MAIN, "list matching forced to fail: %s", error);
883 return FAIL;
884 }
885 log_write(0, LOG_MAIN, "%s: accepted by +include_unknown", error);
886 return OK;
887 }
888 }
889 }
890
891 /* At the end of the file, leave the yield setting at the final setting
892 for the file, in case this is the last item in the list. */
893
894 yield = file_yield;
895 (void)fclose(f);
896 }
897 } /* Loop for the next item on the top-level list */
898
899 /* End of list reached: if the last item was negated yield OK, else FAIL. */
900
901 HDEBUG(D_lists)
902 debug_printf("%s %s (end of list)\n", ot, (yield == OK)? "no":"yes");
903 return (yield == OK)? FAIL : OK;
904
905 /* Something deferred */
906
907 DEFER_RETURN:
908 HDEBUG(D_lists) debug_printf("%s list match deferred for %s\n", ot, sss);
909 return DEFER;
910 }
911
912
913 /*************************************************
914 * Match in colon-separated list *
915 *************************************************/
916
917 /* This function is used for domain lists and local part lists. It is not used
918 for host lists or address lists, which have additional interpretation of the
919 patterns. Some calls of it set sep > UCHAR_MAX in order to use its matching
920 facilities on single items. When this is done, it arranges to set the numerical
921 variables as a result of the match.
922
923 This function is now just a short interface to match_check_list(), which does
924 list scanning in a general way. A good compiler will optimize the tail
925 recursion.
926
927 Arguments:
928 s string to search for
929 listptr ptr to ptr to colon separated list of patterns, or NULL
930 sep a separator value for the list (see string_nextinlist())
931 anchorptr ptr to tree for named items, or NULL if no named items
932 cache_bits ptr to cache_bits for ditto, or NULL if not caching
933 type MCL_DOMAIN when matching a domain list
934 MCL_LOCALPART when matching a local part list (address lists
935 have their own function)
936 MCL_STRING for others (e.g. list of ciphers)
937 MCL_NOEXPAND (whose value is greater than any of them) may
938 be added to any value to suppress expansion of the list
939 caseless TRUE for (mostly) caseless matching - passed directly to
940 match_check_string()
941 valueptr pointer to where any lookup data is to be passed back,
942 or NULL (just passed on to match_check_string)
943
944 Returns: OK if matched a non-negated item
945 OK if hit end of list after a negated item
946 FAIL if expansion force-failed
947 FAIL if matched a negated item
948 FAIL if hit end of list after a non-negated item
949 DEFER if a lookup deferred
950 */
951
952 int
953 match_isinlist(uschar *s, uschar **listptr, int sep, tree_node **anchorptr,
954 unsigned int *cache_bits, int type, BOOL caseless, uschar **valueptr)
955 {
956 unsigned int *local_cache_bits = cache_bits;
957 check_string_block cb;
958 cb.origsubject = s;
959 cb.subject = caseless? string_copylc(s) : string_copy(s);
960 cb.expand_setup = (sep > UCHAR_MAX)? 0 : -1;
961 cb.use_partial = TRUE;
962 cb.caseless = caseless;
963 cb.at_is_special = (type == MCL_DOMAIN || type == MCL_DOMAIN + MCL_NOEXPAND);
964 if (valueptr != NULL) *valueptr = NULL;
965 return match_check_list(listptr, sep, anchorptr, &local_cache_bits,
966 check_string, &cb, type, s, valueptr);
967 }
968
969
970
971 /*************************************************
972 * Match address to single address-list item *
973 *************************************************/
974
975 /* This function matches an address to an item from an address list. It is
976 called from match_address_list() via match_check_list(). That is why most of
977 its arguments are in an indirect block.
978
979 Arguments:
980 arg the argument block (see below)
981 pattern the pattern to match
982 valueptr where to return a value
983 error for error messages (not used in this function; it never
984 returns ERROR)
985
986 The argument block contains:
987 address the start of the subject address; when called from retry.c
988 it may be *@domain if the local part isn't relevant
989 origaddress the original, un-case-forced address (not used here, but used
990 in match_check_list() when +caseful is encountered)
991 expand_setup controls setting up of $n variables
992 caseless TRUE for caseless local part matching
993
994 Returns: OK for a match
995 FAIL for no match
996 DEFER if a lookup deferred
997 */
998
999 static int
1000 check_address(void *arg, uschar *pattern, uschar **valueptr, uschar **error)
1001 {
1002 check_address_block *cb = (check_address_block *)arg;
1003 check_string_block csb;
1004 int rc;
1005 int expand_inc = 0;
1006 unsigned int *null = NULL;
1007 uschar *listptr;
1008 uschar *subject = cb->address;
1009 uschar *s, *pdomain, *sdomain;
1010
1011 error = error; /* Keep clever compilers from complaining */
1012
1013 DEBUG(D_lists) debug_printf("address match: subject=%s pattern=%s\n",
1014 subject, pattern);
1015
1016 /* Find the subject's domain */
1017
1018 sdomain = Ustrrchr(subject, '@');
1019
1020 /* The only case where a subject may not have a domain is if the subject is
1021 empty. Otherwise, a subject with no domain is a serious configuration error. */
1022
1023 if (sdomain == NULL && *subject != 0)
1024 {
1025 log_write(0, LOG_MAIN|LOG_PANIC, "no @ found in the subject of an "
1026 "address list match: subject=\"%s\" pattern=\"%s\"", subject, pattern);
1027 return FAIL;
1028 }
1029
1030 /* Handle a regular expression, which must match the entire incoming address.
1031 This may be the empty address. */
1032
1033 if (*pattern == '^')
1034 return match_check_string(subject, pattern, cb->expand_setup, TRUE,
1035 cb->caseless, FALSE, NULL);
1036
1037 /* Handle a pattern that is just a lookup. Skip over possible lookup names
1038 (letters, digits, hyphens). Skip over a possible * or *@ at the end. Then we
1039 must have a semicolon for it to be a lookup. */
1040
1041 for (s = pattern; isalnum(*s) || *s == '-'; s++);
1042 if (*s == '*') s++;
1043 if (*s == '@') s++;
1044
1045 /* If it is a straight lookup, do a lookup for the whole address. This may be
1046 the empty address. Partial matching doesn't make sense here, so we ignore it,
1047 but write a panic log entry. However, *@ matching will be honoured. */
1048
1049 if (*s == ';')
1050 {
1051 if (Ustrncmp(pattern, "partial-", 8) == 0)
1052 log_write(0, LOG_MAIN|LOG_PANIC, "partial matching is not applicable to "
1053 "whole-address lookups: ignored \"partial-\" in \"%s\"", pattern);
1054 return match_check_string(subject, pattern, -1, FALSE, cb->caseless, FALSE,
1055 valueptr);
1056 }
1057
1058 /* For the remaining cases, an empty subject matches only an empty pattern,
1059 because other patterns expect to have a local part and a domain to match
1060 against. */
1061
1062 if (*subject == 0) return (*pattern == 0)? OK : FAIL;
1063
1064 /* If the pattern starts with "@@" we have a split lookup, where the domain is
1065 looked up to obtain a list of local parts. If the subject's local part is just
1066 "*" (called from retry) the match always fails. */
1067
1068 if (pattern[0] == '@' && pattern[1] == '@')
1069 {
1070 int watchdog = 50;
1071 uschar *list, *key, *ss;
1072 uschar buffer[1024];
1073
1074 if (sdomain == subject + 1 && *subject == '*') return FAIL;
1075
1076 /* Loop for handling chains. The last item in any list may be of the form
1077 ">name" in order to chain on to another list. */
1078
1079 for (key = sdomain + 1; key != NULL && watchdog-- > 0; )
1080 {
1081 int sep = 0;
1082
1083 if ((rc = match_check_string(key, pattern + 2, -1, TRUE, FALSE, FALSE,
1084 &list)) != OK) return rc;
1085
1086 /* Check for chaining from the last item; set up the next key if one
1087 is found. */
1088
1089 ss = Ustrrchr(list, ':');
1090 if (ss == NULL) ss = list; else ss++;
1091 while (isspace(*ss)) ss++;
1092 if (*ss == '>')
1093 {
1094 *ss++ = 0;
1095 while (isspace(*ss)) ss++;
1096 key = string_copy(ss);
1097 }
1098 else key = NULL;
1099
1100 /* Look up the local parts provided by the list; negation is permitted.
1101 If a local part has to begin with !, a regex can be used. */
1102
1103 while ((ss = string_nextinlist(&list, &sep, buffer, sizeof(buffer)))
1104 != NULL)
1105 {
1106 int local_yield;
1107
1108 if (*ss == '!')
1109 {
1110 local_yield = FAIL;
1111 while (isspace((*(++ss))));
1112 }
1113 else local_yield = OK;
1114
1115 *sdomain = 0;
1116 rc = match_check_string(subject, ss, -1, TRUE, cb->caseless, FALSE,
1117 valueptr);
1118 *sdomain = '@';
1119
1120 switch(rc)
1121 {
1122 case OK:
1123 return local_yield;
1124
1125 case DEFER:
1126 return DEFER;
1127 }
1128 }
1129 }
1130
1131 /* End of chain loop; panic if too many times */
1132
1133 if (watchdog <= 0)
1134 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "Loop detected in lookup of "
1135 "local part of %s in %s", subject, pattern);
1136
1137 /* Otherwise the local part check has failed, so the whole match
1138 fails. */
1139
1140 return FAIL;
1141 }
1142
1143
1144 /* We get here if the pattern is not a lookup or a regular expression. If it
1145 contains an @ there is both a local part and a domain. */
1146
1147 pdomain = Ustrrchr(pattern, '@');
1148 if (pdomain != NULL)
1149 {
1150 int pllen, sllen;
1151
1152 /* If the domain in the pattern is empty or one of the special cases [] or
1153 mx_{any,primary,secondary}, and the local part in the pattern ends in "@",
1154 we have a pattern of the form <something>@@, <something>@@[], or
1155 <something>@@mx_{any,primary,secondary}. These magic "domains" are
1156 automatically interpreted in match_check_string. We just need to arrange that
1157 the leading @ is included in the domain. */
1158
1159 if (pdomain > pattern && pdomain[-1] == '@' &&
1160 (pdomain[1] == 0 ||
1161 Ustrcmp(pdomain+1, "[]") == 0 ||
1162 Ustrcmp(pdomain+1, "mx_any") == 0 ||
1163 Ustrcmp(pdomain+1, "mx_primary") == 0 ||
1164 Ustrcmp(pdomain+1, "mx_secondary") == 0))
1165 pdomain--;
1166
1167 pllen = pdomain - pattern;
1168 sllen = sdomain - subject;
1169
1170 /* Compare the local parts in the subject and the pattern */
1171
1172 if (*pattern == '*')
1173 {
1174 int cllen = pllen - 1;
1175 if (sllen < cllen) return FAIL;
1176 if (cb->caseless)
1177 {
1178 if (strncmpic(subject+sllen-cllen, pattern + 1, cllen) != 0)
1179 return FAIL;
1180 }
1181 else
1182 {
1183 if (Ustrncmp(subject+sllen-cllen, pattern + 1, cllen) != 0)
1184 return FAIL;
1185 }
1186 if (cb->expand_setup > 0)
1187 {
1188 expand_nstring[cb->expand_setup] = subject;
1189 expand_nlength[cb->expand_setup] = sllen - cllen;
1190 expand_inc = 1;
1191 }
1192 }
1193 else
1194 {
1195 if (sllen != pllen) return FAIL;
1196 if (cb->caseless)
1197 {
1198 if (strncmpic(subject, pattern, sllen) != 0) return FAIL;
1199 }
1200 else
1201 {
1202 if (Ustrncmp(subject, pattern, sllen) != 0) return FAIL;
1203 }
1204 }
1205 }
1206
1207 /* If the local part matched, or was not being checked, check the domain using
1208 the generalized function, which supports file lookups (which may defer). The
1209 original code read as follows:
1210
1211 return match_check_string(sdomain + 1,
1212 (pdomain == NULL)? pattern : pdomain + 1,
1213 cb->expand_setup + expand_inc, TRUE, cb->caseless, TRUE, NULL);
1214
1215 This supported only literal domains and *.x.y patterns. In order to allow for
1216 named domain lists (so that you can right, for example, "senders=+xxxx"), it
1217 was changed to use the list scanning function. */
1218
1219 csb.origsubject = sdomain + 1;
1220 csb.subject = (cb->caseless)? string_copylc(sdomain+1) : string_copy(sdomain+1);
1221 csb.expand_setup = cb->expand_setup + expand_inc;
1222 csb.use_partial = TRUE;
1223 csb.caseless = cb->caseless;
1224 csb.at_is_special = TRUE;
1225
1226 listptr = (pdomain == NULL)? pattern : pdomain + 1;
1227 if (valueptr != NULL) *valueptr = NULL;
1228
1229 return match_check_list(
1230 &listptr, /* list of one item */
1231 UCHAR_MAX+1, /* impossible separator; single item */
1232 &domainlist_anchor, /* it's a domain list */
1233 &null, /* ptr to NULL means no caching */
1234 check_string, /* the function to do one test */
1235 &csb, /* its data */
1236 MCL_DOMAIN + MCL_NOEXPAND, /* domain list; don't expand */
1237 csb.subject, /* string for messages */
1238 valueptr); /* where to pass back lookup data */
1239 }
1240
1241
1242
1243
1244 /*************************************************
1245 * Test whether address matches address list *
1246 *************************************************/
1247
1248 /* This function is given an address and a list of things to match it against.
1249 The list may contain individual addresses, regular expressions, lookup
1250 specifications, and indirection via bare files. Negation is supported. The
1251 address to check can consist of just a domain, which will then match only
1252 domain items or items specified as *@domain.
1253
1254 Domains are always lower cased before the match. Local parts are also lower
1255 cased unless "caseless" is false. The work of actually scanning the list is
1256 done by match_check_list(), with an appropriate block of arguments and a
1257 callback to check_address(). During caseless matching, it will recognize
1258 +caseful and revert to caseful matching.
1259
1260 Arguments:
1261 address address to test
1262 caseless TRUE to start in caseless state
1263 expand TRUE to allow list expansion
1264 listptr list to check against
1265 cache_bits points to cache bits for named address lists, or NULL
1266 expand_setup controls setting up of $n variables - passed through
1267 to check_address (q.v.)
1268 sep separator character for the list;
1269 may be 0 to get separator from the list;
1270 may be UCHAR_MAX+1 for one-item list
1271 valueptr where to return a lookup value, or NULL
1272
1273 Returns: OK for a positive match, or end list after a negation;
1274 FAIL for a negative match, or end list after non-negation;
1275 DEFER if a lookup deferred
1276 */
1277
1278 int
1279 match_address_list(uschar *address, BOOL caseless, BOOL expand,
1280 uschar **listptr, unsigned int *cache_bits, int expand_setup, int sep,
1281 uschar **valueptr)
1282 {
1283 uschar *p;
1284 check_address_block ab;
1285 unsigned int *local_cache_bits = cache_bits;
1286
1287 /* RFC 2505 recommends that for spam checking, local parts should be caselessly
1288 compared. Therefore, Exim now forces the entire address into lower case here,
1289 provided that "caseless" is set. (It is FALSE for calls for matching rewriting
1290 patterns.) Otherwise just the domain is lower cases. A magic item "+caseful" in
1291 the list can be used to restore a caseful copy of the local part from the
1292 original address. */
1293
1294 sprintf(CS big_buffer, "%.*s", big_buffer_size - 1, address);
1295 for (p = big_buffer + Ustrlen(big_buffer) - 1; p >= big_buffer; p--)
1296 {
1297 if (!caseless && *p == '@') break;
1298 *p = tolower(*p);
1299 }
1300
1301 /* If expand_setup is zero, we need to set up $0 to the whole thing, in
1302 case there is a match. Can't use the built-in facilities of match_check_string
1303 (via check_address), as we may just be calling that for part of the address
1304 (the domain). */
1305
1306 if (expand_setup == 0)
1307 {
1308 expand_nstring[0] = string_copy(address);
1309 expand_nlength[0] = Ustrlen(address);
1310 expand_setup++;
1311 }
1312
1313 /* Set up the data to be passed ultimately to check_address. */
1314
1315 ab.origaddress = address;
1316 ab.address = big_buffer;
1317 ab.expand_setup = expand_setup;
1318 ab.caseless = caseless;
1319
1320 return match_check_list(listptr, sep, &addresslist_anchor, &local_cache_bits,
1321 check_address, &ab, MCL_ADDRESS + (expand? 0:MCL_NOEXPAND), address,
1322 valueptr);
1323 }
1324
1325 /* End of match.c */