[exim.git] / src / src / lookups / lsearch.c

/*************************************************
*     Exim - an Internet mail transport agent    *
*************************************************/

/* Copyright (c) University of Cambridge 1995 - 2018 */
/* Copyright (c) The Exim Maintainers 2020 */
/* See the file NOTICE for conditions of use and distribution. */

#include "../exim.h"
#include "lf_functions.h"

/* Codes for the different kinds of lsearch that are supported */

enum {
  LSEARCH_PLAIN,        /* Literal keys */
  LSEARCH_WILD,         /* Wild card keys, expanded */
  LSEARCH_NWILD,        /* Wild card keys, not expanded */
  LSEARCH_IP            /* IP addresses and networks */
};


/*************************************************
*              Open entry point                  *
*************************************************/

/* See local README for interface description */

static void *
lsearch_open(const uschar * filename, uschar ** errmsg)
{
FILE *f = Ufopen(filename, "rb");
if (f == NULL)
  {
  int save_errno = errno;
  *errmsg = string_open_failed(errno, "%s for linear search", filename);
  errno = save_errno;
  return NULL;
  }
return f;
}


/*************************************************
*             Check entry point                  *
*************************************************/

static BOOL
lsearch_check(void *handle, const uschar *filename, int modemask, uid_t *owners,
  gid_t *owngroups, uschar **errmsg)
{
return lf_check_file(fileno((FILE *)handle), filename, S_IFREG, modemask,
  owners, owngroups, "lsearch", errmsg) == 0;
}


/*************************************************
*  Internal function for the various lsearches   *
*************************************************/

/* See local README for interface description, plus:

Extra argument:

  type     one of the values LSEARCH_PLAIN, LSEARCH_WILD, LSEARCH_NWILD, or
           LSEARCH_IP

There is some messy logic in here to cope with very long data lines that do not
fit into the fixed sized buffer. Most of the time this will never be exercised,
but people do occasionally do weird things. */

