src/src/match.c

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