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