C99 initialisers
[exim.git] / src / src / lookups / lsearch.c
1 /*************************************************
2 * Exim - an Internet mail transport agent *
3 *************************************************/
4
5 /* Copyright (c) University of Cambridge 1995 - 2018 */
6 /* See the file NOTICE for conditions of use and distribution. */
7
8 #include "../exim.h"
9 #include "lf_functions.h"
10
11 /* Codes for the different kinds of lsearch that are supported */
12
13 enum {
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
28 static void *
29 lsearch_open(const uschar * filename, uschar ** errmsg)
30 {
31 FILE *f = Ufopen(filename, "rb");
32 if (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 }
39 return f;
40 }
41
42
43
44 /*************************************************
45 * Check entry point *
46 *************************************************/
47
48 static BOOL
49 lsearch_check(void *handle, const uschar *filename, int modemask, uid_t *owners,
50 gid_t *owngroups, uschar **errmsg)
51 {
52 return 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
64 Extra argument:
65
66 type one of the values LSEARCH_PLAIN, LSEARCH_WILD, LSEARCH_NWILD, or
67 LSEARCH_IP
68
69 There is some messy logic in here to cope with very long data lines that do not
70 fit into the fixed sized buffer. Most of the time this will never be exercised,
71 but people do occasionally do weird things. */
72
73 static int
74 internal_lsearch_find(void * handle, const uschar * filename,
75 const uschar * keystring, int length, uschar ** result, uschar ** errmsg,
76 int type)
77 {
78 FILE *f = (FILE *)handle;
79 BOOL last_was_eol = TRUE;
80 BOOL this_is_eol = TRUE;
81 int old_pool = store_pool;
82 rmark reset_point = NULL;
83 uschar buffer[4096];
84
85 /* Wildcard searches may use up some store, because of expansions. We don't
86 want them to fill up our search store. What we do is set the pool to the main
87 pool and get a point to reset to later. Wildcard searches could also issue
88 lookups, but internal_search_find will take care of that, and the cache will be
89 safely stored in the search pool again. */
90
91 if(type == LSEARCH_WILD || type == LSEARCH_NWILD)
92 {
93 store_pool = POOL_MAIN;
94 reset_point = store_mark();
95 }
96
97 filename = filename; /* Keep picky compilers happy */
98 errmsg = errmsg;
99
100 rewind(f);
101 for (last_was_eol = TRUE;
102 Ufgets(buffer, sizeof(buffer), f) != NULL;
103 last_was_eol = this_is_eol)
104 {
105 int p = Ustrlen(buffer);
106 int linekeylength;
107 BOOL this_is_comment;
108 gstring * 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 {
149 if (*s == '\\') *t++ = string_interpret_escape(CUSS &s);
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];
184 const uschar *list = buffer;
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 }
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;
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;
223 if (string_is_ip_address(buffer, &maskoffset) == 0 ||
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)
244 {
245 reset_point = 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
256 this_is_comment = FALSE;
257 yield = string_get(100);
258 if (*s != 0)
259 yield = string_cat(yield, s);
260
261 /* Now handle continuations */
262
263 for (last_was_eol = this_is_eol;
264 Ufgets(buffer, sizeof(buffer), f) != NULL;
265 last_was_eol = this_is_eol)
266 {
267 s = buffer;
268 p = Ustrlen(buffer);
269 this_is_eol = p > 0 && buffer[p-1] == '\n';
270
271 /* Remove trailing white space from a physical line end */
272
273 if (this_is_eol)
274 {
275 while (p > 0 && isspace((uschar)buffer[p-1])) p--;
276 buffer[p] = 0;
277 }
278
279 /* If this is not a physical line continuation, skip it entirely if it's
280 empty or starts with #. Otherwise, break the loop if it doesn't start with
281 white space. Otherwise, replace leading white space with a single blank. */
282
283 if (last_was_eol)
284 {
285 this_is_comment = (this_is_comment || (buffer[0] == 0 || buffer[0] == '#'));
286 if (this_is_comment) continue;
287 if (!isspace((uschar)buffer[0])) break;
288 while (isspace((uschar)*s)) s++;
289 *(--s) = ' ';
290 }
291 if (this_is_comment) continue;
292
293 /* Join a physical or logical line continuation onto the result string. */
294
295 yield = string_cat(yield, s);
296 }
297
298 gstring_release_unused(yield);
299 *result = string_from_gstring(yield);
300 return OK;
301 }
302
303 /* Reset dynamic store, if we need to */
304
305 if (reset_point)
306 {
307 store_reset(reset_point);
308 store_pool = old_pool;
309 }
310
311 return FAIL;
312 }
313
314
315 /*************************************************
316 * Find entry point for lsearch *
317 *************************************************/
318
319 /* See local README for interface description */
320
321 static int
322 lsearch_find(void * handle, const uschar * filename, const uschar * keystring,
323 int length, uschar ** result, uschar ** errmsg, uint * do_cache,
324 const uschar * opts)
325 {
326 do_cache = do_cache; /* Keep picky compilers happy */
327 return internal_lsearch_find(handle, filename, keystring, length, result,
328 errmsg, LSEARCH_PLAIN);
329 }
330
331
332
333 /*************************************************
334 * Find entry point for wildlsearch *
335 *************************************************/
336
337 /* See local README for interface description */
338
339 static int
340 wildlsearch_find(void * handle, const uschar * filename, const uschar * keystring,
341 int length, uschar ** result, uschar ** errmsg, uint * do_cache,
342 const uschar * opts)
343 {
344 do_cache = do_cache; /* Keep picky compilers happy */
345 return internal_lsearch_find(handle, filename, keystring, length, result,
346 errmsg, LSEARCH_WILD);
347 }
348
349
350
351 /*************************************************
352 * Find entry point for nwildlsearch *
353 *************************************************/
354
355 /* See local README for interface description */
356
357 static int
358 nwildlsearch_find(void * handle, const uschar * filename, const uschar * keystring,
359 int length, uschar ** result, uschar ** errmsg, uint * do_cache,
360 const uschar * opts)
361 {
362 do_cache = do_cache; /* Keep picky compilers happy */
363 return 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
376 static int
377 iplsearch_find(void * handle, uschar const * filename, const uschar * keystring,
378 int length, uschar ** result, uschar ** errmsg, uint * do_cache,
379 const uschar * opts)
380 {
381 do_cache = do_cache; /* Keep picky compilers happy */
382
383 if ((length == 1 && keystring[0] == '*') ||
384 string_is_ip_address(keystring, NULL) != 0)
385 return internal_lsearch_find(handle, filename, keystring, length, result,
386 errmsg, LSEARCH_IP);
387
388 *errmsg = string_sprintf("\"%s\" is not a valid iplsearch key (an IP "
389 "address, with optional CIDR mask, is wanted): "
390 "in a host list, use net-iplsearch as the search type", keystring);
391 return DEFER;
392 }
393
394
395
396
397 /*************************************************
398 * Close entry point *
399 *************************************************/
400
401 /* See local README for interface description */
402
403 static void
404 lsearch_close(void *handle)
405 {
406 (void)fclose((FILE *)handle);
407 }
408
409
410
411 /*************************************************
412 * Version reporting entry point *
413 *************************************************/
414
415 /* See local README for interface description. */
416
417 #include "../version.h"
418
419 void
420 lsearch_version_report(FILE *f)
421 {
422 #ifdef DYNLOOKUP
423 fprintf(f, "Library version: lsearch: Exim version %s\n", EXIM_VERSION_STR);
424 #endif
425 }
426
427
428 static lookup_info iplsearch_lookup_info = {
429 .name = US"iplsearch", /* lookup name */
430 .type = lookup_absfile, /* uses absolute file name */
431 .open = lsearch_open, /* open function */
432 .check = lsearch_check, /* check function */
433 .find = iplsearch_find, /* find function */
434 .close = lsearch_close, /* close function */
435 .tidy = NULL, /* no tidy function */
436 .quote = NULL, /* no quoting function */
437 .version_report = NULL /* no version reporting (redundant) */
438 };
439
440 static lookup_info lsearch_lookup_info = {
441 .name = US"lsearch", /* lookup name */
442 .type = lookup_absfile, /* uses absolute file name */
443 .open = lsearch_open, /* open function */
444 .check = lsearch_check, /* check function */
445 .find = lsearch_find, /* find function */
446 .close = lsearch_close, /* close function */
447 .tidy = NULL, /* no tidy function */
448 .quote = NULL, /* no quoting function */
449 .version_report = lsearch_version_report /* version reporting */
450 };
451
452 static lookup_info nwildlsearch_lookup_info = {
453 .name = US"nwildlsearch", /* lookup name */
454 .type = lookup_absfile, /* uses absolute file name */
455 .open = lsearch_open, /* open function */
456 .check = lsearch_check, /* check function */
457 .find = nwildlsearch_find, /* find function */
458 .close = lsearch_close, /* close function */
459 .tidy = NULL, /* no tidy function */
460 .quote = NULL, /* no quoting function */
461 .version_report = NULL /* no version reporting (redundant) */
462 };
463
464 static lookup_info wildlsearch_lookup_info = {
465 .name = US"wildlsearch", /* lookup name */
466 .type = lookup_absfile, /* uses absolute file name */
467 .open = lsearch_open, /* open function */
468 .check = lsearch_check, /* check function */
469 .find = wildlsearch_find, /* find function */
470 .close = lsearch_close, /* close function */
471 .tidy = NULL, /* no tidy function */
472 .quote = NULL, /* no quoting function */
473 .version_report = NULL /* no version reporting (redundant) */
474 };
475
476 #ifdef DYNLOOKUP
477 #define lsearch_lookup_module_info _lookup_module_info
478 #endif
479
480 static lookup_info *_lookup_list[] = { &iplsearch_lookup_info,
481 &lsearch_lookup_info,
482 &nwildlsearch_lookup_info,
483 &wildlsearch_lookup_info };
484 lookup_module_info lsearch_lookup_module_info = { LOOKUP_MODULE_INFO_MAGIC, _lookup_list, 4 };
485
486 /* End of lookups/lsearch.c */