static int
internal_lsearch_find(void * handle, const uschar * filename,
  const uschar * keystring, int length, uschar ** result, uschar ** errmsg,
 int type)
{
FILE *f = (FILE *)handle;
BOOL last_was_eol = TRUE;
BOOL this_is_eol = TRUE;
int old_pool = store_pool;
rmark reset_point = NULL;
uschar buffer[4096];

/* Wildcard searches may use up some store, because of expansions. We don't
want them to fill up our search store. What we do is set the pool to the main
pool and get a point to reset to later. Wildcard searches could also issue
lookups, but internal_search_find will take care of that, and the cache will be
safely stored in the search pool again. */

if(type == LSEARCH_WILD || type == LSEARCH_NWILD)
  {
  store_pool = POOL_MAIN;
  reset_point = store_mark();
  }

filename = filename;  /* Keep picky compilers happy */
errmsg = errmsg;

rewind(f);
for (last_was_eol = TRUE;
     Ufgets(buffer, sizeof(buffer), f) != NULL;
     last_was_eol = this_is_eol)
  {
  int p = Ustrlen(buffer);
  int linekeylength;
  BOOL this_is_comment;
  gstring * yield;
  uschar *s = buffer;

  /* Check whether this the final segment of a line. If it follows an
  incomplete part-line, skip it. */

  this_is_eol = p > 0 && buffer[p-1] == '\n';
  if (!last_was_eol) continue;

  /* We now have the start of a physical line. If this is a final line segment,
  remove trailing white space. */

  if (this_is_eol)
    {
    while (p > 0 && isspace((uschar)buffer[p-1])) p--;
    buffer[p] = 0;
    }

  /* If the buffer is empty it might be (a) a complete empty line, or (b) the
  start of a line that begins with so much white space that it doesn't all fit
  in the buffer. In both cases we want to skip the entire physical line.

  If the buffer begins with # it is a comment line; if it begins with white
  space it is a logical continuation; again, we want to skip the entire
  physical line. */

  if (buffer[0] == 0 || buffer[0] == '#' || isspace(buffer[0])) continue;

  /* We assume that they key will fit in the buffer. If the key starts with ",
  read it as a quoted string. We don't use string_dequote() because that uses
  new store for the result, and we may be doing this many times in a long file.
  We know that the dequoted string must be shorter than the original, because
  we are removing the quotes, and also any escape sequences always turn two or
  more characters into one character. Therefore, we can store the new string in
  the same buffer. */

  if (*s == '\"')
    {
    uschar *t = s++;
    while (*s != 0 && *s != '\"')
      {
      if (*s == '\\') *t++ = string_interpret_escape(CUSS &s);
        else *t++ = *s;
      s++;
      }
    if (*s != 0) s++;               /* Past terminating " */
    linekeylength = t - buffer;
    }

  /* Otherwise it is terminated by a colon or white space */

  else
    {
    while (*s != 0 && *s != ':' && !isspace(*s)) s++;
    linekeylength = s - buffer;
    }

  /* The matching test depends on which kind of lsearch we are doing */

  switch(type)
    {
    /* A plain lsearch treats each key as a literal */

    case LSEARCH_PLAIN:
    if (linekeylength != length || strncmpic(buffer, keystring, length) != 0)
      continue;
    break;      /* Key matched */

    /* A wild lsearch treats each key as a possible wildcarded string; no
    expansion is done for nwildlsearch. */

    case LSEARCH_WILD:
    case LSEARCH_NWILD:
      {
      int rc;
      int save = buffer[linekeylength];
      const uschar *list = buffer;
      buffer[linekeylength] = 0;
      rc = match_isinlist(keystring,
        &list,
        UCHAR_MAX+1,              /* Single-item list */
        NULL,                     /* No anchor */
        NULL,                     /* No caching */
        MCL_STRING + ((type == LSEARCH_WILD)? 0:MCL_NOEXPAND),
        TRUE,                     /* Caseless */
        NULL);
      buffer[linekeylength] = save;
      if (rc == FAIL) continue;
      if (rc == DEFER) return DEFER;
      }

    /* The key has matched. If the search involved a regular expression, it
    might have caused numerical variables to be set. However, their values will
    be in the wrong storage pool for external use. Copying them to the standard
    pool is not feasible because of the caching of lookup results - a repeated
    lookup will not match the regular expression again. Therefore, we flatten
    all numeric variables at this point. */

    expand_nmax = -1;
    break;

    /* Compare an ip address against a list of network/ip addresses. We have to
    allow for the "*" case specially. */

    case LSEARCH_IP:
    if (linekeylength == 1 && buffer[0] == '*')
      {
      if (length != 1 || keystring[0] != '*') continue;
      }
    else if (length == 1 && keystring[0] == '*') continue;
    else
      {
      int maskoffset;
      int save = buffer[linekeylength];
      buffer[linekeylength] = 0;
      if (string_is_ip_address(buffer, &maskoffset) == 0 ||
          !host_is_in_net(keystring, buffer, maskoffset)) continue;
      buffer[linekeylength] = save;
      }
    break;      /* Key matched */
    }

  /* The key has matched. Skip spaces after the key, and allow an optional
  colon after the spaces. This is an odd specification, but it's for
  compatibility. */

  while (isspace((uschar)*s)) s++;
  if (*s == ':')
    {
    s++;
    while (isspace((uschar)*s)) s++;
    }

  /* Reset dynamic store, if we need to, and revert to the search pool */

  if (reset_point)
    {
    reset_point = store_reset(reset_point);
    store_pool = old_pool;
    }

  /* Now we want to build the result string to contain the data. There can be
  two kinds of continuation: (a) the physical line may not all have fitted into
  the buffer, and (b) there may be logical continuation lines, for which we
  must convert all leading white space into a single blank.

  Initialize, and copy the first segment of data. */

  this_is_comment = FALSE;
  yield = string_get(100);
  if (*s != 0)
    yield = string_cat(yield, s);

  /* Now handle continuations */

  for (last_was_eol = this_is_eol;
       Ufgets(buffer, sizeof(buffer), f) != NULL;
       last_was_eol = this_is_eol)
    {
    s = buffer;
    p = Ustrlen(buffer);
    this_is_eol = p > 0 && buffer[p-1] == '\n';

    /* Remove trailing white space from a physical line end */

    if (this_is_eol)
      {
      while (p > 0 && isspace((uschar)buffer[p-1])) p--;
      buffer[p] = 0;
      }

    /* If this is not a physical line continuation, skip it entirely if it's
    empty or starts with #. Otherwise, break the loop if it doesn't start with
    white space. Otherwise, replace leading white space with a single blank. */

    if (last_was_eol)
      {
      this_is_comment = (this_is_comment || (buffer[0] == 0 || buffer[0] == '#'));
      if (this_is_comment) continue;
      if (!isspace((uschar)buffer[0])) break;
      while (isspace((uschar)*s)) s++;
      *(--s) = ' ';
      }
    if (this_is_comment) continue;

    /* Join a physical or logical line continuation onto the result string. */

    yield = string_cat(yield, s);
    }

  gstring_release_unused(yield);
  *result = string_from_gstring(yield);
  return OK;
  }

/* Reset dynamic store, if we need to */

if (reset_point)
  {
  store_reset(reset_point);
  store_pool = old_pool;
  }

return FAIL;
}


