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