src/src/match.c

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