/*************************************************
*         Find entry point for lsearch           *
*************************************************/

/* See local README for interface description */

static int
lsearch_find(void * handle, const uschar * filename, const uschar * keystring,
  int length, uschar ** result, uschar ** errmsg, uint * do_cache,
  const uschar * opts)
{
do_cache = do_cache;  /* Keep picky compilers happy */
return internal_lsearch_find(handle, filename, keystring, length, result,
  errmsg, LSEARCH_PLAIN);
}


/*************************************************
*      Find entry point for wildlsearch          *
*************************************************/

/* See local README for interface description */

static int
wildlsearch_find(void * handle, const uschar * filename, const uschar * keystring,
  int length, uschar ** result, uschar ** errmsg, uint * do_cache,
  const uschar * opts)
{
do_cache = do_cache;  /* Keep picky compilers happy */
return internal_lsearch_find(handle, filename, keystring, length, result,
  errmsg, LSEARCH_WILD);
}


/*************************************************
*      Find entry point for nwildlsearch         *
*************************************************/

/* See local README for interface description */

static int
nwildlsearch_find(void * handle, const uschar * filename, const uschar * keystring,
  int length, uschar ** result, uschar ** errmsg, uint * do_cache,
  const uschar * opts)
{
do_cache = do_cache;  /* Keep picky compilers happy */
return internal_lsearch_find(handle, filename, keystring, length, result,
  errmsg, LSEARCH_NWILD);
}


/*************************************************
*      Find entry point for iplsearch            *
*************************************************/

/* See local README for interface description */

static int
iplsearch_find(void * handle, uschar const * filename, const uschar * keystring,
  int length, uschar ** result, uschar ** errmsg, uint * do_cache,
  const uschar * opts)
{
do_cache = do_cache;  /* Keep picky compilers happy */

if ((length == 1 && keystring[0] == '*') ||
    string_is_ip_address(keystring, NULL) != 0)
  return internal_lsearch_find(handle, filename, keystring, length, result,
    errmsg, LSEARCH_IP);

*errmsg = string_sprintf("\"%s\" is not a valid iplsearch key (an IP "
"address, with optional CIDR mask, is wanted): "
"in a host list, use net-iplsearch as the search type", keystring);
return DEFER;
}


/*************************************************
*              Close entry point                 *
*************************************************/

/* See local README for interface description */

static void
lsearch_close(void *handle)
{
(void)fclose((FILE *)handle);
}


/*************************************************
*         Version reporting entry point          *
*************************************************/

/* See local README for interface description. */

#include "../version.h"

void
lsearch_version_report(FILE *f)
{
#ifdef DYNLOOKUP
fprintf(f, "Library version: lsearch: Exim version %s\n", EXIM_VERSION_STR);
#endif
}


static lookup_info iplsearch_lookup_info = {
  .name = US"iplsearch",		/* lookup name */
  .type = lookup_absfile,		/* uses absolute file name */
  .open = lsearch_open,			/* open function */
  .check = lsearch_check,		/* check function */
  .find = iplsearch_find,		/* find function */
  .close = lsearch_close,		/* close function */
  .tidy = NULL,				/* no tidy function */
  .quote = NULL,			/* no quoting function */
  .version_report = NULL                           /* no version reporting (redundant) */
};

