tidying
[exim.git] / src / src / search.c
CommitLineData
059ec3d9
PH
1/*************************************************
2* Exim - an Internet mail transport agent *
3*************************************************/
4
3386088d 5/* Copyright (c) University of Cambridge 1995 - 2015 */
059ec3d9
PH
6/* See the file NOTICE for conditions of use and distribution. */
7
8/* A set of functions to search databases in various formats. An open
9database is represented by a void * value which is returned from a lookup-
10specific "open" function. These are now all held in individual modules in the
11lookups subdirectory and the functions here form a generic interface.
12
13Caching is used to improve performance. Open files are cached until a tidyup
14function is called, and for each file the result of the last lookup is cached.
15However, if too many files are opened, some of those that are not in use have
16to be closed. Those open items that use real files are kept on a LRU chain to
17help with this.
18
19All the data is held in permanent store so as to be independent of the stacking
20pool that is reset from time to time. In fact, we use malloc'd store so that it
21can be freed when the caches are tidied up. It isn't actually clear whether
22this is a benefit or not, to be honest. */
23
24#include "exim.h"
25
26
27/* Tree in which to cache open files until tidyup called. */
28
29static tree_node *search_tree = NULL;
30
31/* Two-way chain of open databases that use real files. This is maintained in
32recently-used order for the purposes of closing the least recently used when
33too many files are open. */
34
35static tree_node *open_top = NULL;
36static tree_node *open_bot = NULL;
37
38/* Count of open databases that use real files */
39
40static int open_filecount = 0;
41
42/* Allow us to reset store used for lookups and lookup caching */
43
44static void *search_reset_point = NULL;
45
46
47
48/*************************************************
49* Validate a plain lookup type name *
50*************************************************/
51
52/* Only those names that are recognized and whose code is included in the
53binary give an OK response. Use a binary chop search now that the list has got
54so long.
55
56Arguments:
57 name lookup type name - not necessarily zero terminated (e.g. dbm*)
58 len length of the name
59
60Returns: +ve => valid lookup name; value is offset in lookup_list
61 -ve => invalid name; message in search_error_message.
62*/
63
64int
55414b25 65search_findtype(const uschar *name, int len)
059ec3d9
PH
66{
67int bot = 0;
68int top = lookup_list_count;
69while (top > bot)
70 {
71 int mid = (top + bot)/2;
e6d225ae 72 int c = Ustrncmp(name, lookup_list[mid]->name, len);
059ec3d9
PH
73
74 /* If c == 0 we have matched the incoming name with the start of the search
75 type name. However, some search types are substrings of others (e.g. nis and
76 nisplus) so we need to check that the lengths are the same. The length of the
77 type name cannot be shorter (else c would not be 0); if it is not equal it
78 must be longer, and in that case, the incoming name comes before the name we
79 are testing. By leaving c == 0 when the lengths are different, and doing a
80 > 0 test below, this all falls out correctly. */
81
e6d225ae 82 if (c == 0 && Ustrlen(lookup_list[mid]->name) == len)
059ec3d9 83 {
e6d225ae 84 if (lookup_list[mid]->find != NULL) return mid;
059ec3d9
PH
85 search_error_message = string_sprintf("lookup type \"%.*s\" is not "
86 "available (not in the binary - check buildtime LOOKUP configuration)",
87 len, name);
88 return -1;
89 }
90
91 if (c > 0) bot = mid + 1; else top = mid;
92 }
93
94search_error_message = string_sprintf("unknown lookup type \"%.*s\"",len,name);
95return -1;
96}
97
98
99
100/*************************************************
101* Validate a full lookup type name *
102*************************************************/
103
104/* This function recognizes the "partial-" prefix and also terminating * and *@
105suffixes.
106
107Arguments:
108 name the full lookup type name
109 ptypeptr where to put the partial type
110 after subtraction of 1024 or 2048:
111 negative => no partial matching
112 non-negative => minimum number of non-wild components
113 ptypeaff where to put a pointer to the affix
114 the affix is within name if supplied therein
115 otherwise it's a literal string
116 afflen the length of the affix
117 starflags where to put the SEARCH_STAR and SEARCH_STARAT flags
118
119Returns: +ve => valid lookup name; value is offset in lookup_list
120 -ve => invalid name; message in search_error_message.
121*/
122
123int
55414b25 124search_findtype_partial(const uschar *name, int *ptypeptr, const uschar **ptypeaff,
059ec3d9
PH
125 int *afflen, int *starflags)
126{
127int len, stype;
128int pv = -1;
55414b25 129const uschar *ss = name;
059ec3d9
PH
130
131*starflags = 0;
132*ptypeaff = NULL;
133
134/* Check for a partial matching type. It must start with "partial", optionally
135followed by a sequence of digits. If this is followed by "-", the affix is the
136default "*." string. Otherwise we expect an affix in parentheses. Affixes are a
137limited number of characters, not including parens. */
138
139if (Ustrncmp(name, "partial", 7) == 0)
140 {
141 ss += 7;
142 if (isdigit (*ss))
143 {
144 pv = 0;
145 while (isdigit(*ss)) pv = pv*10 + *ss++ - '0';
146 }
147 else pv = 2; /* Default number of wild components */
148
149 if (*ss == '(')
150 {
151 *ptypeaff = ++ss;
152 while (ispunct(*ss) && *ss != ')') ss++;
153 if (*ss != ')') goto BAD_TYPE;
154 *afflen = ss++ - *ptypeaff;
155 }
156 else if (*ss++ == '-')
157 {
158 *ptypeaff = US "*.";
159 *afflen = 2;
160 }
161 else
162 {
163 BAD_TYPE:
164 search_error_message = string_sprintf("format error in lookup type \"%s\"",
165 name);
166 return -1;
167 }
168 }
169
170/* Now we are left with a lookup name, possibly followed by * or *@. */
171
172len = Ustrlen(ss);
173if (len >= 2 && Ustrncmp(ss + len - 2, "*@", 2) == 0)
174 {
175 *starflags |= SEARCH_STARAT;
176 len -= 2;
177 }
178else if (len >= 1 && ss[len-1] == '*')
179 {
180 *starflags |= SEARCH_STAR;
181 len--;
182 }
183
184/* Check for the individual search type. Only those that are actually in the
d7837193
PH
185binary are valid. For query-style types, "partial" and default types are
186erroneous. */
059ec3d9
PH
187
188stype = search_findtype(ss, len);
d7837193 189if (stype >= 0 && mac_islookup(stype, lookup_querystyle))
059ec3d9 190 {
d7837193
PH
191 if (pv >= 0)
192 {
193 search_error_message = string_sprintf("\"partial\" is not permitted "
194 "for lookup type \"%s\"", ss);
195 return -1;
196 }
197 if ((*starflags & (SEARCH_STAR|SEARCH_STARAT)) != 0)
198 {
199 search_error_message = string_sprintf("defaults using \"*\" or \"*@\" are "
200 "not permitted for lookup type \"%s\"", ss);
201 return -1;
202 }
059ec3d9
PH
203 }
204
059ec3d9
PH
205*ptypeptr = pv;
206return stype;
207}
208
209
210
211/*************************************************
212* Release cached resources *
213*************************************************/
214
215/* When search_open is called it caches the "file" that it opens in
216search_tree. The name of the tree node is a concatenation of the search type
217with the file name. For query-style lookups, the file name is empty. Real files
218are normally closed only when this tidyup routine is called, typically at the
219end of sections of code where a number of lookups might occur. However, if too
220many files are open simultaneously, some get closed beforehand. They can't be
221removed from the tree. There is also a general tidyup function which is called
222for the lookup driver, if it exists.
223
224First, there is an internal, recursive subroutine.
225
226Argument: a pointer to a search_openfile tree node
227Returns: nothing
228*/
229
230static void
231tidyup_subtree(tree_node *t)
232{
233search_cache *c = (search_cache *)(t->data.ptr);
234if (t->left != NULL) tidyup_subtree(t->left);
235if (t->right != NULL) tidyup_subtree(t->right);
236if (c != NULL &&
237 c->handle != NULL &&
e6d225ae
DW
238 lookup_list[c->search_type]->close != NULL)
239 lookup_list[c->search_type]->close(c->handle);
059ec3d9
PH
240}
241
242
243/* The external entry point
244
245Argument: none
246Returns: nothing
247*/
248
249void
250search_tidyup(void)
251{
059ec3d9
PH
252int old_pool = store_pool;
253
42c7f0b4 254DEBUG(D_lookup) debug_printf_indent("search_tidyup called\n");
059ec3d9
PH
255
256/* Close individually each cached open file. */
257
258store_pool = POOL_SEARCH;
d7978c0f 259if (search_tree)
059ec3d9
PH
260 {
261 tidyup_subtree(search_tree);
262 search_tree = NULL;
263 }
264open_top = open_bot = NULL;
265open_filecount = 0;
266
267/* Call the general tidyup entry for any drivers that have one. */
268
d7978c0f
JH
269for (int i = 0; i < lookup_list_count; i++) if (lookup_list[i]->tidy)
270 (lookup_list[i]->tidy)();
059ec3d9 271
d7978c0f 272if (search_reset_point) store_reset(search_reset_point);
059ec3d9
PH
273search_reset_point = NULL;
274store_pool = old_pool;
275}
276
277
278
279
280/*************************************************
281* Open search database *
282*************************************************/
283
284/* A mode, and lists of owners and groups, are passed over for checking in
285the cases where the database is one or more files. Return NULL, with a message
286pointed to by message, in cases of error.
287
288For search types that use a file or files, check up on the mode after
289opening. It is tempting to do a stat before opening the file, and use it as
290an existence check. However, doing that opens a small security loophole in
291that the status could be changed before the file is opened. Can't quite see
292what problems this might lead to, but you can't be too careful where security
293is concerned. Fstat() on an open file can normally be expected to succeed,
294but there are some NFS states where it does not.
295
296There are two styles of query: (1) in the "single-key+file" style, a single
297key string and a file name are given, for example, for linear searches, DBM
298files, or for NIS. (2) In the "query" style, no "filename" is given; instead
299just a single query string is passed. This applies to multiple-key lookup
300types such as NIS+.
301
302Before opening, scan the tree of cached files to see if this file is already
303open for the correct search type. If so, return the saved handle. If not, put
304the handle in the tree for possible subsequent use. See search_tidyup above for
305closing all the cached files.
306
307A count of open databases which use real files is maintained, and if this
308gets too large, we have to close a cached file. Its entry remains in the tree,
309but is marked closed.
310
311Arguments:
312 filename the name of the file for single-key+file style lookups,
313 NULL for query-style lookups
314 search_type the type of search required
315 modemask if a real single file is used, this specifies mode bits that
316 must not be set; otherwise it is ignored
317 owners if a real single file is used, this specifies the possible
318 owners of the file; otherwise it is ignored
319 owngroups if a real single file is used, this specifies the possible
320 group owners of the file; otherwise it is ignored
321
322Returns: an identifying handle for the open database;
323 this is the pointer to the tree block in the
324 cache of open files; return NULL on open failure, with
325 a message in search_error_message
326*/
327
328void *
329search_open(uschar *filename, int search_type, int modemask, uid_t *owners,
330 gid_t *owngroups)
331{
332void *handle;
333tree_node *t;
334search_cache *c;
e6d225ae 335lookup_info *lk = lookup_list[search_type];
059ec3d9
PH
336uschar keybuffer[256];
337int old_pool = store_pool;
338
339/* Change to the search store pool and remember our reset point */
340
341store_pool = POOL_SEARCH;
342if (search_reset_point == NULL) search_reset_point = store_get(0);
343
42c7f0b4
JH
344DEBUG(D_lookup) debug_printf_indent("search_open: %s \"%s\"\n", lk->name,
345 filename ? filename : US"NULL");
059ec3d9
PH
346
347/* See if we already have this open for this type of search, and if so,
348pass back the tree block as the handle. The key for the tree node is the search
349type plus '0' concatenated with the file name. There may be entries in the tree
350with closed files if a lot of files have been opened. */
351
352sprintf(CS keybuffer, "%c%.254s", search_type + '0',
df04890c 353 filename ? filename : US"");
059ec3d9 354
df04890c 355if ((t = tree_search(search_tree, keybuffer)))
059ec3d9
PH
356 {
357 c = (search_cache *)(t->data.ptr);
df04890c 358 if (c->handle)
059ec3d9 359 {
42c7f0b4 360 DEBUG(D_lookup) debug_printf_indent(" cached open\n");
059ec3d9
PH
361 store_pool = old_pool;
362 return t;
363 }
42c7f0b4 364 DEBUG(D_lookup) debug_printf_indent(" cached closed\n");
059ec3d9
PH
365 }
366
367/* Otherwise, we need to open the file or database - each search type has its
368own code, which is now split off into separately compiled modules. Before doing
369this, if the search type is one that uses real files, check on the number that
370we are holding open in the cache. If the limit is reached, close the least
371recently used one. */
372
373if (lk->type == lookup_absfile && open_filecount >= lookup_open_max)
374 {
df04890c 375 if (!open_bot)
059ec3d9
PH
376 log_write(0, LOG_MAIN|LOG_PANIC, "too many lookups open, but can't find "
377 "one to close");
378 else
379 {
380 search_cache *c = (search_cache *)(open_bot->data.ptr);
42c7f0b4 381 DEBUG(D_lookup) debug_printf_indent("Too many lookup files open\n closing %s\n",
059ec3d9 382 open_bot->name);
df04890c 383 if ((open_bot = c->up))
059ec3d9
PH
384 ((search_cache *)(open_bot->data.ptr))->down = NULL;
385 else
386 open_top = NULL;
e6d225ae 387 ((lookup_list[c->search_type])->close)(c->handle);
059ec3d9
PH
388 c->handle = NULL;
389 open_filecount--;
390 }
391 }
392
393/* If opening is successful, call the file-checking function if there is one,
394and if all is still well, enter the open database into the tree. */
395
df04890c 396if (!(handle = (lk->open)(filename, &search_error_message)))
059ec3d9
PH
397 {
398 store_pool = old_pool;
399 return NULL;
400 }
401
df04890c
JH
402if ( lk->check
403 && !lk->check(handle, filename, modemask, owners, owngroups,
404 &search_error_message))
059ec3d9
PH
405 {
406 lk->close(handle);
407 store_pool = old_pool;
408 return NULL;
409 }
410
411/* If this is a search type that uses real files, keep count. */
412
413if (lk->type == lookup_absfile) open_filecount++;
414
415/* If we found a previously opened entry in the tree, re-use it; otherwise
416insert a new entry. On re-use, leave any cached lookup data and the lookup
417count alone. */
418
df04890c 419if (!t)
059ec3d9
PH
420 {
421 t = store_get(sizeof(tree_node) + Ustrlen(keybuffer));
422 t->data.ptr = c = store_get(sizeof(search_cache));
423 c->item_cache = NULL;
424 Ustrcpy(t->name, keybuffer);
425 tree_insertnode(&search_tree, t);
426 }
427else c = t->data.ptr;
428
429c->handle = handle;
430c->search_type = search_type;
431c->up = c->down = NULL;
432
433store_pool = old_pool;
434return t;
435}
436
437
438
439
440
441/*************************************************
442* Internal function: Find one item in database *
443*************************************************/
444
445/* The answer is always put into dynamic store. The last lookup for each handle
446is cached.
447
448Arguments:
449 handle the handle from search_open; points to tree node
450 filename the filename that was handed to search_open, or
451 NULL for query-style searches
452 keystring the keystring for single-key+file lookups, or
453 the querystring for query-style lookups
454
455Returns: a pointer to a dynamic string containing the answer,
456 or NULL if the query failed or was deferred; in the
457 latter case, search_find_defer is set TRUE; after an unusual
458 failure, there may be a message in search_error_message.
459*/
460
461static uschar *
462internal_search_find(void *handle, uschar *filename, uschar *keystring)
463{
0488984d
JH
464tree_node * t = (tree_node *)handle;
465search_cache * c = (search_cache *)(t->data.ptr);
466expiring_data * e = NULL; /* compiler quietening */
467uschar * data = NULL;
059ec3d9
PH
468int search_type = t->name[0] - '0';
469int old_pool = store_pool;
470
471/* Lookups that return DEFER may not always set an error message. So that
472the callers don't have to test for NULL, set an empty string. */
473
474search_error_message = US"";
8768d548 475f.search_find_defer = FALSE;
059ec3d9 476
42c7f0b4 477DEBUG(D_lookup) debug_printf_indent("internal_search_find: file=\"%s\"\n "
059ec3d9 478 "type=%s key=\"%s\"\n", filename,
e6d225ae 479 lookup_list[search_type]->name, keystring);
059ec3d9
PH
480
481/* Insurance. If the keystring is empty, just fail. */
482
483if (keystring[0] == 0) return NULL;
484
485/* Use the special store pool for search data */
486
487store_pool = POOL_SEARCH;
488
489/* Look up the data for the key, unless it is already in the cache for this
490file. No need to check c->item_cache for NULL, tree_search will do so. */
491
14b3c5bc
JH
492if ( (t = tree_search(c->item_cache, keystring))
493 && (!(e = t->data.ptr)->expiry || e->expiry > time(NULL))
494 )
495 { /* Data was in the cache already; set the pointer from the tree node */
496 data = e->ptr;
42c7f0b4 497 DEBUG(D_lookup) debug_printf_indent("cached data used for lookup of %s%s%s\n",
14b3c5bc
JH
498 keystring,
499 filename ? US"\n in " : US"", filename ? filename : US"");
500 }
501else
059ec3d9 502 {
14b3c5bc 503 uint do_cache = UINT_MAX;
059ec3d9
PH
504 int keylength = Ustrlen(keystring);
505
506 DEBUG(D_lookup)
507 {
42c7f0b4
JH
508 if (t) debug_printf_indent("cached data found but past valid time; ");
509 debug_printf_indent("%s lookup required for %s%s%s\n",
14b3c5bc
JH
510 filename ? US"file" : US"database",
511 keystring,
512 filename ? US"\n in " : US"", filename ? filename : US"");
059ec3d9
PH
513 }
514
515 /* Call the code for the different kinds of search. DEFER is handled
516 like FAIL, except that search_find_defer is set so the caller can
517 distinguish if necessary. */
518
e6d225ae 519 if (lookup_list[search_type]->find(c->handle, filename, keystring, keylength,
059ec3d9 520 &data, &search_error_message, &do_cache) == DEFER)
8768d548 521 f.search_find_defer = TRUE;
059ec3d9
PH
522
523 /* A record that has been found is now in data, which is either NULL
524 or points to a bit of dynamic store. Cache the result of the lookup if
525 caching is permitted. Lookups can disable caching, when they did something
526 that changes their data. The mysql and pgsql lookups do this when an
527 UPDATE/INSERT query was executed. */
528
529 else if (do_cache)
530 {
531 int len = keylength + 1;
14b3c5bc
JH
532
533 if (t) /* Previous, out-of-date cache entry. Update with the */
534 { /* new result and forget the old one */
535 e->expiry = do_cache == UINT_MAX ? 0 : time(NULL)+do_cache;
536 e->ptr = data;
537 }
538 else
539 {
98b98887 540 e = store_get(sizeof(expiring_data) + sizeof(tree_node) + len);
14b3c5bc
JH
541 e->expiry = do_cache == UINT_MAX ? 0 : time(NULL)+do_cache;
542 e->ptr = data;
98b98887 543 t = (tree_node *)(e+1);
14b3c5bc
JH
544 memcpy(t->name, keystring, len);
545 t->data.ptr = e;
546 tree_insertnode(&c->item_cache, t);
547 }
059ec3d9
PH
548 }
549
550 /* If caching was disabled, empty the cache tree. We just set the cache
551 pointer to NULL here, because we cannot release the store at this stage. */
552
553 else
554 {
42c7f0b4 555 DEBUG(D_lookup) debug_printf_indent("lookup forced cache cleanup\n");
059ec3d9
PH
556 c->item_cache = NULL;
557 }
558 }
559
059ec3d9
PH
560DEBUG(D_lookup)
561 {
14b3c5bc 562 if (data)
42c7f0b4 563 debug_printf_indent("lookup yielded: %s\n", data);
8768d548 564 else if (f.search_find_defer)
42c7f0b4
JH
565 debug_printf_indent("lookup deferred: %s\n", search_error_message);
566 else debug_printf_indent("lookup failed\n");
059ec3d9
PH
567 }
568
569/* Return it in new dynamic store in the regular pool */
570
571store_pool = old_pool;
14b3c5bc 572return data ? string_copy(data) : NULL;
059ec3d9
PH
573}
574
575
576
577
578/*************************************************
579* Find one item in database, possibly wildcarded *
580*************************************************/
581
582/* This function calls the internal function above; once only if there
583is no partial matching, but repeatedly when partial matching is requested.
584
585Arguments:
586 handle the handle from search_open
587 filename the filename that was handed to search_open, or
588 NULL for query-style searches
589 keystring the keystring for single-key+file lookups, or
590 the querystring for query-style lookups
591 partial -1 means no partial matching;
592 otherwise it's the minimum number of components;
593 affix the affix string for partial matching
594 affixlen the length of the affix string
595 starflags SEARCH_STAR and SEARCH_STARAT flags
596 expand_setup pointer to offset for setting up expansion strings;
597 don't do any if < 0
598
599Returns: a pointer to a dynamic string containing the answer,
600 or NULL if the query failed or was deferred; in the
601 latter case, search_find_defer is set TRUE
602*/
603
604uschar *
605search_find(void *handle, uschar *filename, uschar *keystring, int partial,
55414b25 606 const uschar *affix, int affixlen, int starflags, int *expand_setup)
059ec3d9
PH
607{
608tree_node *t = (tree_node *)handle;
609BOOL set_null_wild = FALSE;
610uschar *yield;
611
612DEBUG(D_lookup)
613 {
614 if (partial < 0) affixlen = 99; /* So that "NULL" prints */
42c7f0b4 615 debug_printf_indent("search_find: file=\"%s\"\n key=\"%s\" "
059ec3d9
PH
616 "partial=%d affix=%.*s starflags=%x\n",
617 (filename == NULL)? US"NULL" : filename,
618 keystring, partial, affixlen, affix, starflags);
619 }
620
621/* Arrange to put this database at the top of the LRU chain if it is a type
622that opens real files. */
623
df04890c
JH
624if ( open_top != (tree_node *)handle
625 && lookup_list[t->name[0]-'0']->type == lookup_absfile)
059ec3d9
PH
626 {
627 search_cache *c = (search_cache *)(t->data.ptr);
628 tree_node *up = c->up;
629 tree_node *down = c->down;
630
631 /* Cut it out of the list. A newly opened file will a NULL up pointer.
632 Otherwise there will be a non-NULL up pointer, since we checked above that
633 this block isn't already at the top of the list. */
634
df04890c 635 if (up)
059ec3d9
PH
636 {
637 ((search_cache *)(up->data.ptr))->down = down;
df04890c 638 if (down)
059ec3d9 639 ((search_cache *)(down->data.ptr))->up = up;
df04890c
JH
640 else
641 open_bot = up;
059ec3d9
PH
642 }
643
644 /* Now put it at the head of the list. */
645
646 c->up = NULL;
647 c->down = open_top;
df04890c
JH
648 if (!open_top) open_bot = t;
649 else ((search_cache *)(open_top->data.ptr))->up = t;
059ec3d9
PH
650 open_top = t;
651 }
652
653DEBUG(D_lookup)
654 {
42c7f0b4
JH
655 debug_printf_indent("LRU list:\n");
656 for (tree_node *t = open_top; t; )
059ec3d9
PH
657 {
658 search_cache *c = (search_cache *)(t->data.ptr);
42c7f0b4
JH
659 debug_printf_indent(" %s\n", t->name);
660 if (t == open_bot) debug_printf_indent(" End\n");
059ec3d9
PH
661 t = c->down;
662 }
663 }
664
665/* First of all, try to match the key string verbatim. If matched a complete
666entry but could have been partial, flag to set up variables. */
667
668yield = internal_search_find(handle, filename, keystring);
8768d548 669if (f.search_find_defer) return NULL;
df04890c
JH
670
671if (yield) { if (partial >= 0) set_null_wild = TRUE; }
059ec3d9
PH
672
673/* Not matched a complete entry; handle partial lookups, but only if the full
674search didn't defer. Don't use string_sprintf() to construct the initial key,
675just in case the original key is too long for the string_sprintf() buffer (it
676*has* happened!). The case of a zero-length affix has to be treated specially.
677*/
678
679else if (partial >= 0)
680 {
681 int len = Ustrlen(keystring);
682 uschar *keystring2;
683
684 /* Try with the affix on the front, except for a zero-length affix */
685
686 if (affixlen == 0) keystring2 = keystring; else
687 {
688 keystring2 = store_get(len + affixlen + 1);
689 Ustrncpy(keystring2, affix, affixlen);
690 Ustrcpy(keystring2 + affixlen, keystring);
42c7f0b4 691 DEBUG(D_lookup) debug_printf_indent("trying partial match %s\n", keystring2);
059ec3d9 692 yield = internal_search_find(handle, filename, keystring2);
8768d548 693 if (f.search_find_defer) return NULL;
059ec3d9
PH
694 }
695
696 /* The key in its entirety did not match a wild entry; try chopping off
697 leading components. */
698
699 if (yield == NULL)
700 {
701 int dotcount = 0;
702 uschar *keystring3 = keystring2 + affixlen;
703 uschar *s = keystring3;
704 while (*s != 0) if (*s++ == '.') dotcount++;
705
706 while (dotcount-- >= partial)
707 {
708 while (*keystring3 != 0 && *keystring3 != '.') keystring3++;
709
710 /* If we get right to the end of the string (which will be the last time
711 through this loop), we've failed if the affix is null. Otherwise do one
712 last lookup for the affix itself, but if it is longer than 1 character,
713 remove the last character if it is ".". */
714
715 if (*keystring3 == 0)
716 {
717 if (affixlen < 1) break;
718 if (affixlen > 1 && affix[affixlen-1] == '.') affixlen--;
719 Ustrncpy(keystring2, affix, affixlen);
720 keystring2[affixlen] = 0;
721 keystring3 = keystring2;
722 }
723 else
724 {
725 keystring3 -= affixlen - 1;
726 if (affixlen > 0) Ustrncpy(keystring3, affix, affixlen);
727 }
728
42c7f0b4 729 DEBUG(D_lookup) debug_printf_indent("trying partial match %s\n", keystring3);
059ec3d9 730 yield = internal_search_find(handle, filename, keystring3);
8768d548 731 if (f.search_find_defer) return NULL;
df04890c 732 if (yield)
059ec3d9
PH
733 {
734 /* First variable is the wild part; second is the fixed part. Take care
735 to get it right when keystring3 is just "*". */
736
df04890c 737 if (expand_setup && *expand_setup >= 0)
059ec3d9
PH
738 {
739 int fixedlength = Ustrlen(keystring3) - affixlen;
740 int wildlength = Ustrlen(keystring) - fixedlength - 1;
741 *expand_setup += 1;
742 expand_nstring[*expand_setup] = keystring;
743 expand_nlength[*expand_setup] = wildlength;
744 *expand_setup += 1;
745 expand_nstring[*expand_setup] = keystring + wildlength + 1;
746 expand_nlength[*expand_setup] = (fixedlength < 0)? 0 : fixedlength;
747 }
748 break;
749 }
750 keystring3 += affixlen;
751 }
752 }
753
754 else set_null_wild = TRUE; /* Matched a wild entry without any wild part */
755 }
756
757/* If nothing has been matched, but the option to look for "*@" is set, try
4c04137d 758replacing everything to the left of @ by *. After a match, the wild part
059ec3d9
PH
759is set to the string to the left of the @. */
760
df04890c 761if (!yield && starflags & SEARCH_STARAT)
059ec3d9
PH
762 {
763 uschar *atat = Ustrrchr(keystring, '@');
764 if (atat != NULL && atat > keystring)
765 {
766 int savechar;
767 savechar = *(--atat);
768 *atat = '*';
769
42c7f0b4 770 DEBUG(D_lookup) debug_printf_indent("trying default match %s\n", atat);
059ec3d9
PH
771 yield = internal_search_find(handle, filename, atat);
772 *atat = savechar;
8768d548 773 if (f.search_find_defer) return NULL;
059ec3d9 774
df04890c 775 if (yield && expand_setup && *expand_setup >= 0)
059ec3d9
PH
776 {
777 *expand_setup += 1;
778 expand_nstring[*expand_setup] = keystring;
779 expand_nlength[*expand_setup] = atat - keystring + 1;
780 *expand_setup += 1;
781 expand_nstring[*expand_setup] = keystring;
782 expand_nlength[*expand_setup] = 0;
783 }
784 }
785 }
786
787/* If we still haven't matched anything, and the option to look for "*" is set,
788try that. If we do match, the first variable (the wild part) is the whole key,
789and the second is empty. */
790
df04890c 791if (!yield && starflags & (SEARCH_STAR|SEARCH_STARAT))
059ec3d9 792 {
42c7f0b4 793 DEBUG(D_lookup) debug_printf_indent("trying to match *\n");
059ec3d9 794 yield = internal_search_find(handle, filename, US"*");
df04890c 795 if (yield && expand_setup && *expand_setup >= 0)
059ec3d9
PH
796 {
797 *expand_setup += 1;
798 expand_nstring[*expand_setup] = keystring;
799 expand_nlength[*expand_setup] = Ustrlen(keystring);
800 *expand_setup += 1;
801 expand_nstring[*expand_setup] = keystring;
802 expand_nlength[*expand_setup] = 0;
803 }
804 }
805
806/* If this was a potentially partial lookup, and we matched either a
807complete non-wild domain entry, or we matched a wild-carded entry without
808chopping off any of the domain components, set up the expansion variables
809(if required) so that the first one is empty, and the second one is the
810fixed part of the domain. The set_null_wild flag is set only when yield is not
811NULL. */
812
df04890c 813if (set_null_wild && expand_setup && *expand_setup >= 0)
059ec3d9
PH
814 {
815 *expand_setup += 1;
816 expand_nstring[*expand_setup] = keystring;
817 expand_nlength[*expand_setup] = 0;
818 *expand_setup += 1;
819 expand_nstring[*expand_setup] = keystring;
820 expand_nlength[*expand_setup] = Ustrlen(keystring);
821 }
822
823return yield;
824}
825
826/* End of search.c */