src/src/match.c

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