static lookup_info lsearch_lookup_info = {
  .name = US"lsearch",			/* lookup name */
  .type = lookup_absfile,		/* uses absolute file name */
  .open = lsearch_open,			/* open function */
  .check = lsearch_check,		/* check function */
  .find = lsearch_find,			/* find function */
  .close = lsearch_close,		/* close function */
  .tidy = NULL,				/* no tidy function */
  .quote = NULL,			/* no quoting function */
  .version_report = lsearch_version_report         /* version reporting */
};

static lookup_info nwildlsearch_lookup_info = {
  .name = US"nwildlsearch",		/* lookup name */
  .type = lookup_absfile,		/* uses absolute file name */
  .open = lsearch_open,			/* open function */
  .check = lsearch_check,		/* check function */
  .find = nwildlsearch_find,		/* find function */
  .close = lsearch_close,		/* close function */
  .tidy = NULL,				/* no tidy function */
  .quote = NULL,			/* no quoting function */
  .version_report = NULL                           /* no version reporting (redundant) */
};

static lookup_info wildlsearch_lookup_info = {
  .name = US"wildlsearch",		/* lookup name */
  .type = lookup_absfile,		/* uses absolute file name */
  .open = lsearch_open,			/* open function */
  .check = lsearch_check,		/* check function */
  .find = wildlsearch_find,		/* find function */
  .close = lsearch_close,		/* close function */
  .tidy = NULL,				/* no tidy function */
  .quote = NULL,			/* no quoting function */
  .version_report = NULL                           /* no version reporting (redundant) */
};

#ifdef DYNLOOKUP
#define lsearch_lookup_module_info _lookup_module_info
#endif

static lookup_info *_lookup_list[] = { &iplsearch_lookup_info,
                                       &lsearch_lookup_info,
                                       &nwildlsearch_lookup_info,
                                       &wildlsearch_lookup_info };
lookup_module_info lsearch_lookup_module_info = { LOOKUP_MODULE_INFO_MAGIC, _lookup_list, 4 };

/* End of lookups/lsearch.c */
Commit	Line	Data
0756eb3c PH	1	/*************************************************
	2	* Exim - an Internet mail transport agent *
	3	*************************************************/
	4
f9ba5e22	5	/* Copyright (c) University of Cambridge 1995 - 2018 */
1e1ddfac	6	/* Copyright (c) The Exim Maintainers 2020 */
0756eb3c PH	7	/* See the file NOTICE for conditions of use and distribution. */
	8
	9	#include "../exim.h"
	10	#include "lf_functions.h"
0756eb3c PH	11
	12	/* Codes for the different kinds of lsearch that are supported */
	13
	14	enum {
	15	LSEARCH_PLAIN, /* Literal keys */
	16	LSEARCH_WILD, /* Wild card keys, expanded */
	17	LSEARCH_NWILD, /* Wild card keys, not expanded */
	18	LSEARCH_IP /* IP addresses and networks */
	19	};
	20
	21
	22
	23	/*************************************************
	24	* Open entry point *
	25	*************************************************/
	26
	27	/* See local README for interface description */
	28
e6d225ae	29	static void *
d447dbd1	30	lsearch_open(const uschar * filename, uschar ** errmsg)
0756eb3c PH	31	{
	32	FILE *f = Ufopen(filename, "rb");
	33	if (f == NULL)
	34	{
	35	int save_errno = errno;
	36	*errmsg = string_open_failed(errno, "%s for linear search", filename);
	37	errno = save_errno;
	38	return NULL;
	39	}
	40	return f;
	41	}
	42
	43
	44
	45	/*************************************************
	46	* Check entry point *
	47	*************************************************/
	48
e6d225ae	49	static BOOL
d447dbd1	50	lsearch_check(void handle, const uschar filename, int modemask, uid_t *owners,
0756eb3c PH	51	gid_t owngroups, uschar *errmsg)
	52	{
	53	return lf_check_file(fileno((FILE *)handle), filename, S_IFREG, modemask,
	54	owners, owngroups, "lsearch", errmsg) == 0;
	55	}
	56
	57
	58
	59	/*************************************************
	60	* Internal function for the various lsearches *
	61	*************************************************/
	62
	63	/* See local README for interface description, plus:
	64
	65	Extra argument:
	66
	67	type one of the values LSEARCH_PLAIN, LSEARCH_WILD, LSEARCH_NWILD, or
	68	LSEARCH_IP
	69
	70	There is some messy logic in here to cope with very long data lines that do not
	71	fit into the fixed sized buffer. Most of the time this will never be exercised,
	72	but people do occasionally do weird things. */
	73
	74	static int
