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