src/src/match.c

   1 /* $Cambridge: exim/src/src/match.c,v 1.9 2005/09/12 13:39:31 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)
 724             {
 725             if ((log_extra_selector & LX_unknown_in_list) != 0)
 726               log_write(0, LOG_MAIN, "list matching forced to fail: %s", error);
 727             return FAIL;
 728             }
 729           log_write(0, LOG_MAIN, "%s: accepted by +include_unknown", error);
 730           return OK;
 731           }
 732         }
 733       }
 734     }
 735
 736   /* If the item is a file name, we read the file and do a match attempt
 737   on each line in the file, including possibly more negation processing. */
 738
 739   else
 740     {
 741     int file_yield = yield;       /* In case empty file */
 742     uschar *filename = ss;
 743     FILE *f = Ufopen(filename, "rb");
 744     uschar filebuffer[1024];
 745
 746     /* ot will be null in non-debugging cases, and anyway, we get better
 747     wording by reworking it. */
 748
 749     if (f == NULL)
 750       {
 751       uschar *listname = readconf_find_option(listptr);
 752       if (listname[0] == 0)
 753         listname = string_sprintf("\"%s\"", *listptr);
 754       log_write(0, LOG_MAIN|LOG_PANIC_DIE, "%s",
 755         string_open_failed(errno, "%s when checking %s", sss, listname));
 756       }
 757
 758     /* Trailing comments are introduced by #, but in an address list or local
 759     part list, the # must be preceded by white space or the start of the line,
 760     because the # character is a legal character in local parts. */
 761
 762     while (Ufgets(filebuffer, sizeof(filebuffer), f) != NULL)
 763       {
 764       uschar *error;
 765       uschar *sss = filebuffer;
 766
 767       while ((ss = Ustrchr(sss, '#')) != NULL)
 768         {
 769         if ((type != MCL_ADDRESS && type != MCL_LOCALPART) ||
 770               ss == filebuffer || isspace(ss[-1]))
 771           {
 772           *ss = 0;
 773           break;
 774           }
 775         sss = ss + 1;
 776         }
 777
 778       ss = filebuffer + Ustrlen(filebuffer);             /* trailing space */
 779       while (ss > filebuffer && isspace(ss[-1])) ss--;
 780       *ss = 0;
 781
 782       ss = filebuffer;
 783       while (isspace(*ss)) ss++;                         /* leading space */
 784
 785       if (*ss == 0) continue;                            /* ignore empty */
 786
 787       file_yield = yield;                                /* positive yield */
 788       sss = ss;                                          /* for debugging */
 789
 790       if (*ss == '!')                                    /* negation */
 791         {
 792         file_yield = (file_yield == OK)? FAIL : OK;
 793         while (isspace((*(++ss))));
 794         }
 795
 796       switch ((func)(arg, ss, valueptr, &error))
 797         {
 798         case OK:
 799         (void)fclose(f);
 800         HDEBUG(D_lists) debug_printf("%s %s (matched \"%s\" in %s)\n", ot,
 801           (yield == OK)? "yes" : "no", sss, filename);
 802         return file_yield;
 803
 804         case DEFER:
 805         (void)fclose(f);
 806         goto DEFER_RETURN;
 807
 808         case ERROR:          /* host name lookup failed - this can only */
 809         if (ignore_unknown)  /* be for an incoming host (not outgoing) */
 810           {
 811           HDEBUG(D_lists) debug_printf("%s: item ignored by +ignore_unknown",
 812             error);
 813           }
 814         else
 815          {
 816           HDEBUG(D_lists) debug_printf("%s %s (%s)\n", ot,
 817             include_unknown? "yes":"no", error);
 818           (void)fclose(f);
 819           if (!include_unknown)
 820             {
 821             if ((log_extra_selector & LX_unknown_in_list) != 0)
 822               log_write(0, LOG_MAIN, "list matching forced to fail: %s", error);
 823             return FAIL;
 824             }
 825           log_write(0, LOG_MAIN, "%s: accepted by +include_unknown", error);
 826           return OK;
 827           }
 828         }
 829       }
 830
 831     /* At the end of the file, leave the yield setting at the final setting
 832     for the file, in case this is the last item in the list. */
 833
 834     yield = file_yield;
 835     (void)fclose(f);
 836     }
 837   }    /* Loop for the next item on the top-level list */
 838
 839 /* End of list reached: if the last item was negated yield OK, else FAIL. */
 840
 841 HDEBUG(D_lists)
 842   debug_printf("%s %s (end of list)\n", ot, (yield == OK)? "no":"yes");
 843 return (yield == OK)? FAIL : OK;
 844
 845 /* Handle lookup defer */
 846
 847 DEFER_RETURN:
 848 HDEBUG(D_lists) debug_printf("%s lookup deferred for %s\n", ot, sss);
 849 return DEFER;
 850 }
 851
 852
 853 /*************************************************
 854 *          Match in colon-separated list         *
 855 *************************************************/
 856
 857 /* This function is used for domain lists and local part lists. It is not used
 858 for host lists or address lists, which have additional interpretation of the
 859 patterns. Some calls of it set sep > UCHAR_MAX in order to use its matching
 860 facilities on single items. When this is done, it arranges to set the numerical
 861 variables as a result of the match.
 862
 863 This function is now just a short interface to match_check_list(), which does
 864 list scanning in a general way. A good compiler will optimize the tail
 865 recursion.
 866
 867 Arguments:
 868   s              string to search for
 869   listptr        ptr to ptr to colon separated list of patterns, or NULL
 870   sep            a separator value for the list (see string_nextinlist())
 871   anchorptr      ptr to tree for named items, or NULL if no named items
 872   cache_bits     ptr to cache_bits for ditto, or NULL if not caching
 873   type           MCL_DOMAIN when matching a domain list
 874                  MCL_LOCALPART when matching a local part list (address lists
 875                    have their own function)
 876                  MCL_STRING for others (e.g. list of ciphers)
 877                  MCL_NOEXPAND (whose value is greater than any of them) may
 878                    be added to any value to suppress expansion of the list
 879   caseless       TRUE for (mostly) caseless matching - passed directly to
 880                    match_check_string()
 881   valueptr       pointer to where any lookup data is to be passed back,
 882                  or NULL (just passed on to match_check_string)
 883
 884 Returns:         OK    if matched a non-negated item
 885                  OK    if hit end of list after a negated item
 886                  FAIL  if expansion force-failed
 887                  FAIL  if matched a negated item
 888                  FAIL  if hit end of list after a non-negated item
 889                  DEFER if a lookup deferred
 890 */
 891
 892 int
 893 match_isinlist(uschar *s, uschar **listptr, int sep, tree_node **anchorptr,
 894   unsigned int *cache_bits, int type, BOOL caseless, uschar **valueptr)
 895 {
 896 unsigned int *local_cache_bits = cache_bits;
 897 check_string_block cb;
 898 cb.origsubject = s;
 899 cb.subject = caseless? string_copylc(s) : string_copy(s);
 900 cb.expand_setup = (sep > UCHAR_MAX)? 0 : -1;
 901 cb.use_partial = TRUE;
 902 cb.caseless = caseless;
 903 cb.at_is_special = (type == MCL_DOMAIN || type == MCL_DOMAIN + MCL_NOEXPAND);
 904 if (valueptr != NULL) *valueptr = NULL;
 905 return  match_check_list(listptr, sep, anchorptr, &local_cache_bits,
 906   check_string, &cb, type, s, valueptr);
 907 }
 908
 909
 910
 911 /*************************************************
 912 *    Match address to single address-list item   *
 913 *************************************************/
 914
 915 /* This function matches an address to an item from an address list. It is
 916 called from match_address_list() via match_check_list(). That is why most of
 917 its arguments are in an indirect block.
 918
 919 Arguments:
 920   arg            the argument block (see below)
 921   pattern        the pattern to match
 922   valueptr       where to return a value
 923   error          for error messages (not used in this function; it never
 924                    returns ERROR)
 925
 926 The argument block contains:
 927   address        the start of the subject address; when called from retry.c
 928                    it may be *@domain if the local part isn't relevant
 929   origaddress    the original, un-case-forced address (not used here, but used
 930                    in match_check_list() when +caseful is encountered)
 931   expand_setup   controls setting up of $n variables
 932   caseless       TRUE for caseless local part matching
 933
 934 Returns:         OK     for a match
 935                  FAIL   for no match
 936                  DEFER  if a lookup deferred
 937 */
 938
 939 static int
 940 check_address(void *arg, uschar *pattern, uschar **valueptr, uschar **error)
 941 {
 942 check_address_block *cb = (check_address_block *)arg;
 943 check_string_block csb;
 944 int rc;
 945 int expand_inc = 0;
 946 unsigned int *null = NULL;
 947 uschar *listptr;
 948 uschar *subject = cb->address;
 949 uschar *s, *pdomain, *sdomain;
 950
 951 error = error;  /* Keep clever compilers from complaining */
 952
 953 DEBUG(D_lists) debug_printf("address match: subject=%s pattern=%s\n",
 954   subject, pattern);
 955
 956 /* Handle a regular expression, which must match the entire incoming address.
 957 This may be the empty address. */
 958
 959 if (*pattern == '^')
 960   return match_check_string(subject, pattern, cb->expand_setup, TRUE,
 961     cb->caseless, FALSE, NULL);
 962
 963 /* Handle a pattern that is just a lookup. Skip over possible lookup names
 964 (letters, digits, hyphens). Skip over a possible * or *@ at the end. Then we
 965 must have a semicolon for it to be a lookup. */
 966
 967 for (s = pattern; isalnum(*s) || *s == '-'; s++);
 968 if (*s == '*') s++;
 969 if (*s == '@') s++;
 970
 971 /* If it is a straight lookup, do a lookup for the whole address. This may be
 972 the empty address. Partial matching doesn't make sense here, so we ignore it,
 973 but write a panic log entry. However, *@ matching will be honoured. */
 974
 975 if (*s == ';')
 976   {
 977   if (Ustrncmp(pattern, "partial-", 8) == 0)
 978     log_write(0, LOG_MAIN|LOG_PANIC, "partial matching is not applicable to "
 979       "whole-address lookups: ignored \"partial-\" in \"%s\"", pattern);
 980   return match_check_string(subject, pattern, -1, FALSE, cb->caseless, FALSE,
 981     valueptr);
 982   }
 983
 984 /* For the remaining cases, an empty subject matches only an empty pattern,
 985 because other patterns expect to have a local part and a domain to match
 986 against. */
 987
 988 if (*subject == 0) return (*pattern == 0)? OK : FAIL;
 989
 990 /* Find the subject's domain */
 991
 992 sdomain = Ustrrchr(subject, '@');
 993
 994 /* If the pattern starts with "@@" we have a split lookup, where the domain is
 995 looked up to obtain a list of local parts. If the subject's local part is just
 996 "*" (called from retry) the match always fails. */
 997
 998 if (pattern[0] == '@' && pattern[1] == '@')
 999   {
1000   int watchdog = 50;
1001   uschar *list, *key, *ss;
1002   uschar buffer[1024];
1003
1004   if (sdomain == subject + 1 && *subject == '*') return FAIL;
1005
1006   /* Loop for handling chains. The last item in any list may be of the form
1007   ">name" in order to chain on to another list. */
1008
1009   for (key = sdomain + 1; key != NULL && watchdog-- > 0; )
1010     {
1011     int sep = 0;
1012
1013     if ((rc = match_check_string(key, pattern + 2, -1, TRUE, FALSE, FALSE,
1014       &list)) != OK) return rc;
1015
1016     /* Check for chaining from the last item; set up the next key if one
1017     is found. */
1018
1019     ss = Ustrrchr(list, ':');
1020     if (ss == NULL) ss = list; else ss++;
1021     while (isspace(*ss)) ss++;
1022     if (*ss == '>')
1023       {
1024       *ss++ = 0;
1025       while (isspace(*ss)) ss++;
1026       key = string_copy(ss);
1027       }
1028     else key = NULL;
1029
1030     /* Look up the local parts provided by the list; negation is permitted.
1031     If a local part has to begin with !, a regex can be used. */
1032
1033     while ((ss = string_nextinlist(&list, &sep, buffer, sizeof(buffer)))
1034            != NULL)
1035       {
1036       int local_yield;
1037
1038       if (*ss == '!')
1039         {
1040         local_yield = FAIL;
1041         while (isspace((*(++ss))));
1042         }
1043       else local_yield = OK;
1044
1045       *sdomain = 0;
1046       rc = match_check_string(subject, ss, -1, TRUE, cb->caseless, FALSE,
1047         valueptr);
1048       *sdomain = '@';
1049
1050       switch(rc)
1051         {
1052         case OK:
1053         return local_yield;
1054
1055         case DEFER:
1056         return DEFER;
1057         }
1058       }
1059     }
1060
1061   /* End of chain loop; panic if too many times */
1062
1063   if (watchdog <= 0)
1064     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "Loop detected in lookup of "
1065       "local part of %s in %s", subject, pattern);
1066
1067   /* Otherwise the local part check has failed, so the whole match
1068   fails. */
1069
1070   return FAIL;
1071   }
1072
1073
1074 /* We get here if the pattern is not a lookup or a regular expression. If it
1075 contains an @ there is both a local part and a domain. */
1076
1077 pdomain = Ustrrchr(pattern, '@');
1078 if (pdomain != NULL)
1079   {
1080   int pllen, sllen;
1081
1082   /* If the domain in the pattern is empty or one of the special cases [] or
1083   mx_{any,primary,secondary}, and the local part in the pattern ends in "@",
1084   we have a pattern of the form <something>@@, <something>@@[], or
1085   <something>@@mx_{any,primary,secondary}. These magic "domains" are
1086   automatically interpreted in match_check_string. We just need to arrange that
1087   the leading @ is included in the domain. */
1088
1089   if (pdomain > pattern && pdomain[-1] == '@' &&
1090        (pdomain[1] == 0 ||
1091         Ustrcmp(pdomain+1, "[]") == 0 ||
1092         Ustrcmp(pdomain+1, "mx_any") == 0 ||
1093         Ustrcmp(pdomain+1, "mx_primary") == 0 ||
1094         Ustrcmp(pdomain+1, "mx_secondary") == 0))
1095     pdomain--;
1096
1097   pllen = pdomain - pattern;
1098   sllen = sdomain - subject;
1099
1100   /* Compare the local parts in the subject and the pattern */
1101
1102   if (*pattern == '*')
1103     {
1104     int cllen = pllen - 1;
1105     if (sllen < cllen) return FAIL;
1106     if (cb->caseless)
1107       {
1108       if (strncmpic(subject+sllen-cllen, pattern + 1, cllen) != 0)
1109         return FAIL;
1110       }
1111     else
1112       {
1113       if (Ustrncmp(subject+sllen-cllen, pattern + 1, cllen) != 0)
1114         return FAIL;
1115       }
1116     if (cb->expand_setup > 0)
1117       {
1118       expand_nstring[cb->expand_setup] = subject;
1119       expand_nlength[cb->expand_setup] = sllen - cllen;
1120       expand_inc = 1;
1121       }
1122     }
1123   else
1124     {
1125     if (sllen != pllen) return FAIL;
1126     if (cb->caseless)
1127       {
1128       if (strncmpic(subject, pattern, sllen) != 0) return FAIL;
1129       }
1130     else
1131       {
1132       if (Ustrncmp(subject, pattern, sllen) != 0) return FAIL;
1133       }
1134     }
1135   }
1136
1137 /* If the local part matched, or was not being checked, check the domain using
1138 the generalized function, which supports file lookups (which may defer). The
1139 original code read as follows:
1140
1141   return match_check_string(sdomain + 1,
1142       (pdomain == NULL)? pattern : pdomain + 1,
1143       cb->expand_setup + expand_inc, TRUE, cb->caseless, TRUE, NULL);
1144
1145 This supported only literal domains and *.x.y patterns. In order to allow for
1146 named domain lists (so that you can right, for example, "senders=+xxxx"), it
1147 was changed to use the list scanning function. */
1148
1149 csb.origsubject = sdomain + 1;
1150 csb.subject = (cb->caseless)? string_copylc(sdomain+1) : string_copy(sdomain+1);
1151 csb.expand_setup = cb->expand_setup + expand_inc;
1152 csb.use_partial = TRUE;
1153 csb.caseless = cb->caseless;
1154 csb.at_is_special = TRUE;
1155
1156 listptr = (pdomain == NULL)? pattern : pdomain + 1;
1157 if (valueptr != NULL) *valueptr = NULL;
1158
1159 return match_check_list(
1160   &listptr,                  /* list of one item */
1161   UCHAR_MAX+1,               /* impossible separator; single item */
1162   &domainlist_anchor,        /* it's a domain list */
1163   &null,                     /* ptr to NULL means no caching */
1164   check_string,              /* the function to do one test */
1165   &csb,                      /* its data */
1166   MCL_DOMAIN + MCL_NOEXPAND, /* domain list; don't expand */
1167   csb.subject,               /* string for messages */
1168   valueptr);                 /* where to pass back lookup data */
1169 }
1170
1171
1172
1173
1174 /*************************************************
1175 *    Test whether address matches address list   *
1176 *************************************************/
1177
1178 /* This function is given an address and a list of things to match it against.
1179 The list may contain individual addresses, regular expressions, lookup
1180 specifications, and indirection via bare files. Negation is supported. The
1181 address to check can consist of just a domain, which will then match only
1182 domain items or items specified as *@domain.
1183
1184 Domains are always lower cased before the match. Local parts are also lower
1185 cased unless "caseless" is false. The work of actually scanning the list is
1186 done by match_check_list(), with an appropriate block of arguments and a
1187 callback to check_address(). During caseless matching, it will recognize
1188 +caseful and revert to caseful matching.
1189
1190 Arguments:
1191   address         address to test
1192   caseless        TRUE to start in caseless state
1193   expand          TRUE to allow list expansion
1194   listptr         list to check against
1195   cache_bits      points to cache bits for named address lists, or NULL
1196   expand_setup    controls setting up of $n variables - passed through
1197                   to check_address (q.v.)
1198   sep             separator character for the list;
1199                   may be 0 to get separator from the list;
1200                   may be UCHAR_MAX+1 for one-item list
1201   valueptr        where to return a lookup value, or NULL
1202
1203 Returns:          OK    for a positive match, or end list after a negation;
1204                   FAIL  for a negative match, or end list after non-negation;
1205                   DEFER if a lookup deferred
1206 */
1207
1208 int
1209 match_address_list(uschar *address, BOOL caseless, BOOL expand,
1210   uschar **listptr, unsigned int *cache_bits, int expand_setup, int sep,
1211   uschar **valueptr)
1212 {
1213 uschar *p;
1214 check_address_block ab;
1215 unsigned int *local_cache_bits = cache_bits;
1216
1217 /* RFC 2505 recommends that for spam checking, local parts should be caselessly
1218 compared. Therefore, Exim now forces the entire address into lower case here,
1219 provided that "caseless" is set. (It is FALSE for calls for matching rewriting
1220 patterns.) Otherwise just the domain is lower cases. A magic item "+caseful" in
1221 the list can be used to restore a caseful copy of the local part from the
1222 original address. */
1223
1224 sprintf(CS big_buffer, "%.*s", big_buffer_size - 1, address);
1225 for (p = big_buffer + Ustrlen(big_buffer) - 1; p >= big_buffer; p--)
1226   {
1227   if (!caseless && *p == '@') break;
1228   *p = tolower(*p);
1229   }
1230
1231 /* If expand_setup is zero, we need to set up $0 to the whole thing, in
1232 case there is a match. Can't use the built-in facilities of match_check_string
1233 (via check_address), as we may just be calling that for part of the address
1234 (the domain). */
1235
1236 if (expand_setup == 0)
1237   {
1238   expand_nstring[0] = string_copy(address);
1239   expand_nlength[0] = Ustrlen(address);
1240   expand_setup++;
1241   }
1242
1243 /* Set up the data to be passed ultimately to check_address. */
1244
1245 ab.origaddress = address;
1246 ab.address = big_buffer;
1247 ab.expand_setup = expand_setup;
1248 ab.caseless = caseless;
1249
1250 return match_check_list(listptr, sep, &addresslist_anchor, &local_cache_bits,
1251   check_address, &ab, MCL_ADDRESS + (expand? 0:MCL_NOEXPAND), address,
1252     valueptr);
1253 }
1254
1255 /* End of match.c */