d447dbd1 JH	75	internal_lsearch_find(void * handle, const uschar * filename,
	76	const uschar * keystring, int length, uschar result, uschar errmsg,
	77	int type)
0756eb3c PH	78	{
	79	FILE f = (FILE )handle;
	80	BOOL last_was_eol = TRUE;
	81	BOOL this_is_eol = TRUE;
	82	int old_pool = store_pool;
f3ebb786	83	rmark reset_point = NULL;
0756eb3c PH	84	uschar buffer[4096];
	85
	86	/* Wildcard searches may use up some store, because of expansions. We don't
	87	want them to fill up our search store. What we do is set the pool to the main
	88	pool and get a point to reset to later. Wildcard searches could also issue
	89	lookups, but internal_search_find will take care of that, and the cache will be
	90	safely stored in the search pool again. */
	91
	92	if(type == LSEARCH_WILD \|\| type == LSEARCH_NWILD)
	93	{
	94	store_pool = POOL_MAIN;
f3ebb786	95	reset_point = store_mark();
0756eb3c PH	96	}
	97
	98	filename = filename; /* Keep picky compilers happy */
	99	errmsg = errmsg;
	100
	101	rewind(f);
	102	for (last_was_eol = TRUE;
	103	Ufgets(buffer, sizeof(buffer), f) != NULL;
	104	last_was_eol = this_is_eol)
	105	{
0756eb3c PH	106	int p = Ustrlen(buffer);
0756eb3c PH	107	int linekeylength;
dbb0bf41	108	BOOL this_is_comment;
acec9514	109	gstring * yield;
0756eb3c PH	110	uschar *s = buffer;
	111
	112	/* Check whether this the final segment of a line. If it follows an
	113	incomplete part-line, skip it. */
	114
	115	this_is_eol = p > 0 && buffer[p-1] == '\n';
	116	if (!last_was_eol) continue;
	117
	118	/* We now have the start of a physical line. If this is a final line segment,
	119	remove trailing white space. */
	120
	121	if (this_is_eol)
	122	{
	123	while (p > 0 && isspace((uschar)buffer[p-1])) p--;
	124	buffer[p] = 0;
	125	}
	126
	127	/* If the buffer is empty it might be (a) a complete empty line, or (b) the
	128	start of a line that begins with so much white space that it doesn't all fit
	129	in the buffer. In both cases we want to skip the entire physical line.
	130
	131	If the buffer begins with # it is a comment line; if it begins with white
	132	space it is a logical continuation; again, we want to skip the entire
	133	physical line. */
	134
	135	if (buffer[0] == 0 \|\| buffer[0] == '#' \|\| isspace(buffer[0])) continue;
	136
	137	/* We assume that they key will fit in the buffer. If the key starts with ",
	138	read it as a quoted string. We don't use string_dequote() because that uses
	139	new store for the result, and we may be doing this many times in a long file.
	140	We know that the dequoted string must be shorter than the original, because
	141	we are removing the quotes, and also any escape sequences always turn two or
	142	more characters into one character. Therefore, we can store the new string in
	143	the same buffer. */
	144
	145	if (*s == '\"')
	146	{
	147	uschar *t = s++;
	148	while (s != 0 && s != '\"')
	149	{
55414b25	150	if (s == '\\') t++ = string_interpret_escape(CUSS &s);
0756eb3c PH	151	else t++ = s;
	152	s++;
	153	}
	154	if (s != 0) s++; / Past terminating " */
	155	linekeylength = t - buffer;
	156	}
	157
	158	/* Otherwise it is terminated by a colon or white space */
	159
	160	else
	161	{
	162	while (s != 0 && s != ':' && !isspace(*s)) s++;
	163	linekeylength = s - buffer;
	164	}
	165
	166	/* The matching test depends on which kind of lsearch we are doing */
	167
	168	switch(type)
	169	{
	170	/* A plain lsearch treats each key as a literal */
	171
	172	case LSEARCH_PLAIN:
	173	if (linekeylength != length \|\| strncmpic(buffer, keystring, length) != 0)
	174	continue;
	175	break; /* Key matched */
	176
	177	/* A wild lsearch treats each key as a possible wildcarded string; no
	178	expansion is done for nwildlsearch. */
	179
	180	case LSEARCH_WILD:
	181	case LSEARCH_NWILD:
	182	{
	183	int rc;
	184	int save = buffer[linekeylength];
55414b25	185	const uschar *list = buffer;
0756eb3c PH	186	buffer[linekeylength] = 0;
	187	rc = match_isinlist(keystring,
	188	&list,
	189	UCHAR_MAX+1, /* Single-item list */
	190	NULL, /* No anchor */
	191	NULL, /* No caching */
	192	MCL_STRING + ((type == LSEARCH_WILD)? 0:MCL_NOEXPAND),
	193	TRUE, /* Caseless */
	194	NULL);
	195	buffer[linekeylength] = save;
	196	if (rc == FAIL) continue;
	197	if (rc == DEFER) return DEFER;
	198	}
eba0c039 PH	199
	200	/* The key has matched. If the search involved a regular expression, it
	201	might have caused numerical variables to be set. However, their values will
	202	be in the wrong storage pool for external use. Copying them to the standard
	203	pool is not feasible because of the caching of lookup results - a repeated
	204	lookup will not match the regular expression again. Therefore, we flatten
	205	all numeric variables at this point. */
	206
	207	expand_nmax = -1;
	208	break;
0756eb3c PH	209
	210	/* Compare an ip address against a list of network/ip addresses. We have to
	211	allow for the "" case specially. /
	212
	213	case LSEARCH_IP:
	214	if (linekeylength == 1 && buffer[0] == '*')
	215	{
	216	if (length != 1 \|\| keystring[0] != '*') continue;
	217	}
	218	else if (length == 1 && keystring[0] == '*') continue;
	219	else
	220	{
	221	int maskoffset;
	222	int save = buffer[linekeylength];
	223	buffer[linekeylength] = 0;
a5a28604	224	if (string_is_ip_address(buffer, &maskoffset) == 0 \|\|
0756eb3c PH	225	!host_is_in_net(keystring, buffer, maskoffset)) continue;
	226	buffer[linekeylength] = save;
	227	}
	228	break; /* Key matched */
	229	}
	230
	231	/* The key has matched. Skip spaces after the key, and allow an optional
	232	colon after the spaces. This is an odd specification, but it's for
	233	compatibility. */
	234
	235	while (isspace((uschar)*s)) s++;
	236	if (*s == ':')
	237	{
	238	s++;
	239	while (isspace((uschar)*s)) s++;
	240	}
	241
	242	/* Reset dynamic store, if we need to, and revert to the search pool */
	243
acec9514	244	if (reset_point)
0756eb3c	245	{
f3ebb786	246	reset_point = store_reset(reset_point);
0756eb3c PH	247	store_pool = old_pool;
	248	}
	249
	250	/* Now we want to build the result string to contain the data. There can be
	251	two kinds of continuation: (a) the physical line may not all have fitted into
	252	the buffer, and (b) there may be logical continuation lines, for which we
	253	must convert all leading white space into a single blank.
	254
	255	Initialize, and copy the first segment of data. */
	256
dbb0bf41	257	this_is_comment = FALSE;
acec9514	258	yield = string_get(100);
0756eb3c	259	if (*s != 0)
acec9514	260	yield = string_cat(yield, s);
0756eb3c PH	261
	262	/* Now handle continuations */
	263
	264	for (last_was_eol = this_is_eol;
	265	Ufgets(buffer, sizeof(buffer), f) != NULL;
	266	last_was_eol = this_is_eol)
	267	{
	268	s = buffer;
	269	p = Ustrlen(buffer);
	270	this_is_eol = p > 0 && buffer[p-1] == '\n';
	271
	272	/* Remove trailing white space from a physical line end */
	273
	274	if (this_is_eol)
	275	{
	276	while (p > 0 && isspace((uschar)buffer[p-1])) p--;
	277	buffer[p] = 0;
	278	}
	279
	280	/* If this is not a physical line continuation, skip it entirely if it's
	281	empty or starts with #. Otherwise, break the loop if it doesn't start with
	282	white space. Otherwise, replace leading white space with a single blank. */
	283
	284	if (last_was_eol)
	285	{
31ffd7bf	286	this_is_comment = (this_is_comment \|\| (buffer[0] == 0 \|\| buffer[0] == '#'));
dbb0bf41	287	if (this_is_comment) continue;
0756eb3c PH	288	if (!isspace((uschar)buffer[0])) break;
	289	while (isspace((uschar)*s)) s++;
	290	*(--s) = ' ';
	291	}
dbb0bf41	292	if (this_is_comment) continue;
0756eb3c PH	293
	294	/* Join a physical or logical line continuation onto the result string. */
	295
acec9514	296	yield = string_cat(yield, s);
0756eb3c PH	297	}
0756eb3c PH	298
f3ebb786	299	gstring_release_unused(yield);
acec9514	300	*result = string_from_gstring(yield);
0756eb3c PH	301	return OK;
	302	}
	303
	304	/* Reset dynamic store, if we need to */
	305
acec9514	306	if (reset_point)
0756eb3c PH	307	{
	308	store_reset(reset_point);
	309	store_pool = old_pool;
	310	}
	311
	312	return FAIL;
	313	}
	314
	315
	316	/*************************************************
	317	* Find entry point for lsearch *
	318	*************************************************/
	319
	320	/* See local README for interface description */
	321
