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