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