Disconnect hostapd from building in base
[dragonfly.git] / contrib / ldns / higher.c
1 /*
2  * higher.c
3  *
4  * Specify some higher level functions that would
5  * be usefull to would be developers
6  *
7  * a Net::DNS like library for C
8  *
9  * (c) NLnet Labs, 2004-2006
10  *
11  * See the file LICENSE for the license
12  */
13
14 #include <ldns/config.h>
15
16 #include <ldns/ldns.h>
17
18 #ifdef HAVE_SSL
19 #include <openssl/ssl.h>
20 #include <openssl/sha.h>
21 #endif /* HAVE_SSL */
22
23 ldns_rr_list *
24 ldns_get_rr_list_addr_by_name(ldns_resolver *res, ldns_rdf *name, ldns_rr_class c, 
25                 uint16_t flags)
26 {
27         ldns_pkt *pkt;
28         ldns_rr_list *aaaa;
29         ldns_rr_list *a;
30         ldns_rr_list *result = NULL;
31         ldns_rr_list *hostsfilenames;
32         size_t i;
33         uint8_t ip6;
34
35         a = NULL; 
36         aaaa = NULL; 
37         result = NULL;
38
39         if (!res) {
40                 return NULL;
41         }
42         if (ldns_rdf_get_type(name) != LDNS_RDF_TYPE_DNAME) {
43                 return NULL;
44         }
45
46         ip6 = ldns_resolver_ip6(res); /* we use INET_ANY here, save
47                                          what was there */
48
49         ldns_resolver_set_ip6(res, LDNS_RESOLV_INETANY);
50         
51         hostsfilenames = ldns_get_rr_list_hosts_frm_file(NULL);
52         for (i = 0; i < ldns_rr_list_rr_count(hostsfilenames); i++) {
53                 if (ldns_rdf_compare(name, 
54                                         ldns_rr_owner(ldns_rr_list_rr(hostsfilenames, 
55                                                         i))) == 0) {
56                         if (!result) {
57                                 result = ldns_rr_list_new();
58                         }
59                         ldns_rr_list_push_rr(result, 
60                                         ldns_rr_clone(ldns_rr_list_rr(hostsfilenames, i)));
61                 }
62         }
63         ldns_rr_list_deep_free(hostsfilenames);
64
65         if (result) {
66                 return result;
67         }
68
69         /* add the RD flags, because we want an answer */
70         pkt = ldns_resolver_query(res, name, LDNS_RR_TYPE_AAAA, c, flags | LDNS_RD);
71         if (pkt) {
72                 /* extract the data we need */
73                 aaaa = ldns_pkt_rr_list_by_type(pkt, LDNS_RR_TYPE_AAAA, 
74                         LDNS_SECTION_ANSWER);
75                 ldns_pkt_free(pkt);
76         } 
77
78         pkt = ldns_resolver_query(res, name, LDNS_RR_TYPE_A, c, flags | LDNS_RD);
79         if (pkt) {
80                 /* extract the data we need */
81                 a = ldns_pkt_rr_list_by_type(pkt, LDNS_RR_TYPE_A, LDNS_SECTION_ANSWER);
82                 ldns_pkt_free(pkt);
83         } 
84         ldns_resolver_set_ip6(res, ip6);
85
86         if (aaaa && a) {
87                 result = ldns_rr_list_cat_clone(aaaa, a);
88                 ldns_rr_list_deep_free(aaaa);
89                 ldns_rr_list_deep_free(a);
90                 return result;
91         }
92         
93         if (aaaa) {
94                 result = ldns_rr_list_clone(aaaa);
95         }
96         
97         if (a) {
98                 result = ldns_rr_list_clone(a);
99         }
100
101         ldns_rr_list_deep_free(aaaa);
102         ldns_rr_list_deep_free(a);
103         return result;
104 }
105
106 ldns_rr_list *
107 ldns_get_rr_list_name_by_addr(ldns_resolver *res, ldns_rdf *addr, ldns_rr_class c, 
108                 uint16_t flags)
109 {
110         ldns_pkt *pkt;
111         ldns_rr_list *names;
112         ldns_rdf *name;
113
114         names = NULL;
115
116         if (!res || !addr) {
117                 return NULL;
118         }
119
120         if (ldns_rdf_get_type(addr) != LDNS_RDF_TYPE_A &&
121                         ldns_rdf_get_type(addr) != LDNS_RDF_TYPE_AAAA) {
122                 return NULL;
123         }
124
125         name = ldns_rdf_address_reverse(addr);
126         
127         /* add the RD flags, because we want an answer */
128         pkt = ldns_resolver_query(res, name, LDNS_RR_TYPE_PTR, c, flags | LDNS_RD);
129         ldns_rdf_deep_free(name);
130         if (pkt) {
131                 /* extract the data we need */
132                 names = ldns_pkt_rr_list_by_type(pkt, 
133                                 LDNS_RR_TYPE_PTR, LDNS_SECTION_ANSWER);
134         }
135         return names;
136 }
137
138 /* read a line, put it in a buffer, parse the buffer */
139 ldns_rr_list *
140 ldns_get_rr_list_hosts_frm_fp(FILE *fp)
141 {
142         return ldns_get_rr_list_hosts_frm_fp_l(fp, NULL);
143 }
144
145 ldns_rr_list *
146 ldns_get_rr_list_hosts_frm_fp_l(FILE *fp, int *line_nr)
147 {
148         ssize_t i, j;
149         size_t cnt;
150         char *line;
151         char *word;
152         char *addr;
153         char *rr_str;
154         ldns_buffer *linebuf;
155         ldns_rr *rr;
156         ldns_rr_list *list;
157         ldns_rdf *tmp;
158         bool ip6;
159         ldns_status parse_result;
160
161         line = LDNS_XMALLOC(char, LDNS_MAX_LINELEN + 1);
162         word = LDNS_XMALLOC(char, LDNS_MAX_LINELEN + 1);
163         addr = LDNS_XMALLOC(char, LDNS_MAX_LINELEN + 1);
164         rr_str = LDNS_XMALLOC(char, LDNS_MAX_LINELEN + 1);
165         ip6 = false;
166         list = ldns_rr_list_new();
167         rr = NULL;
168         if(!line || !word || !addr || !rr_str || !list) {
169                 LDNS_FREE(line);
170                 LDNS_FREE(word);
171                 LDNS_FREE(addr);
172                 LDNS_FREE(rr_str);
173                 ldns_rr_list_free(list);
174                 return NULL;
175         }
176
177         for(i = ldns_fget_token_l(fp, line, "\n", LDNS_MAX_LINELEN, line_nr);
178                         i > 0; i = ldns_fget_token_l(fp, line, "\n", LDNS_MAX_LINELEN, line_nr)) {
179                 /* # is comment */
180                 if (line[0] == '#') {
181                         continue;
182                 }
183                 /* put it in a buffer for further processing */
184                 linebuf = LDNS_MALLOC(ldns_buffer);
185                 if(!linebuf) {
186                         LDNS_FREE(line);
187                         LDNS_FREE(word);
188                         LDNS_FREE(addr);
189                         LDNS_FREE(rr_str);
190                         ldns_rr_list_deep_free(list);
191                         return NULL;
192                 }
193
194                 ldns_buffer_new_frm_data(linebuf, line, (size_t) i);
195                 for(cnt = 0, j = ldns_bget_token(linebuf, word, LDNS_PARSE_NO_NL, LDNS_MAX_LINELEN);
196                                 j > 0;
197                                 j = ldns_bget_token(linebuf, word, LDNS_PARSE_NO_NL, LDNS_MAX_LINELEN), cnt++) {
198                         if (cnt == 0) {
199                                 /* the address */
200                                 if ((tmp = ldns_rdf_new_frm_str(LDNS_RDF_TYPE_AAAA, 
201                                                                 word))) {
202                                         /* ip6 */
203                                         ldns_rdf_deep_free(tmp);
204                                         ip6 = true;
205                                 } else {
206                                         if ((tmp = ldns_rdf_new_frm_str(LDNS_RDF_TYPE_A, 
207                                                                         word))) {
208                                                 /* ip4 */
209                                                 ldns_rdf_deep_free(tmp);
210                                                 ip6 = false;
211                                         } else {
212                                                 /* kaput */
213                                                 break;
214                                         }
215                                 }
216                                 (void)strlcpy(addr, word, LDNS_MAX_LINELEN+1);
217                         } else {
218                                 /* la al la la */
219                                 if (ip6) {
220                                         snprintf(rr_str, LDNS_MAX_LINELEN, 
221                                                 "%s IN AAAA %s", word, addr);
222                                 } else {
223                                         snprintf(rr_str, LDNS_MAX_LINELEN, 
224                                                 "%s IN A %s", word, addr);
225                                 }
226                                 parse_result = ldns_rr_new_frm_str(&rr, rr_str, 0, NULL, NULL);
227                                 if (parse_result == LDNS_STATUS_OK && ldns_rr_owner(rr) && ldns_rr_rd_count(rr) > 0) {
228                                         ldns_rr_list_push_rr(list, ldns_rr_clone(rr));
229                                 }
230                                 ldns_rr_free(rr);
231                         }
232                 }
233                 ldns_buffer_free(linebuf);
234         }
235         LDNS_FREE(line);
236         LDNS_FREE(word);
237         LDNS_FREE(addr);
238         LDNS_FREE(rr_str);
239         return list;
240 }
241
242 ldns_rr_list *
243 ldns_get_rr_list_hosts_frm_file(char *filename)
244 {
245         ldns_rr_list *names;
246         FILE *fp;
247
248         if (!filename) {
249                 fp = fopen(LDNS_RESOLV_HOSTS, "r");
250         
251         } else {
252                 fp = fopen(filename, "r");
253         }
254         if (!fp) {
255                 return NULL;
256         }
257
258         names = ldns_get_rr_list_hosts_frm_fp(fp);
259         fclose(fp);
260         return names;
261 }
262
263 uint16_t
264 ldns_getaddrinfo(ldns_resolver *res, ldns_rdf *node, ldns_rr_class c, 
265                 ldns_rr_list **ret)
266 {
267         ldns_rdf_type t;
268         uint16_t names_found;
269         ldns_resolver *r;
270         ldns_status s;
271
272         t = ldns_rdf_get_type(node);
273         names_found = 0;
274         r = res;
275
276         if (res == NULL) {
277                 /* prepare a new resolver, using /etc/resolv.conf as a guide  */
278                 s = ldns_resolver_new_frm_file(&r, NULL);
279                 if (s != LDNS_STATUS_OK) {
280                         return 0;
281                 } 
282         }
283
284         if (t == LDNS_RDF_TYPE_DNAME) {
285                 /* we're asked to query for a name */
286                 *ret = ldns_get_rr_list_addr_by_name(r, node, c, 0);
287                 names_found = ldns_rr_list_rr_count(*ret);
288         }
289
290         if (t == LDNS_RDF_TYPE_A || t == LDNS_RDF_TYPE_AAAA) {
291                 /* an address */
292                 *ret = ldns_get_rr_list_name_by_addr(r, node, c, 0);
293                 names_found = ldns_rr_list_rr_count(*ret);
294         }
295
296         if (res == NULL) {
297                 ldns_resolver_deep_free(r);
298         }
299         
300         return names_found;
301 }
302
303 bool
304 ldns_nsec_type_check(ldns_rr *nsec, ldns_rr_type t)
305 {
306         /* does the nsec cover the t given? */
307         /* copied from host2str.c line 465: ldns_rdf2buffer_str_nsec */
308         uint8_t window_block_nr;
309         uint8_t bitmap_length;
310         uint16_t type;
311         uint16_t pos = 0;
312         uint16_t bit_pos;
313         ldns_rdf *nsec_type_list = ldns_rr_rdf(nsec, 1); 
314         uint8_t *data;
315         
316         if (nsec_type_list == NULL) {
317                 return false;
318         }
319         data  = ldns_rdf_data(nsec_type_list);
320
321         while(pos < ldns_rdf_size(nsec_type_list)) {
322                 window_block_nr = data[pos];
323                 bitmap_length = data[pos + 1];
324                 pos += 2;
325
326                 for (bit_pos = 0; bit_pos < (bitmap_length) * 8; bit_pos++) {
327                         if (ldns_get_bit(&data[pos], bit_pos)) {
328                                 type = 256 * (uint16_t) window_block_nr + bit_pos;
329
330                                 if ((ldns_rr_type)type == t) {
331                                         /* we have a winner */
332                                         return true;
333                                 }
334                         }
335                 }
336                 pos += (uint16_t) bitmap_length;
337         }
338         return false;
339 }
340
341 void
342 ldns_print_rr_rdf(FILE *fp, ldns_rr *r, int rdfnum, ...)
343 {
344         int16_t rdf;
345         ldns_rdf *rd;
346         va_list va_rdf;
347         va_start(va_rdf, rdfnum);
348
349         for (rdf = (int16_t)rdfnum; rdf != -1; rdf = (int16_t)va_arg(va_rdf, int)) 
350         {
351                 rd = ldns_rr_rdf(r, rdf);
352                 if (!rd) {
353                         continue;
354                 } else {
355                         ldns_rdf_print(fp, rd);
356                         fprintf(fp, " "); /* not sure if we want to do this */
357                 }
358         }
359         va_end(va_rdf);
360 }