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