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