tidying
[exim.git] / src / src / lookups / dnsdb.c
CommitLineData
0756eb3c
PH
1/*************************************************
2* Exim - an Internet mail transport agent *
3*************************************************/
4
f9ba5e22 5/* Copyright (c) University of Cambridge 1995 - 2018 */
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
12
13/* Ancient systems (e.g. SunOS4) don't appear to have T_TXT defined in their
14header files. */
15
16#ifndef T_TXT
acec9514 17# define T_TXT 16
0756eb3c
PH
18#endif
19
eae0036b
PP
20/* Many systems do not have T_SPF. */
21#ifndef T_SPF
acec9514 22# define T_SPF 99
eae0036b
PP
23#endif
24
1e06383a
TL
25/* New TLSA record for DANE */
26#ifndef T_TLSA
acec9514 27# define T_TLSA 52
1e06383a
TL
28#endif
29
0756eb3c
PH
30/* Table of recognized DNS record types and their integer values. */
31
1ba28e2b 32static const char *type_names[] = {
0756eb3c
PH
33 "a",
34#if HAVE_IPV6
3a796370 35 "a+",
0756eb3c 36 "aaaa",
0756eb3c
PH
37#endif
38 "cname",
e5a9dba6 39 "csa",
0756eb3c 40 "mx",
ea3bc19b 41 "mxh",
0756eb3c
PH
42 "ns",
43 "ptr",
d2a2c69b 44 "soa",
eae0036b 45 "spf",
0756eb3c 46 "srv",
1e06383a 47 "tlsa",
33397d19 48 "txt",
8e669ac1 49 "zns"
33397d19 50};
0756eb3c
PH
51
52static int type_values[] = {
53 T_A,
54#if HAVE_IPV6
66be95e0 55 T_ADDRESSES, /* Private type for AAAA + A */
0756eb3c 56 T_AAAA,
0756eb3c
PH
57#endif
58 T_CNAME,
e5a9dba6 59 T_CSA, /* Private type for "Client SMTP Authorization". */
0756eb3c 60 T_MX,
ea3bc19b 61 T_MXH, /* Private type for "MX hostnames" */
0756eb3c
PH
62 T_NS,
63 T_PTR,
d2a2c69b 64 T_SOA,
eae0036b 65 T_SPF,
0756eb3c 66 T_SRV,
1e06383a 67 T_TLSA,
33397d19
PH
68 T_TXT,
69 T_ZNS /* Private type for "zone nameservers" */
70};
0756eb3c
PH
71
72
73/*************************************************
74* Open entry point *
75*************************************************/
76
77/* See local README for interface description. */
78
e6d225ae 79static void *
0756eb3c
PH
80dnsdb_open(uschar *filename, uschar **errmsg)
81{
82filename = filename; /* Keep picky compilers happy */
83errmsg = errmsg; /* Ditto */
84return (void *)(-1); /* Any non-0 value */
85}
86
87
88
89/*************************************************
90* Find entry point for dnsdb *
91*************************************************/
92
7bb56e1f
PH
93/* See local README for interface description. The query in the "keystring" may
94consist of a number of parts.
95
8e669ac1
PH
96(a) If the first significant character is '>' then the next character is the
97separator character that is used when multiple records are found. The default
7bb56e1f
PH
98separator is newline.
99
0d0c6357
NM
100(b) If the next character is ',' then the next character is the separator
101character used for multiple items of text in "TXT" records. Alternatively,
102if the next character is ';' then these multiple items are concatenated with
103no separator. With neither of these options specified, only the first item
8ee4b30e
PP
104is output. Similarly for "SPF" records, but the default for joining multiple
105items in one SPF record is the empty string, for direct concatenation.
0d0c6357 106
fd7f7910
JH
107(c) Options, all comma-terminated, in any order. Any unrecognised option
108terminates option processing. Recognised options are:
109
110- 'defer_FOO': set the defer behaviour to FOO. The possible behaviours are:
111'strict', where any defer causes the whole lookup to defer; 'lax', where a defer
112causes the whole lookup to defer only if none of the DNS queries succeeds; and
113'never', where all defers are as if the lookup failed. The default is 'lax'.
114
115- 'dnssec_FOO', with 'strict', 'lax' and 'never' (default). The meanings are
fd3b6a4a
JH
116require, try and don't-try dnssec respectively.
117
fd7f7910
JH
118- 'retrans_VAL', set the timeout value. VAL is an Exim time specification
119(eg "5s"). The default is set by the main configuration option 'dns_retrans'.
120
121- 'retry_VAL', set the retry count on timeouts. VAL is an integer. The
122default is set by the main configuration option "dns_retry".
123
124(d) If the next sequence of characters is a sequence of letters and digits
8e669ac1 125followed by '=', it is interpreted as the name of the DNS record type. The
ff4dbb19 126default is "TXT".
7bb56e1f 127
fd7f7910 128(e) Then there follows list of domain names. This is a generalized Exim list,
8e669ac1 129which may start with '<' in order to set a specific separator. The default
7bb56e1f 130separator, as always, is colon. */
0756eb3c 131
e6d225ae 132static int
55414b25 133dnsdb_find(void *handle, uschar *filename, const uschar *keystring, int length,
14b3c5bc 134 uschar **result, uschar **errmsg, uint *do_cache)
0756eb3c
PH
135{
136int rc;
7bb56e1f 137int sep = 0;
ff4dbb19 138int defer_mode = PASS;
fd3b6a4a 139int dnssec_mode = OK;
fd7f7910
JH
140int save_retrans = dns_retrans;
141int save_retry = dns_retry;
542bc632 142int type;
c38d6da9 143int failrc = FAIL;
55414b25
JH
144const uschar *outsep = CUS"\n";
145const uschar *outsep2 = NULL;
e5a9dba6 146uschar *equals, *domain, *found;
0756eb3c 147
8743d3ac
JH
148dns_answer * dnsa = store_get_dns_answer();
149dns_scan dnss;
150
acec9514 151/* Because we're working in the search pool, we try to reclaim as much
0756eb3c
PH
152store as possible later, so we preallocate the result here */
153
acec9514 154gstring * yield = string_get(256);
0756eb3c 155
0756eb3c
PH
156handle = handle; /* Keep picky compilers happy */
157filename = filename;
158length = length;
159do_cache = do_cache;
160
0d0c6357
NM
161/* If the string starts with '>' we change the output separator.
162If it's followed by ';' or ',' we set the TXT output separator. */
0756eb3c 163
7bb56e1f
PH
164while (isspace(*keystring)) keystring++;
165if (*keystring == '>')
0756eb3c 166 {
7bb56e1f 167 outsep = keystring + 1;
8e669ac1 168 keystring += 2;
0d0c6357
NM
169 if (*keystring == ',')
170 {
171 outsep2 = keystring + 1;
172 keystring += 2;
173 }
174 else if (*keystring == ';')
175 {
176 outsep2 = US"";
177 keystring++;
178 }
7bb56e1f 179 while (isspace(*keystring)) keystring++;
8e669ac1 180 }
7bb56e1f 181
fd3b6a4a 182/* Check for a modifier keyword. */
ff4dbb19 183
fd7f7910 184for (;;)
ff4dbb19 185 {
fd3b6a4a 186 if (strncmpic(keystring, US"defer_", 6) == 0)
ff4dbb19 187 {
ff4dbb19 188 keystring += 6;
fd3b6a4a 189 if (strncmpic(keystring, US"strict", 6) == 0)
fd7f7910 190 { defer_mode = DEFER; keystring += 6; }
fd3b6a4a 191 else if (strncmpic(keystring, US"lax", 3) == 0)
fd7f7910 192 { defer_mode = PASS; keystring += 3; }
fd3b6a4a 193 else if (strncmpic(keystring, US"never", 5) == 0)
fd7f7910 194 { defer_mode = OK; keystring += 5; }
fd3b6a4a
JH
195 else
196 {
197 *errmsg = US"unsupported dnsdb defer behaviour";
198 return DEFER;
199 }
ff4dbb19 200 }
fd7f7910 201 else if (strncmpic(keystring, US"dnssec_", 7) == 0)
ff4dbb19 202 {
fd3b6a4a
JH
203 keystring += 7;
204 if (strncmpic(keystring, US"strict", 6) == 0)
fd7f7910 205 { dnssec_mode = DEFER; keystring += 6; }
fd3b6a4a 206 else if (strncmpic(keystring, US"lax", 3) == 0)
fd7f7910
JH
207 { dnssec_mode = PASS; keystring += 3; }
208 else if (strncmpic(keystring, US"never", 5) == 0)
209 { dnssec_mode = OK; keystring += 5; }
210 else
fd3b6a4a 211 {
fd7f7910
JH
212 *errmsg = US"unsupported dnsdb dnssec behaviour";
213 return DEFER;
fd3b6a4a 214 }
fd7f7910
JH
215 }
216 else if (strncmpic(keystring, US"retrans_", 8) == 0)
217 {
218 int timeout_sec;
219 if ((timeout_sec = readconf_readtime(keystring += 8, ',', FALSE)) <= 0)
fd3b6a4a 220 {
fd7f7910
JH
221 *errmsg = US"unsupported dnsdb timeout value";
222 return DEFER;
fd3b6a4a 223 }
fd7f7910
JH
224 dns_retrans = timeout_sec;
225 while (*keystring != ',') keystring++;
226 }
227 else if (strncmpic(keystring, US"retry_", 6) == 0)
228 {
229 int retries;
fc362fc5 230 if ((retries = (int)strtol(CCS keystring + 6, CSS &keystring, 0)) < 0)
fd3b6a4a 231 {
fd7f7910 232 *errmsg = US"unsupported dnsdb retry count";
fd3b6a4a
JH
233 return DEFER;
234 }
fd7f7910 235 dns_retry = retries;
ff4dbb19 236 }
fd7f7910
JH
237 else
238 break;
239
ff4dbb19
PH
240 while (isspace(*keystring)) keystring++;
241 if (*keystring++ != ',')
242 {
fd3b6a4a 243 *errmsg = US"dnsdb modifier syntax error";
ff4dbb19
PH
244 return DEFER;
245 }
246 while (isspace(*keystring)) keystring++;
247 }
248
542bc632
PP
249/* Figure out the "type" value if it is not T_TXT.
250If the keystring contains an = this must be preceded by a valid type name. */
7bb56e1f 251
542bc632 252type = T_TXT;
7bb56e1f
PH
253if ((equals = Ustrchr(keystring, '=')) != NULL)
254 {
255 int i, len;
256 uschar *tend = equals;
8e669ac1
PH
257
258 while (tend > keystring && isspace(tend[-1])) tend--;
259 len = tend - keystring;
260
9be4572b 261 for (i = 0; i < nelem(type_names); i++)
0756eb3c
PH
262 if (len == Ustrlen(type_names[i]) &&
263 strncmpic(keystring, US type_names[i], len) == 0)
264 {
265 type = type_values[i];
266 break;
267 }
8e669ac1 268
9be4572b 269 if (i >= nelem(type_names))
0756eb3c
PH
270 {
271 *errmsg = US"unsupported DNS record type";
272 return DEFER;
273 }
8e669ac1 274
7bb56e1f
PH
275 keystring = equals + 1;
276 while (isspace(*keystring)) keystring++;
0756eb3c 277 }
8e669ac1 278
7bb56e1f 279/* Initialize the resolver in case this is the first time it has been used. */
0756eb3c 280
fd3b6a4a 281dns_init(FALSE, FALSE, dnssec_mode != OK);
0756eb3c 282
8e669ac1
PH
283/* The remainder of the string must be a list of domains. As long as the lookup
284for at least one of them succeeds, we return success. Failure means that none
285of them were found.
0756eb3c 286
8e669ac1
PH
287The original implementation did not support a list of domains. Adding the list
288feature is compatible, except in one case: when PTR records are being looked up
289for a single IPv6 address. Fortunately, we can hack in a compatibility feature
290here: If the type is PTR and no list separator is specified, and the entire
291remaining string is valid as an IP address, set an impossible separator so that
7bb56e1f 292it is treated as one item. */
33397d19 293
7bb56e1f 294if (type == T_PTR && keystring[0] != '<' &&
7e66e54d 295 string_is_ip_address(keystring, NULL) != 0)
7bb56e1f 296 sep = -1;
0756eb3c 297
542bc632
PP
298/* SPF strings should be concatenated without a separator, thus make
299it the default if not defined (see RFC 4408 section 3.1.3).
300Multiple SPF records are forbidden (section 3.1.2) but are currently
be36e572
JH
301not handled specially, thus they are concatenated with \n by default.
302MX priority and value are space-separated by default.
303SRV and TLSA record parts are space-separated by default. */
542bc632 304
be36e572
JH
305if (!outsep2) switch(type)
306 {
307 case T_SPF: outsep2 = US""; break;
308 case T_SRV: case T_MX: case T_TLSA: outsep2 = US" "; break;
309 }
542bc632 310
7bb56e1f 311/* Now scan the list and do a lookup for each item */
0756eb3c 312
fd7f7910 313while ((domain = string_nextinlist(&keystring, &sep, NULL, 0)))
8e669ac1 314 {
7bb56e1f 315 uschar rbuffer[256];
b09c1793
JH
316 int searchtype = type == T_CSA ? T_SRV : /* record type we want */
317 type == T_MXH ? T_MX :
318 type == T_ZNS ? T_NS : type;
e5a9dba6
PH
319
320 /* If the type is PTR or CSA, we have to construct the relevant magic lookup
321 key if the original is an IP address (some experimental protocols are using
322 PTR records for different purposes where the key string is a host name, and
323 Exim's extended CSA can be keyed by domains or IP addresses). This code for
324 doing the reversal is now in a separate function. */
325
326 if ((type == T_PTR || type == T_CSA) &&
7e66e54d 327 string_is_ip_address(domain, NULL) != 0)
0756eb3c 328 {
7bb56e1f
PH
329 dns_build_reverse(domain, rbuffer);
330 domain = rbuffer;
0756eb3c 331 }
8e669ac1 332
3a796370 333 do
c38d6da9 334 {
42c7f0b4 335 DEBUG(D_lookup) debug_printf_indent("dnsdb key: %s\n", domain);
3a796370
JH
336
337 /* Do the lookup and sort out the result. There are four special types that
66be95e0 338 are handled specially: T_CSA, T_ZNS, T_ADDRESSES and T_MXH.
3a796370 339 The first two are handled in a special lookup function so that the facility
66be95e0 340 could be used from other parts of the Exim code. T_ADDRESSES is handled by looping
3a796370
JH
341 over the types of A lookup. T_MXH affects only what happens later on in
342 this function, but for tidiness it is handled by the "special". If the
343 lookup fails, continue with the next domain. In the case of DEFER, adjust
344 the final "nothing found" result, but carry on to the next domain. */
345
346 found = domain;
6abc190a 347#if HAVE_IPV6
66be95e0 348 if (type == T_ADDRESSES) /* NB cannot happen unless HAVE_IPV6 */
3a796370 349 {
cc00f4af 350 if (searchtype == T_ADDRESSES) searchtype = T_AAAA;
3a796370 351 else if (searchtype == T_AAAA) searchtype = T_A;
8743d3ac 352 rc = dns_special_lookup(dnsa, domain, searchtype, CUSS &found);
3a796370
JH
353 }
354 else
6abc190a 355#endif
8743d3ac 356 rc = dns_special_lookup(dnsa, domain, type, CUSS &found);
ea3bc19b 357
4e0983dc 358 lookup_dnssec_authenticated = dnssec_mode==OK ? NULL
8743d3ac 359 : dns_is_secure(dnsa) ? US"yes" : US"no";
4e0983dc 360
3a796370 361 if (rc == DNS_NOMATCH || rc == DNS_NODATA) continue;
91f40ccd 362 if ( rc != DNS_SUCCEED
8743d3ac 363 || (dnssec_mode == DEFER && !dns_is_secure(dnsa))
91f40ccd 364 )
3a796370 365 {
fd3b6a4a
JH
366 if (defer_mode == DEFER)
367 {
fd7f7910
JH
368 dns_retrans = save_retrans;
369 dns_retry = save_retry;
9d9c3746 370 dns_init(FALSE, FALSE, FALSE); /* clr dnssec bit */
fd3b6a4a
JH
371 return DEFER; /* always defer */
372 }
3a796370
JH
373 if (defer_mode == PASS) failrc = DEFER; /* defer only if all do */
374 continue; /* treat defer as fail */
375 }
fd3b6a4a 376
8e669ac1 377
3a796370 378 /* Search the returned records */
8e669ac1 379
8743d3ac
JH
380 for (dns_record * rr = dns_next_rr(dnsa, &dnss, RESET_ANSWERS); rr;
381 rr = dns_next_rr(dnsa, &dnss, RESET_NEXT)) if (rr->type == searchtype)
0756eb3c 382 {
14b3c5bc
JH
383 if (*do_cache > rr->ttl)
384 *do_cache = rr->ttl;
385
cc00f4af 386 if (type == T_A || type == T_AAAA || type == T_ADDRESSES)
7bb56e1f 387 {
8743d3ac 388 for (dns_address * da = dns_address_from_rr(dnsa, rr); da; da = da->next)
3a796370 389 {
acec9514
JH
390 if (yield->ptr) yield = string_catn(yield, outsep, 1);
391 yield = string_cat(yield, da->address);
3a796370
JH
392 }
393 continue;
7bb56e1f 394 }
8e669ac1 395
3a796370
JH
396 /* Other kinds of record just have one piece of data each, but there may be
397 several of them, of course. */
8e669ac1 398
acec9514 399 if (yield->ptr) yield = string_catn(yield, outsep, 1);
8e669ac1 400
3a796370 401 if (type == T_TXT || type == T_SPF)
80a47a2c 402 {
acec9514
JH
403 if (outsep2 == NULL) /* output only the first item of data */
404 yield = string_catn(yield, US (rr->data+1), (rr->data)[0]);
3a796370
JH
405 else
406 {
407 /* output all items */
408 int data_offset = 0;
409 while (data_offset < rr->size)
410 {
411 uschar chunk_len = (rr->data)[data_offset++];
412 if (outsep2[0] != '\0' && data_offset != 1)
acec9514
JH
413 yield = string_catn(yield, outsep2, 1);
414 yield = string_catn(yield, US ((rr->data)+data_offset), chunk_len);
3a796370
JH
415 data_offset += chunk_len;
416 }
0d0c6357 417 }
80a47a2c 418 }
1e06383a
TL
419 else if (type == T_TLSA)
420 {
421 uint8_t usage, selector, matching_type;
624f33df 422 uint16_t payload_length;
1e06383a
TL
423 uschar s[MAX_TLSA_EXPANDED_SIZE];
424 uschar * sp = s;
d2a2c69b 425 uschar * p = US rr->data;
1e06383a
TL
426
427 usage = *p++;
428 selector = *p++;
429 matching_type = *p++;
430 /* What's left after removing the first 3 bytes above */
431 payload_length = rr->size - 3;
be36e572
JH
432 sp += sprintf(CS s, "%d%c%d%c%d%c", usage, *outsep2,
433 selector, *outsep2, matching_type, *outsep2);
1e06383a 434 /* Now append the cert/identifier, one hex char at a time */
624f33df
JH
435 while (payload_length-- > 0 && sp-s < (MAX_TLSA_EXPANDED_SIZE - 4))
436 sp += sprintf(CS sp, "%02x", *p++);
d2a2c69b 437
acec9514 438 yield = string_cat(yield, s);
1e06383a 439 }
d2a2c69b 440 else /* T_CNAME, T_CSA, T_MX, T_MXH, T_NS, T_PTR, T_SOA, T_SRV */
e5a9dba6 441 {
3a796370
JH
442 int priority, weight, port;
443 uschar s[264];
d2a2c69b
JH
444 uschar * p = US rr->data;
445
446 switch (type)
447 {
448 case T_MXH:
449 /* mxh ignores the priority number and includes only the hostnames */
450 GETSHORT(priority, p);
451 break;
452
453 case T_MX:
454 GETSHORT(priority, p);
455 sprintf(CS s, "%d%c", priority, *outsep2);
acec9514 456 yield = string_cat(yield, s);
d2a2c69b
JH
457 break;
458
459 case T_SRV:
460 GETSHORT(priority, p);
461 GETSHORT(weight, p);
462 GETSHORT(port, p);
463 sprintf(CS s, "%d%c%d%c%d%c", priority, *outsep2,
464 weight, *outsep2, port, *outsep2);
acec9514 465 yield = string_cat(yield, s);
d2a2c69b
JH
466 break;
467
468 case T_CSA:
469 /* See acl_verify_csa() for more comments about CSA. */
470 GETSHORT(priority, p);
471 GETSHORT(weight, p);
472 GETSHORT(port, p);
473
474 if (priority != 1) continue; /* CSA version must be 1 */
475
476 /* If the CSA record we found is not the one we asked for, analyse
477 the subdomain assertions in the port field, else analyse the direct
478 authorization status in the weight field. */
479
480 if (Ustrcmp(found, domain) != 0)
481 {
482 if (port & 1) *s = 'X'; /* explicit authorization required */
483 else *s = '?'; /* no subdomain assertions here */
484 }
485 else
486 {
487 if (weight < 2) *s = 'N'; /* not authorized */
488 else if (weight == 2) *s = 'Y'; /* authorized */
489 else if (weight == 3) *s = '?'; /* unauthorizable */
490 else continue; /* invalid */
491 }
492
493 s[1] = ' ';
acec9514 494 yield = string_catn(yield, s, 2);
d2a2c69b
JH
495 break;
496
497 default:
498 break;
499 }
e5a9dba6 500
3a796370 501 /* GETSHORT() has advanced the pointer to the target domain. */
8e669ac1 502
8743d3ac 503 rc = dn_expand(dnsa->answer, dnsa->answer + dnsa->answerlen, p,
d2a2c69b 504 (DN_EXPAND_ARG4_TYPE)s, sizeof(s));
8e669ac1 505
3a796370
JH
506 /* If an overlong response was received, the data will have been
507 truncated and dn_expand may fail. */
8e669ac1 508
3a796370
JH
509 if (rc < 0)
510 {
511 log_write(0, LOG_MAIN, "host name alias list truncated: type=%s "
512 "domain=%s", dns_text_type(type), domain);
513 break;
514 }
acec9514 515 else yield = string_cat(yield, s);
d2a2c69b
JH
516
517 if (type == T_SOA && outsep2 != NULL)
518 {
519 unsigned long serial, refresh, retry, expire, minimum;
520
521 p += rc;
acec9514 522 yield = string_catn(yield, outsep2, 1);
d2a2c69b 523
8743d3ac 524 rc = dn_expand(dnsa->answer, dnsa->answer + dnsa->answerlen, p,
d2a2c69b
JH
525 (DN_EXPAND_ARG4_TYPE)s, sizeof(s));
526 if (rc < 0)
527 {
528 log_write(0, LOG_MAIN, "responsible-mailbox truncated: type=%s "
529 "domain=%s", dns_text_type(type), domain);
530 break;
531 }
acec9514 532 else yield = string_cat(yield, s);
d2a2c69b
JH
533
534 p += rc;
535 GETLONG(serial, p); GETLONG(refresh, p);
536 GETLONG(retry, p); GETLONG(expire, p); GETLONG(minimum, p);
fc362fc5 537 sprintf(CS s, "%c%lu%c%lu%c%lu%c%lu%c%lu",
d2a2c69b
JH
538 *outsep2, serial, *outsep2, refresh,
539 *outsep2, retry, *outsep2, expire, *outsep2, minimum);
acec9514 540 yield = string_cat(yield, s);
d2a2c69b 541 }
7bb56e1f 542 }
3a796370
JH
543 } /* Loop for list of returned records */
544
4c04137d 545 /* Loop for set of A-lookup types */
66be95e0 546 } while (type == T_ADDRESSES && searchtype != T_A);
3a796370
JH
547
548 } /* Loop for list of domains */
7bb56e1f
PH
549
550/* Reclaim unused memory */
0756eb3c 551
f3ebb786 552gstring_release_unused(yield);
7bb56e1f 553
acec9514 554/* If yield NULL we have not found anything. Otherwise, insert the terminating
7bb56e1f
PH
555zero and return the result. */
556
fd7f7910
JH
557dns_retrans = save_retrans;
558dns_retry = save_retry;
fd3b6a4a
JH
559dns_init(FALSE, FALSE, FALSE); /* clear the dnssec bit for getaddrbyname */
560
acec9514
JH
561if (!yield || !yield->ptr) return failrc;
562
563*result = string_from_gstring(yield);
0756eb3c
PH
564return OK;
565}
566
6545de78
PP
567
568
569/*************************************************
570* Version reporting entry point *
571*************************************************/
572
573/* See local README for interface description. */
574
575#include "../version.h"
576
577void
578dnsdb_version_report(FILE *f)
579{
580#ifdef DYNLOOKUP
581fprintf(f, "Library version: DNSDB: Exim version %s\n", EXIM_VERSION_STR);
582#endif
583}
584
585
e6d225ae
DW
586static lookup_info _lookup_info = {
587 US"dnsdb", /* lookup name */
588 lookup_querystyle, /* query style */
589 dnsdb_open, /* open function */
590 NULL, /* check function */
591 dnsdb_find, /* find function */
592 NULL, /* no close function */
593 NULL, /* no tidy function */
6545de78
PP
594 NULL, /* no quoting function */
595 dnsdb_version_report /* version reporting */
e6d225ae
DW
596};
597
598#ifdef DYNLOOKUP
599#define dnsdb_lookup_module_info _lookup_module_info
600#endif
601
602static lookup_info *_lookup_list[] = { &_lookup_info };
603lookup_module_info dnsdb_lookup_module_info = { LOOKUP_MODULE_INFO_MAGIC, _lookup_list, 1 };
604
fd3b6a4a
JH
605/* vi: aw ai sw=2
606*/
0756eb3c 607/* End of lookups/dnsdb.c */