src/src/match.c

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