src/src/match.c

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