e6d225ae	322	static int
d447dbd1	323	lsearch_find(void * handle, const uschar * filename, const uschar * keystring,
67a57a5a JH	324	int length, uschar result, uschar errmsg, uint * do_cache,
67a57a5a JH	325	const uschar * opts)
0756eb3c PH	326	{
	327	do_cache = do_cache; /* Keep picky compilers happy */
	328	return internal_lsearch_find(handle, filename, keystring, length, result,
	329	errmsg, LSEARCH_PLAIN);
	330	}
	331
	332
	333
	334	/*************************************************
	335	* Find entry point for wildlsearch *
	336	*************************************************/
	337
	338	/* See local README for interface description */
	339
e6d225ae	340	static int
d447dbd1	341	wildlsearch_find(void * handle, const uschar * filename, const uschar * keystring,
67a57a5a JH	342	int length, uschar result, uschar errmsg, uint * do_cache,
67a57a5a JH	343	const uschar * opts)
0756eb3c PH	344	{
	345	do_cache = do_cache; /* Keep picky compilers happy */
	346	return internal_lsearch_find(handle, filename, keystring, length, result,
	347	errmsg, LSEARCH_WILD);
	348	}
	349
	350
	351
	352	/*************************************************
	353	* Find entry point for nwildlsearch *
	354	*************************************************/
	355
	356	/* See local README for interface description */
	357
