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