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