e6d225ae	358	static int
d447dbd1	359	nwildlsearch_find(void * handle, const uschar * filename, const uschar * keystring,
67a57a5a JH	360	int length, uschar result, uschar errmsg, uint * do_cache,
67a57a5a JH	361	const uschar * opts)
0756eb3c PH	362	{
	363	do_cache = do_cache; /* Keep picky compilers happy */
	364	return internal_lsearch_find(handle, filename, keystring, length, result,
	365	errmsg, LSEARCH_NWILD);
	366	}
	367
	368
	369
	370
	371	/*************************************************
	372	* Find entry point for iplsearch *
	373	*************************************************/
	374
	375	/* See local README for interface description */
	376
e6d225ae	377	static int
d447dbd1	378	iplsearch_find(void * handle, uschar const * filename, const uschar * keystring,
67a57a5a JH	379	int length, uschar result, uschar errmsg, uint * do_cache,
67a57a5a JH	380	const uschar * opts)
0756eb3c PH	381	{
0756eb3c PH	382	do_cache = do_cache; /* Keep picky compilers happy */
d447dbd1	383
0756eb3c	384	if ((length == 1 && keystring[0] == '*') \|\|
7e66e54d	385	string_is_ip_address(keystring, NULL) != 0)
0756eb3c PH	386	return internal_lsearch_find(handle, filename, keystring, length, result,
0756eb3c PH	387	errmsg, LSEARCH_IP);
d447dbd1 JH	388
	389	*errmsg = string_sprintf("\"%s\" is not a valid iplsearch key (an IP "
	390	"address, with optional CIDR mask, is wanted): "
	391	"in a host list, use net-iplsearch as the search type", keystring);
	392	return DEFER;
0756eb3c PH	393	}
	394
	395
	396
	397
	398	/*************************************************
	399	* Close entry point *
	400	*************************************************/
	401
	402	/* See local README for interface description */
	403
