Make smtp transport try server cert verify by default
[exim.git] / src / src / search.c
... / ...
CommitLineData
1/*************************************************
2* Exim - an Internet mail transport agent *
3*************************************************/
4
5/* Copyright (c) University of Cambridge 1995 - 2009 */
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
65search_findtype(uschar *name, int len)
66{
67int bot = 0;
68int top = lookup_list_count;
69while (top > bot)
70 {
71 int mid = (top + bot)/2;
72 int c = Ustrncmp(name, lookup_list[mid]->name, len);
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
82 if (c == 0 && Ustrlen(lookup_list[mid]->name) == len)
83 {
84 if (lookup_list[mid]->find != NULL) return mid;
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
124search_findtype_partial(uschar *name, int *ptypeptr, uschar **ptypeaff,
125 int *afflen, int *starflags)
126{
127int len, stype;
128int pv = -1;
129uschar *ss = name;
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
185binary are valid. For query-style types, "partial" and default types are
186erroneous. */
187
188stype = search_findtype(ss, len);
189if (stype >= 0 && mac_islookup(stype, lookup_querystyle))
190 {
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 }
203 }
204
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 &&
238 lookup_list[c->search_type]->close != NULL)
239 lookup_list[c->search_type]->close(c->handle);
240}
241
242
243/* The external entry point
244
245Argument: none
246Returns: nothing
247*/
248
249void
250search_tidyup(void)
251{
252int i;
253int old_pool = store_pool;
254
255DEBUG(D_lookup) debug_printf("search_tidyup called\n");
256
257/* Close individually each cached open file. */
258
259store_pool = POOL_SEARCH;
260if (search_tree != NULL)
261 {
262 tidyup_subtree(search_tree);
263 search_tree = NULL;
264 }
265open_top = open_bot = NULL;
266open_filecount = 0;
267
268/* Call the general tidyup entry for any drivers that have one. */
269
270for (i = 0; i < lookup_list_count; i++)
271 if (lookup_list[i]->tidy != NULL) (lookup_list[i]->tidy)();
272
273if (search_reset_point != NULL) store_reset(search_reset_point);
274search_reset_point = NULL;
275store_pool = old_pool;
276}
277
278
279
280
281/*************************************************
282* Open search database *
283*************************************************/
284
285/* A mode, and lists of owners and groups, are passed over for checking in
286the cases where the database is one or more files. Return NULL, with a message
287pointed to by message, in cases of error.
288
289For search types that use a file or files, check up on the mode after
290opening. It is tempting to do a stat before opening the file, and use it as
291an existence check. However, doing that opens a small security loophole in
292that the status could be changed before the file is opened. Can't quite see
293what problems this might lead to, but you can't be too careful where security
294is concerned. Fstat() on an open file can normally be expected to succeed,
295but there are some NFS states where it does not.
296
297There are two styles of query: (1) in the "single-key+file" style, a single
298key string and a file name are given, for example, for linear searches, DBM
299files, or for NIS. (2) In the "query" style, no "filename" is given; instead
300just a single query string is passed. This applies to multiple-key lookup
301types such as NIS+.
302
303Before opening, scan the tree of cached files to see if this file is already
304open for the correct search type. If so, return the saved handle. If not, put
305the handle in the tree for possible subsequent use. See search_tidyup above for
306closing all the cached files.
307
308A count of open databases which use real files is maintained, and if this
309gets too large, we have to close a cached file. Its entry remains in the tree,
310but is marked closed.
311
312Arguments:
313 filename the name of the file for single-key+file style lookups,
314 NULL for query-style lookups
315 search_type the type of search required
316 modemask if a real single file is used, this specifies mode bits that
317 must not be set; otherwise it is ignored
318 owners if a real single file is used, this specifies the possible
319 owners of the file; otherwise it is ignored
320 owngroups if a real single file is used, this specifies the possible
321 group owners of the file; otherwise it is ignored
322
323Returns: an identifying handle for the open database;
324 this is the pointer to the tree block in the
325 cache of open files; return NULL on open failure, with
326 a message in search_error_message
327*/
328
329void *
330search_open(uschar *filename, int search_type, int modemask, uid_t *owners,
331 gid_t *owngroups)
332{
333void *handle;
334tree_node *t;
335search_cache *c;
336lookup_info *lk = lookup_list[search_type];
337uschar keybuffer[256];
338int old_pool = store_pool;
339
340/* Change to the search store pool and remember our reset point */
341
342store_pool = POOL_SEARCH;
343if (search_reset_point == NULL) search_reset_point = store_get(0);
344
345DEBUG(D_lookup) debug_printf("search_open: %s \"%s\"\n", lk->name,
346 (filename == NULL)? US"NULL" : filename);
347
348/* See if we already have this open for this type of search, and if so,
349pass back the tree block as the handle. The key for the tree node is the search
350type plus '0' concatenated with the file name. There may be entries in the tree
351with closed files if a lot of files have been opened. */
352
353sprintf(CS keybuffer, "%c%.254s", search_type + '0',
354 (filename == NULL)? US"" : filename);
355
356if ((t = tree_search(search_tree, keybuffer)) != NULL)
357 {
358 c = (search_cache *)(t->data.ptr);
359 if (c->handle != NULL)
360 {
361 DEBUG(D_lookup) debug_printf(" cached open\n");
362 store_pool = old_pool;
363 return t;
364 }
365 DEBUG(D_lookup) debug_printf(" cached closed\n");
366 }
367
368/* Otherwise, we need to open the file or database - each search type has its
369own code, which is now split off into separately compiled modules. Before doing
370this, if the search type is one that uses real files, check on the number that
371we are holding open in the cache. If the limit is reached, close the least
372recently used one. */
373
374if (lk->type == lookup_absfile && open_filecount >= lookup_open_max)
375 {
376 if (open_bot == NULL)
377 log_write(0, LOG_MAIN|LOG_PANIC, "too many lookups open, but can't find "
378 "one to close");
379 else
380 {
381 search_cache *c = (search_cache *)(open_bot->data.ptr);
382 DEBUG(D_lookup) debug_printf("Too many lookup files open\n closing %s\n",
383 open_bot->name);
384 open_bot = c->up;
385 if (open_bot != NULL)
386 ((search_cache *)(open_bot->data.ptr))->down = NULL;
387 else
388 open_top = NULL;
389 ((lookup_list[c->search_type])->close)(c->handle);
390 c->handle = NULL;
391 open_filecount--;
392 }
393 }
394
395/* If opening is successful, call the file-checking function if there is one,
396and if all is still well, enter the open database into the tree. */
397
398handle = (lk->open)(filename, &search_error_message);
399if (handle == NULL)
400 {
401 store_pool = old_pool;
402 return NULL;
403 }
404
405if (lk->check != NULL &&
406 !lk->check(handle, filename, modemask, owners, owngroups,
407 &search_error_message))
408 {
409 lk->close(handle);
410 store_pool = old_pool;
411 return NULL;
412 }
413
414/* If this is a search type that uses real files, keep count. */
415
416if (lk->type == lookup_absfile) open_filecount++;
417
418/* If we found a previously opened entry in the tree, re-use it; otherwise
419insert a new entry. On re-use, leave any cached lookup data and the lookup
420count alone. */
421
422if (t == NULL)
423 {
424 t = store_get(sizeof(tree_node) + Ustrlen(keybuffer));
425 t->data.ptr = c = store_get(sizeof(search_cache));
426 c->item_cache = NULL;
427 Ustrcpy(t->name, keybuffer);
428 tree_insertnode(&search_tree, t);
429 }
430else c = t->data.ptr;
431
432c->handle = handle;
433c->search_type = search_type;
434c->up = c->down = NULL;
435
436store_pool = old_pool;
437return t;
438}
439
440
441
442
443
444/*************************************************
445* Internal function: Find one item in database *
446*************************************************/
447
448/* The answer is always put into dynamic store. The last lookup for each handle
449is cached.
450
451Arguments:
452 handle the handle from search_open; points to tree node
453 filename the filename that was handed to search_open, or
454 NULL for query-style searches
455 keystring the keystring for single-key+file lookups, or
456 the querystring for query-style lookups
457
458Returns: a pointer to a dynamic string containing the answer,
459 or NULL if the query failed or was deferred; in the
460 latter case, search_find_defer is set TRUE; after an unusual
461 failure, there may be a message in search_error_message.
462*/
463
464static uschar *
465internal_search_find(void *handle, uschar *filename, uschar *keystring)
466{
467tree_node *t = (tree_node *)handle;
468search_cache *c = (search_cache *)(t->data.ptr);
469uschar *data = NULL;
470int search_type = t->name[0] - '0';
471int old_pool = store_pool;
472
473/* Lookups that return DEFER may not always set an error message. So that
474the callers don't have to test for NULL, set an empty string. */
475
476search_error_message = US"";
477search_find_defer = FALSE;
478
479DEBUG(D_lookup) debug_printf("internal_search_find: file=\"%s\"\n "
480 "type=%s key=\"%s\"\n", filename,
481 lookup_list[search_type]->name, keystring);
482
483/* Insurance. If the keystring is empty, just fail. */
484
485if (keystring[0] == 0) return NULL;
486
487/* Use the special store pool for search data */
488
489store_pool = POOL_SEARCH;
490
491/* Look up the data for the key, unless it is already in the cache for this
492file. No need to check c->item_cache for NULL, tree_search will do so. */
493
494if ((t = tree_search(c->item_cache, keystring)) == NULL)
495 {
496 BOOL do_cache = TRUE;
497 int keylength = Ustrlen(keystring);
498
499 DEBUG(D_lookup)
500 {
501 if (filename != NULL)
502 debug_printf("file lookup required for %s\n in %s\n",
503 keystring, filename);
504 else
505 debug_printf("database lookup required for %s\n", keystring);
506 }
507
508 /* Call the code for the different kinds of search. DEFER is handled
509 like FAIL, except that search_find_defer is set so the caller can
510 distinguish if necessary. */
511
512 if (lookup_list[search_type]->find(c->handle, filename, keystring, keylength,
513 &data, &search_error_message, &do_cache) == DEFER)
514 {
515 search_find_defer = TRUE;
516 }
517
518 /* A record that has been found is now in data, which is either NULL
519 or points to a bit of dynamic store. Cache the result of the lookup if
520 caching is permitted. Lookups can disable caching, when they did something
521 that changes their data. The mysql and pgsql lookups do this when an
522 UPDATE/INSERT query was executed. */
523
524 else if (do_cache)
525 {
526 int len = keylength + 1;
527 t = store_get(sizeof(tree_node) + len);
528 memcpy(t->name, keystring, len);
529 t->data.ptr = data;
530 tree_insertnode(&c->item_cache, t);
531 }
532
533 /* If caching was disabled, empty the cache tree. We just set the cache
534 pointer to NULL here, because we cannot release the store at this stage. */
535
536 else
537 {
538 DEBUG(D_lookup) debug_printf("lookup forced cache cleanup\n");
539 c->item_cache = NULL;
540 }
541 }
542
543/* Data was in the cache already; set the pointer from the tree node */
544
545else
546 {
547 data = US t->data.ptr;
548 DEBUG(D_lookup) debug_printf("cached data used for lookup of %s%s%s\n",
549 keystring,
550 (filename == NULL)? US"" : US"\n in ",
551 (filename == NULL)? US"" : filename);
552 }
553
554/* Debug: output the answer */
555
556DEBUG(D_lookup)
557 {
558 if (data == NULL)
559 {
560 if (search_find_defer) debug_printf("lookup deferred: %s\n",
561 search_error_message);
562 else debug_printf("lookup failed\n");
563 }
564 else debug_printf("lookup yielded: %s\n", data);
565 }
566
567/* Return it in new dynamic store in the regular pool */
568
569store_pool = old_pool;
570return (data == NULL)? NULL : string_copy(data);
571}
572
573
574
575
576/*************************************************
577* Find one item in database, possibly wildcarded *
578*************************************************/
579
580/* This function calls the internal function above; once only if there
581is no partial matching, but repeatedly when partial matching is requested.
582
583Arguments:
584 handle the handle from search_open
585 filename the filename that was handed to search_open, or
586 NULL for query-style searches
587 keystring the keystring for single-key+file lookups, or
588 the querystring for query-style lookups
589 partial -1 means no partial matching;
590 otherwise it's the minimum number of components;
591 affix the affix string for partial matching
592 affixlen the length of the affix string
593 starflags SEARCH_STAR and SEARCH_STARAT flags
594 expand_setup pointer to offset for setting up expansion strings;
595 don't do any if < 0
596
597Returns: a pointer to a dynamic string containing the answer,
598 or NULL if the query failed or was deferred; in the
599 latter case, search_find_defer is set TRUE
600*/
601
602uschar *
603search_find(void *handle, uschar *filename, uschar *keystring, int partial,
604 uschar *affix, int affixlen, int starflags, int *expand_setup)
605{
606tree_node *t = (tree_node *)handle;
607BOOL set_null_wild = FALSE;
608uschar *yield;
609
610DEBUG(D_lookup)
611 {
612 if (partial < 0) affixlen = 99; /* So that "NULL" prints */
613 debug_printf("search_find: file=\"%s\"\n key=\"%s\" "
614 "partial=%d affix=%.*s starflags=%x\n",
615 (filename == NULL)? US"NULL" : filename,
616 keystring, partial, affixlen, affix, starflags);
617 }
618
619/* Arrange to put this database at the top of the LRU chain if it is a type
620that opens real files. */
621
622if (open_top != (tree_node *)handle &&
623 lookup_list[t->name[0]-'0']->type == lookup_absfile)
624 {
625 search_cache *c = (search_cache *)(t->data.ptr);
626 tree_node *up = c->up;
627 tree_node *down = c->down;
628
629 /* Cut it out of the list. A newly opened file will a NULL up pointer.
630 Otherwise there will be a non-NULL up pointer, since we checked above that
631 this block isn't already at the top of the list. */
632
633 if (up != NULL)
634 {
635 ((search_cache *)(up->data.ptr))->down = down;
636 if (down != NULL)
637 ((search_cache *)(down->data.ptr))->up = up;
638 else open_bot = up;
639 }
640
641 /* Now put it at the head of the list. */
642
643 c->up = NULL;
644 c->down = open_top;
645 if (open_top == NULL) open_bot = t; else
646 ((search_cache *)(open_top->data.ptr))->up = t;
647 open_top = t;
648 }
649
650DEBUG(D_lookup)
651 {
652 tree_node *t = open_top;
653 debug_printf("LRU list:\n");
654 while (t != NULL)
655 {
656 search_cache *c = (search_cache *)(t->data.ptr);
657 debug_printf(" %s\n", t->name);
658 if (t == open_bot) debug_printf(" End\n");
659 t = c->down;
660 }
661 }
662
663/* First of all, try to match the key string verbatim. If matched a complete
664entry but could have been partial, flag to set up variables. */
665
666yield = internal_search_find(handle, filename, keystring);
667if (search_find_defer) return NULL;
668if (yield != NULL) { if (partial >= 0) set_null_wild = TRUE; }
669
670/* Not matched a complete entry; handle partial lookups, but only if the full
671search didn't defer. Don't use string_sprintf() to construct the initial key,
672just in case the original key is too long for the string_sprintf() buffer (it
673*has* happened!). The case of a zero-length affix has to be treated specially.
674*/
675
676else if (partial >= 0)
677 {
678 int len = Ustrlen(keystring);
679 uschar *keystring2;
680
681 /* Try with the affix on the front, except for a zero-length affix */
682
683 if (affixlen == 0) keystring2 = keystring; else
684 {
685 keystring2 = store_get(len + affixlen + 1);
686 Ustrncpy(keystring2, affix, affixlen);
687 Ustrcpy(keystring2 + affixlen, keystring);
688 DEBUG(D_lookup) debug_printf("trying partial match %s\n", keystring2);
689 yield = internal_search_find(handle, filename, keystring2);
690 if (search_find_defer) return NULL;
691 }
692
693 /* The key in its entirety did not match a wild entry; try chopping off
694 leading components. */
695
696 if (yield == NULL)
697 {
698 int dotcount = 0;
699 uschar *keystring3 = keystring2 + affixlen;
700 uschar *s = keystring3;
701 while (*s != 0) if (*s++ == '.') dotcount++;
702
703 while (dotcount-- >= partial)
704 {
705 while (*keystring3 != 0 && *keystring3 != '.') keystring3++;
706
707 /* If we get right to the end of the string (which will be the last time
708 through this loop), we've failed if the affix is null. Otherwise do one
709 last lookup for the affix itself, but if it is longer than 1 character,
710 remove the last character if it is ".". */
711
712 if (*keystring3 == 0)
713 {
714 if (affixlen < 1) break;
715 if (affixlen > 1 && affix[affixlen-1] == '.') affixlen--;
716 Ustrncpy(keystring2, affix, affixlen);
717 keystring2[affixlen] = 0;
718 keystring3 = keystring2;
719 }
720 else
721 {
722 keystring3 -= affixlen - 1;
723 if (affixlen > 0) Ustrncpy(keystring3, affix, affixlen);
724 }
725
726 DEBUG(D_lookup) debug_printf("trying partial match %s\n", keystring3);
727 yield = internal_search_find(handle, filename, keystring3);
728 if (search_find_defer) return NULL;
729 if (yield != NULL)
730 {
731 /* First variable is the wild part; second is the fixed part. Take care
732 to get it right when keystring3 is just "*". */
733
734 if (expand_setup != NULL && *expand_setup >= 0)
735 {
736 int fixedlength = Ustrlen(keystring3) - affixlen;
737 int wildlength = Ustrlen(keystring) - fixedlength - 1;
738 *expand_setup += 1;
739 expand_nstring[*expand_setup] = keystring;
740 expand_nlength[*expand_setup] = wildlength;
741 *expand_setup += 1;
742 expand_nstring[*expand_setup] = keystring + wildlength + 1;
743 expand_nlength[*expand_setup] = (fixedlength < 0)? 0 : fixedlength;
744 }
745 break;
746 }
747 keystring3 += affixlen;
748 }
749 }
750
751 else set_null_wild = TRUE; /* Matched a wild entry without any wild part */
752 }
753
754/* If nothing has been matched, but the option to look for "*@" is set, try
755replacing everthing to the left of @ by *. After a match, the wild part
756is set to the string to the left of the @. */
757
758if (yield == NULL && (starflags & SEARCH_STARAT) != 0)
759 {
760 uschar *atat = Ustrrchr(keystring, '@');
761 if (atat != NULL && atat > keystring)
762 {
763 int savechar;
764 savechar = *(--atat);
765 *atat = '*';
766
767 DEBUG(D_lookup) debug_printf("trying default match %s\n", atat);
768 yield = internal_search_find(handle, filename, atat);
769 *atat = savechar;
770 if (search_find_defer) return NULL;
771
772 if (yield != NULL && expand_setup != NULL && *expand_setup >= 0)
773 {
774 *expand_setup += 1;
775 expand_nstring[*expand_setup] = keystring;
776 expand_nlength[*expand_setup] = atat - keystring + 1;
777 *expand_setup += 1;
778 expand_nstring[*expand_setup] = keystring;
779 expand_nlength[*expand_setup] = 0;
780 }
781 }
782 }
783
784/* If we still haven't matched anything, and the option to look for "*" is set,
785try that. If we do match, the first variable (the wild part) is the whole key,
786and the second is empty. */
787
788if (yield == NULL && (starflags & (SEARCH_STAR|SEARCH_STARAT)) != 0)
789 {
790 DEBUG(D_lookup) debug_printf("trying to match *\n");
791 yield = internal_search_find(handle, filename, US"*");
792 if (yield != NULL && expand_setup != NULL && *expand_setup >= 0)
793 {
794 *expand_setup += 1;
795 expand_nstring[*expand_setup] = keystring;
796 expand_nlength[*expand_setup] = Ustrlen(keystring);
797 *expand_setup += 1;
798 expand_nstring[*expand_setup] = keystring;
799 expand_nlength[*expand_setup] = 0;
800 }
801 }
802
803/* If this was a potentially partial lookup, and we matched either a
804complete non-wild domain entry, or we matched a wild-carded entry without
805chopping off any of the domain components, set up the expansion variables
806(if required) so that the first one is empty, and the second one is the
807fixed part of the domain. The set_null_wild flag is set only when yield is not
808NULL. */
809
810if (set_null_wild && expand_setup != NULL && *expand_setup >= 0)
811 {
812 *expand_setup += 1;
813 expand_nstring[*expand_setup] = keystring;
814 expand_nlength[*expand_setup] = 0;
815 *expand_setup += 1;
816 expand_nstring[*expand_setup] = keystring;
817 expand_nlength[*expand_setup] = Ustrlen(keystring);
818 }
819
820return yield;
821}
822
823/* End of search.c */