Revert accidental bogus checkin, sorry
[exim.git] / src / src / lookups / dnsdb.c
1 /* $Cambridge: exim/src/src/lookups/dnsdb.c,v 1.13 2005/06/10 13:38:06 tom 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 "dnsdb.h"
13
14
15
16 /* Ancient systems (e.g. SunOS4) don't appear to have T_TXT defined in their
17 header files. */
18
19 #ifndef T_TXT
20 #define T_TXT 16
21 #endif
22
23 /* Table of recognized DNS record types and their integer values. */
24
25 static char *type_names[] = {
26   "a",
27 #if HAVE_IPV6
28   "aaaa",
29   #ifdef SUPPORT_A6
30   "a6",
31   #endif
32 #endif
33   "cname",
34   "csa",
35   "mx",
36   "mxh",
37   "ns",
38   "ptr",
39   "srv",
40   "txt",
41   "zns"
42 };
43
44 static int type_values[] = {
45   T_A,
46 #if HAVE_IPV6
47   T_AAAA,
48   #ifdef SUPPORT_A6
49   T_A6,
50   #endif
51 #endif
52   T_CNAME,
53   T_CSA,     /* Private type for "Client SMTP Authorization". */
54   T_MX,
55   T_MXH,     /* Private type for "MX hostnames" */
56   T_NS,
57   T_PTR,
58   T_SRV,
59   T_TXT,
60   T_ZNS      /* Private type for "zone nameservers" */
61 };
62
63
64 /*************************************************
65 *              Open entry point                  *
66 *************************************************/
67
68 /* See local README for interface description. */
69
70 void *
71 dnsdb_open(uschar *filename, uschar **errmsg)
72 {
73 filename = filename;   /* Keep picky compilers happy */
74 errmsg = errmsg;       /* Ditto */
75 return (void *)(-1);   /* Any non-0 value */
76 }
77
78
79
80 /*************************************************
81 *           Find entry point for dnsdb           *
82 *************************************************/
83
84 /* See local README for interface description. The query in the "keystring" may
85 consist of a number of parts.
86
87 (a) If the first significant character is '>' then the next character is the
88 separator character that is used when multiple records are found. The default
89 separator is newline.
90
91 (b) If the next sequence of characters is 'defer_FOO' followed by a comma,
92 the defer behaviour is set to FOO. The possible behaviours are: 'strict', where
93 any defer causes the whole lookup to defer; 'lax', where a defer causes the
94 whole lookup to defer only if none of the DNS queries succeeds; and 'never',
95 where all defers are as if the lookup failed. The default is 'lax'.
96
97 (c) If the next sequence of characters is a sequence of letters and digits
98 followed by '=', it is interpreted as the name of the DNS record type. The
99 default is "TXT".
100
101 (d) Then there follows list of domain names. This is a generalized Exim list,
102 which may start with '<' in order to set a specific separator. The default
103 separator, as always, is colon. */
104
105 int
106 dnsdb_find(void *handle, uschar *filename, uschar *keystring, int length,
107   uschar **result, uschar **errmsg, BOOL *do_cache)
108 {
109 int rc;
110 int size = 256;
111 int ptr = 0;
112 int sep = 0;
113 int defer_mode = PASS;
114 int type = T_TXT;
115 int failrc = FAIL;
116 uschar *outsep = US"\n";
117 uschar *equals, *domain, *found;
118 uschar buffer[256];
119
120 /* Because we're the working in the search pool, we try to reclaim as much
121 store as possible later, so we preallocate the result here */
122
123 uschar *yield = store_get(size);
124
125 dns_record *rr;
126 dns_answer dnsa;
127 dns_scan dnss;
128
129 handle = handle;           /* Keep picky compilers happy */
130 filename = filename;
131 length = length;
132 do_cache = do_cache;
133
134 /* If the string starts with '>' we change the output separator */
135
136 while (isspace(*keystring)) keystring++;
137 if (*keystring == '>')
138   {
139   outsep = keystring + 1;
140   keystring += 2;
141   while (isspace(*keystring)) keystring++;
142   }
143
144 /* Check for a defer behaviour keyword. */
145
146 if (strncmpic(keystring, US"defer_", 6) == 0)
147   {
148   keystring += 6;
149   if (strncmpic(keystring, US"strict", 6) == 0)
150     {
151     defer_mode = DEFER;
152     keystring += 6;
153     }
154   else if (strncmpic(keystring, US"lax", 3) == 0)
155     {
156     defer_mode = PASS;
157     keystring += 3;
158     }
159   else if (strncmpic(keystring, US"never", 5) == 0)
160     {
161     defer_mode = OK;
162     keystring += 5;
163     }
164   else
165     {
166     *errmsg = US"unsupported dnsdb defer behaviour";
167     return DEFER;
168     }
169   while (isspace(*keystring)) keystring++;
170   if (*keystring++ != ',')
171     {
172     *errmsg = US"dnsdb defer behaviour syntax error";
173     return DEFER;
174     }
175   while (isspace(*keystring)) keystring++;
176   }
177
178 /* If the keystring contains an = this must be preceded by a valid type name. */
179
180 if ((equals = Ustrchr(keystring, '=')) != NULL)
181   {
182   int i, len;
183   uschar *tend = equals;
184
185   while (tend > keystring && isspace(tend[-1])) tend--;
186   len = tend - keystring;
187
188   for (i = 0; i < sizeof(type_names)/sizeof(uschar *); i++)
189     {
190     if (len == Ustrlen(type_names[i]) &&
191         strncmpic(keystring, US type_names[i], len) == 0)
192       {
193       type = type_values[i];
194       break;
195       }
196     }
197
198   if (i >= sizeof(type_names)/sizeof(uschar *))
199     {
200     *errmsg = US"unsupported DNS record type";
201     return DEFER;
202     }
203
204   keystring = equals + 1;
205   while (isspace(*keystring)) keystring++;
206   }
207
208 /* Initialize the resolver in case this is the first time it has been used. */
209
210 dns_init(FALSE, FALSE);
211
212 /* The remainder of the string must be a list of domains. As long as the lookup
213 for at least one of them succeeds, we return success. Failure means that none
214 of them were found.
215
216 The original implementation did not support a list of domains. Adding the list
217 feature is compatible, except in one case: when PTR records are being looked up
218 for a single IPv6 address. Fortunately, we can hack in a compatibility feature
219 here: If the type is PTR and no list separator is specified, and the entire
220 remaining string is valid as an IP address, set an impossible separator so that
221 it is treated as one item. */
222
223 if (type == T_PTR && keystring[0] != '<' &&
224     string_is_ip_address(keystring, NULL) > 0)
225   sep = -1;
226
227 /* Now scan the list and do a lookup for each item */
228
229 while ((domain = string_nextinlist(&keystring, &sep, buffer, sizeof(buffer)))
230         != NULL)
231   {
232   uschar rbuffer[256];
233   int searchtype = (type == T_CSA)? T_SRV :         /* record type we want */
234                    (type == T_MXH)? T_MX :
235                    (type == T_ZNS)? T_NS : type;
236
237   /* If the type is PTR or CSA, we have to construct the relevant magic lookup
238   key if the original is an IP address (some experimental protocols are using
239   PTR records for different purposes where the key string is a host name, and
240   Exim's extended CSA can be keyed by domains or IP addresses). This code for
241   doing the reversal is now in a separate function. */
242
243   if ((type == T_PTR || type == T_CSA) &&
244       string_is_ip_address(domain, NULL) > 0)
245     {
246     dns_build_reverse(domain, rbuffer);
247     domain = rbuffer;
248     }
249
250   DEBUG(D_lookup) debug_printf("dnsdb key: %s\n", domain);
251
252   /* Do the lookup and sort out the result. There are two special types that
253   are handled specially: T_ZNS and T_MXH. The former is handled in a special
254   lookup function so that the facility could be used from other parts of the
255   Exim code. The latter affects only what happens later on in this function,
256   but for tidiness it is handled in a similar way. If the lookup fails,
257   continue with the next domain. In the case of DEFER, adjust the final
258   "nothing found" result, but carry on to the next domain. */
259
260   found = domain;
261   rc = dns_special_lookup(&dnsa, domain, type, &found);
262
263   if (rc == DNS_NOMATCH || rc == DNS_NODATA) continue;
264   if (rc != DNS_SUCCEED)
265     {
266     if (defer_mode == DEFER) return DEFER;          /* always defer */
267       else if (defer_mode == PASS) failrc = DEFER;  /* defer only if all do */
268     continue;                                       /* treat defer as fail */
269     }
270
271   /* Search the returned records */
272
273   for (rr = dns_next_rr(&dnsa, &dnss, RESET_ANSWERS);
274        rr != NULL;
275        rr = dns_next_rr(&dnsa, &dnss, RESET_NEXT))
276     {
277     if (rr->type != searchtype) continue;
278
279     /* There may be several addresses from an A6 record. Put the configured
280     separator between them, just as for between several records. However, A6
281     support is not normally configured these days. */
282
283     if (type == T_A ||
284         #ifdef SUPPORT_A6
285         type == T_A6 ||
286         #endif
287         type == T_AAAA)
288       {
289       dns_address *da;
290       for (da = dns_address_from_rr(&dnsa, rr); da != NULL; da = da->next)
291         {
292         if (ptr != 0) yield = string_cat(yield, &size, &ptr, outsep, 1);
293         yield = string_cat(yield, &size, &ptr, da->address,
294           Ustrlen(da->address));
295         }
296       continue;
297       }
298
299     /* Other kinds of record just have one piece of data each, but there may be
300     several of them, of course. */
301
302     if (ptr != 0) yield = string_cat(yield, &size, &ptr, outsep, 1);
303
304     if (type == T_TXT)
305       {
306       yield = string_cat(yield, &size, &ptr, (uschar *)(rr->data+1),
307         (rr->data)[0]);
308       }
309     else   /* T_CNAME, T_CSA, T_MX, T_MXH, T_NS, T_PTR, T_SRV */
310       {
311       int priority, weight, port;
312       uschar s[264];
313       uschar *p = (uschar *)(rr->data);
314
315       if (type == T_MXH)
316         {
317         /* mxh ignores the priority number and includes only the hostnames */
318         GETSHORT(priority, p);
319         }
320       else if (type == T_MX)
321         {
322         GETSHORT(priority, p);
323         sprintf(CS s, "%d ", priority);
324         yield = string_cat(yield, &size, &ptr, s, Ustrlen(s));
325         }
326       else if (type == T_SRV)
327         {
328         GETSHORT(priority, p);
329         GETSHORT(weight, p);
330         GETSHORT(port, p);
331         sprintf(CS s, "%d %d %d ", priority, weight, port);
332         yield = string_cat(yield, &size, &ptr, s, Ustrlen(s));
333         }
334       else if (type == T_CSA)
335         {
336         /* See acl_verify_csa() for more comments about CSA. */
337
338         GETSHORT(priority, p);
339         GETSHORT(weight, p);
340         GETSHORT(port, p);
341
342         if (priority != 1) continue;      /* CSA version must be 1 */
343
344         /* If the CSA record we found is not the one we asked for, analyse
345         the subdomain assertions in the port field, else analyse the direct
346         authorization status in the weight field. */
347
348         if (found != domain)
349           {
350           if (port & 1) *s = 'X';         /* explicit authorization required */
351           else *s = '?';                  /* no subdomain assertions here */
352           }
353         else
354           {
355           if (weight < 2) *s = 'N';       /* not authorized */
356           else if (weight == 2) *s = 'Y'; /* authorized */
357           else if (weight == 3) *s = '?'; /* unauthorizable */
358           else continue;                  /* invalid */
359           }
360
361         s[1] = ' ';
362         yield = string_cat(yield, &size, &ptr, s, 2);
363         }
364
365       /* GETSHORT() has advanced the pointer to the target domain. */
366
367       rc = dn_expand(dnsa.answer, dnsa.answer + dnsa.answerlen, p,
368         (DN_EXPAND_ARG4_TYPE)(s), sizeof(s));
369
370       /* If an overlong response was received, the data will have been
371       truncated and dn_expand may fail. */
372
373       if (rc < 0)
374         {
375         log_write(0, LOG_MAIN, "host name alias list truncated: type=%s "
376           "domain=%s", dns_text_type(type), domain);
377         break;
378         }
379       else yield = string_cat(yield, &size, &ptr, s, Ustrlen(s));
380       }
381     }    /* Loop for list of returned records */
382   }      /* Loop for list of domains */
383
384 /* Reclaim unused memory */
385
386 store_reset(yield + ptr + 1);
387
388 /* If ptr == 0 we have not found anything. Otherwise, insert the terminating
389 zero and return the result. */
390
391 if (ptr == 0) return failrc;
392 yield[ptr] = 0;
393 *result = yield;
394 return OK;
395 }
396
397 /* End of lookups/dnsdb.c */