e6d225ae	404	static void
0756eb3c PH	405	lsearch_close(void *handle)
0756eb3c PH	406	{
f1e894f3	407	(void)fclose((FILE *)handle);
0756eb3c PH	408	}
0756eb3c PH	409
6545de78 PP	410
	411
	412	/*************************************************
	413	* Version reporting entry point *
	414	*************************************************/
	415
	416	/* See local README for interface description. */
	417
	418	#include "../version.h"
	419
	420	void
	421	lsearch_version_report(FILE *f)
	422	{
	423	#ifdef DYNLOOKUP
	424	fprintf(f, "Library version: lsearch: Exim version %s\n", EXIM_VERSION_STR);
	425	#endif
	426	}
	427
	428
e6d225ae	429	static lookup_info iplsearch_lookup_info = {
9f400174 JH	430	.name = US"iplsearch", /* lookup name */
	431	.type = lookup_absfile, /* uses absolute file name */
	432	.open = lsearch_open, /* open function */
	433	.check = lsearch_check, /* check function */
	434	.find = iplsearch_find, /* find function */
	435	.close = lsearch_close, /* close function */
	436	.tidy = NULL, /* no tidy function */
	437	.quote = NULL, /* no quoting function */
	438	.version_report = NULL /* no version reporting (redundant) */
e6d225ae DW	439	};
	440
	441	static lookup_info lsearch_lookup_info = {
9f400174 JH	442	.name = US"lsearch", /* lookup name */
	443	.type = lookup_absfile, /* uses absolute file name */
	444	.open = lsearch_open, /* open function */
	445	.check = lsearch_check, /* check function */
	446	.find = lsearch_find, /* find function */
	447	.close = lsearch_close, /* close function */
	448	.tidy = NULL, /* no tidy function */
	449	.quote = NULL, /* no quoting function */
	450	.version_report = lsearch_version_report /* version reporting */
e6d225ae DW	451	};
	452
	453	static lookup_info nwildlsearch_lookup_info = {
9f400174 JH	454	.name = US"nwildlsearch", /* lookup name */
	455	.type = lookup_absfile, /* uses absolute file name */
	456	.open = lsearch_open, /* open function */
	457	.check = lsearch_check, /* check function */
	458	.find = nwildlsearch_find, /* find function */
	459	.close = lsearch_close, /* close function */
	460	.tidy = NULL, /* no tidy function */
	461	.quote = NULL, /* no quoting function */
	462	.version_report = NULL /* no version reporting (redundant) */
e6d225ae DW	463	};
	464
	465	static lookup_info wildlsearch_lookup_info = {
9f400174 JH	466	.name = US"wildlsearch", /* lookup name */
	467	.type = lookup_absfile, /* uses absolute file name */
	468	.open = lsearch_open, /* open function */
	469	.check = lsearch_check, /* check function */
	470	.find = wildlsearch_find, /* find function */
	471	.close = lsearch_close, /* close function */
	472	.tidy = NULL, /* no tidy function */
	473	.quote = NULL, /* no quoting function */
	474	.version_report = NULL /* no version reporting (redundant) */
e6d225ae DW	475	};
	476
	477	#ifdef DYNLOOKUP
	478	#define lsearch_lookup_module_info _lookup_module_info
	479	#endif
	480
	481	static lookup_info *_lookup_list[] = { &iplsearch_lookup_info,
	482	&lsearch_lookup_info,
	483	&nwildlsearch_lookup_info,
	484	&wildlsearch_lookup_info };
	485	lookup_module_info lsearch_lookup_module_info = { LOOKUP_MODULE_INFO_MAGIC, _lookup_list, 4 };
	486
0756eb3c	487	/* End of lookups/lsearch.c */