djbdnscurve6 45
djbdnscurve6
Loading...
Searching...
No Matches
query.c
Go to the documentation of this file.
1#include "error.h"
2#include "roots.h"
3#include "log.h"
4#include "case.h"
5#include "sipcache.h"
6#include "byte.h"
7#include "dns.h"
8#include "uint_t.h"
9#include "dd.h"
10#include "alloc.h"
11#include "response.h"
12#include "query.h"
13#include "ip.h"
14#include "curvedns.h"
15
16#define LABLEN 255
17
18extern int flagusetxtformat;
19
20static char secretkey[32];
21static char publickey[32];
22
23void query_init(void)
24{
25 int k;
26
27 /* called after droproot(), can't use crypto_box_keypair (depends on /dev/urandom) */
28 for (k = 0; k < 32; ++k)
29 secretkey[k] = dns_random(256);
30 crypto_scalarmult_base((unsigned char *) publickey,(unsigned char *) secretkey);
31
32}
33
34static int flagforwardonly = 0;
35
36void query_forwardonly(void)
37{
38 flagforwardonly = 1;
39}
40
41static void cachegeneric(const char type[2],const char *d,const char *data,unsigned int datalen,uint32 ttl)
42{
43 unsigned int len;
44 char key[257];
45
46 len = dns_domain_length(d);
47 if (len > LABLEN) return;
48
49 byte_copy(key,2,type);
50 byte_copy(key + 2,len,d);
51 case_lowerb(key + 2,len);
52
53 cache_set(key,len + 2,data,datalen,ttl);
54}
55
56static char save_buf[8192];
57static unsigned int save_len;
58static unsigned int save_ok;
59
60static void save_start(void)
61{
62 save_len = 0;
63 save_ok = 1;
64}
65
66static void save_data(const char *buf,unsigned int len)
67{
68 if (!save_ok) return;
69 if (len > (sizeof(save_buf)) - save_len) { save_ok = 0; return; }
70 byte_copy(save_buf + save_len,len,buf);
71 save_len += len;
72}
73
74static void save_finish(const char type[2],const char *d,uint32 ttl)
75{
76 if (!save_ok) return;
77 cachegeneric(type,d,save_buf,save_len,ttl);
78}
79
80static int typematch(const char rtype[2],const char qtype[2])
81{
82 return byte_equal(qtype,2,rtype) || byte_equal(qtype,2,DNS_T_ANY);
83}
84
85static uint32 ttlget(char buf[4])
86{
87 uint32 ttl;
88
89 uint32_unpack_big(buf,&ttl);
90 if (ttl > 1000000000) return 0;
91 if (ttl > 604800) return 604800;
92 return ttl;
93}
94
95static void cleanup(struct query *z)
96{
97 int j;
98 int k;
99
100 dns_transmit_free(&z->dt);
101 for (j = 0; j < QUERY_MAXALIAS; ++j)
102 dns_domain_free(&z->alias[j]);
103 for (j = 0; j < QUERY_MAXLEVEL; ++j) {
104 dns_domain_free(&z->name[j]);
105 for (k = 0; k < QUERY_MAXNS; ++k)
106 dns_domain_free(&z->ns[j][k]);
107 }
108}
109
110static int rqa(struct query *z)
111{
112 int i;
113
114 for (i = QUERY_MAXALIAS - 1; i >= 0; --i)
115 if (z->alias[i]) {
116 if (!response_query(z->alias[i],z->type,z->class)) return 0;
117 while (i > 0) {
118 if (!response_cname(z->alias[i],z->alias[i - 1],z->aliasttl[i])) return 0;
119 --i;
120 }
121 if (!response_cname(z->alias[0],z->name[0],z->aliasttl[0])) return 0;
122 return 1;
123 }
124
125 if (!response_query(z->name[0],z->type,z->class)) return 0;
126 return 1;
127}
128
129static int globalip(char *d,char ip[16])
130{
131 if (dns_domain_equal(d,"\014ip6-loopback\0")) {
132 byte_copy(ip,16,IP6_LOOPBACK_OCTAL);
133 return 1;
134 }
135 if (dns_domain_equal(d,"\014ip4-loopback\0")) {
136 byte_copy(ip,12,V4mappedprefix);
137 byte_copy(ip + 12,4,IP4_LOOPBACK_OCTAL);
138 return 1;
139 }
140
141 /* Domain names may look like IPv4 addresses: 1.2.3.com; not like IPv6 */
142
143 if (dd4(d,"",ip) == 4) return 1;
144 return 0;
145}
146
147static char *t1 = 0;
148static char *t2 = 0;
149static char *t3 = 0;
150static char *cname = 0;
151static char *referral = 0;
152static unsigned int *records = 0;
153
154static int smaller(char *buf,unsigned int len,unsigned int pos1,unsigned int pos2)
155{
156 char header1[12];
157 char header2[12];
158 int r;
159 unsigned int len1;
160 unsigned int len2;
161
162 pos1 = dns_packet_getname(buf,len,pos1,&t1);
163 dns_packet_copy(buf,len,pos1,header1,10);
164 pos2 = dns_packet_getname(buf,len,pos2,&t2);
165 dns_packet_copy(buf,len,pos2,header2,10);
166
167 r = byte_diff(header1,4,header2);
168 if (r < 0) return 1;
169 if (r > 0) return 0;
170
171 len1 = dns_domain_length(t1);
172 len2 = dns_domain_length(t2);
173 if (len1 < len2) return 1;
174 if (len1 > len2) return 0;
175
176 r = case_diffb(t1,len1,t2);
177 if (r < 0) return 1;
178 if (r > 0) return 0;
179
180 if (pos1 < pos2) return 1;
181 return 0;
182}
183
184static int doit(struct query *z,int state)
185{
186 char key[257];
187 char *cached;
188 unsigned int cachedlen;
189 char *buf;
190 unsigned int len;
191 const char *whichserver;
192 char *whichkey;
193 char header[24];
194 char addr[16];
195 char misc[20];
196 char pubkey[32];
197 int flaghaskey;
198 int flagns;
199 unsigned int rcode;
200 unsigned int posanswers;
201 uint16 numanswers;
202 unsigned int posauthority;
203 uint16 numauthority;
204 uint16 numglue;
205 unsigned int pos;
206 unsigned int pos2;
207 uint16 datalen;
208 char *control;
209 char *d;
210 const char *dtype;
211 unsigned int dlen;
212 int flagout;
213 int flagcname;
214 int flagreferral;
215 int flagsoa;
216 const char *cnskey;
217 uint32 ttl;
218 uint32 soattl;
219 uint32 cachettl;
220 uint32 cnamettl;
221 int i;
222 int j;
223 int k;
224 int p;
225 int q;
226
227 errno = EIO;
228 if (state == 1) goto HAVEPACKET;
229 if (state == -1) {
230 log_servfail(z->name[z->level]);
231 goto SERVFAIL;
232 }
233
234
235 NEWNAME:
236 if (++z->loop == QUERY_MAXLOOP) goto DIE;
237 d = z->name[z->level];
238 dtype = z->level ? (z->ipv6[z->level] ? DNS_T_AAAA : DNS_T_A) : z->type;
239 dlen = dns_domain_length(d);
240
241 if (globalip(d,misc)) {
242 if (z->level) {
243 flagns = cns_addns(z,misc,0,0); /* new; ok */
244 if (flagns) log_servflag(addr,flagns);
245 goto LOWERLEVEL;
246 }
247 if (!rqa(z)) goto DIE;
248 if (typematch(DNS_T_A,dtype)) {
249 if (!response_rstart(d,DNS_T_A,MAX_TTL)) goto DIE;
250 if (!response_addbytes(misc,4)) goto DIE;
251 response_rfinish(RESPONSE_ANSWER);
252 }
253 if (typematch(DNS_T_AAAA,dtype)) {
254 if (!response_rstart(d,DNS_T_AAAA,MAX_TTL)) goto DIE;
255 if (!response_addbytes(misc,16)) goto DIE;
256 response_rfinish(RESPONSE_ANSWER);
257 }
258 cleanup(z);
259 return 1;
260 }
261
262 /* common localhost and loopback handling (query.h) */
263
264 if (dns_domain_equal(d,"\011localhost\0") ||
265 dns_domain_equal(d,"\010loopback\0")) {
266 if (z->level) goto LOWERLEVEL;
267 if (!rqa(z)) goto DIE;
268 if (typematch(DNS_T_A,dtype)) {
269 if (!response_rstart(d,DNS_T_A,MAX_TTL)) goto DIE;
270 if (!response_addbytes(IP4_LOOPBACK_OCTAL,4)) goto DIE;
271 response_rfinish(RESPONSE_ANSWER);
272 }
273 if (typematch(DNS_T_AAAA,dtype)) {
274 if (!response_rstart(d,DNS_T_AAAA,MAX_TTL)) goto DIE;
275 if (!response_addbytes(IP6_LOOPBACK_OCTAL,16)) goto DIE;
276 response_rfinish(RESPONSE_ANSWER);
277 }
278 cleanup(z);
279 return 1;
280 }
281
282 /* IPv6 well-known names (query.h) RFC 4291 */
283
284 if (dns_domain_equal(d,IP6_LOOPBACK_ARPA) ||
285 dns_domain_equal(d,IP6_LOCALHOST_ARPA)) {
286 if (z->level) goto LOWERLEVEL;
287 if (!rqa(z)) goto DIE;
288 if (typematch(DNS_T_PTR,dtype)) {
289 if (!response_rstart(d,DNS_T_PTR,MAX_TTL)) goto DIE;
290 if (!response_addname("\014ip6-loopback\0")) goto DIE;
291 response_rfinish(RESPONSE_ANSWER);
292 }
293 cleanup(z);
294 return 1;
295 }
296
297 if (dns_domain_equal(d,IP6_LOCALNET_ARPA)) { /* unspecified IPv6 */
298 if (z->level) goto LOWERLEVEL;
299 if (!rqa(z)) goto DIE;
300 if (typematch(DNS_T_PTR,dtype)) {
301 if (!response_rstart(d,DNS_T_PTR,MAX_TTL)) goto DIE;
302 if (!response_addname("\014ip6-localnet\0")) goto DIE;
303 response_rfinish(RESPONSE_ANSWER);
304 }
305 cleanup(z);
306 return 1;
307 }
308
309 if (dns_domain_equal(d,IP6_MULTICAST_ARPA)) {
310 if (z->level) goto LOWERLEVEL;
311 if (!rqa(z)) goto DIE;
312 if (typematch(DNS_T_PTR,dtype)) {
313 if (!response_rstart(d,DNS_T_PTR,MAX_TTL)) goto DIE;
314 if (!response_addname("\017ip6-mcastprefix\0")) goto DIE;
315 response_rfinish(RESPONSE_ANSWER);
316 }
317 cleanup(z);
318 return 1;
319 }
320
321 if (dns_domain_equal(d,IP6_ALLNODESMULTICAST_ARPA)) {
322 if (z->level) goto LOWERLEVEL;
323 if (!rqa(z)) goto DIE;
324 if (typematch(DNS_T_PTR,dtype)) {
325 if (!response_rstart(d,DNS_T_PTR,MAX_TTL)) goto DIE;
326 if (!response_addname("\016ip6-allnodes\0")) goto DIE;
327 response_rfinish(RESPONSE_ANSWER);
328 }
329 cleanup(z);
330 return 1;
331 }
332
333 if (dns_domain_equal(d,IP6_ALLROUTERSMULTICAST_ARPA)) {
334 if (z->level) goto LOWERLEVEL;
335 if (!rqa(z)) goto DIE;
336 if (typematch(DNS_T_PTR,dtype)) {
337 if (!response_rstart(d,DNS_T_PTR,MAX_TTL)) goto DIE;
338 if (!response_addname("\016ip6-allrouters\0")) goto DIE;
339 response_rfinish(RESPONSE_ANSWER);
340 }
341 cleanup(z);
342 return 1;
343 }
344
345 if (dns_domain_equal(d,"\015ip6-localhost\0") ||
346 dns_domain_equal(d,"\014ip6-loopback\0")) {
347 if (z->level) goto LOWERLEVEL;
348 if (!rqa(z)) goto DIE;
349 if (typematch(DNS_T_AAAA,dtype)) {
350 if (!response_rstart(d,DNS_T_AAAA,MAX_TTL)) goto DIE;
351 if (!response_addbytes(IP6_LOOPBACK_OCTAL,16)) goto DIE;
352 response_rfinish(RESPONSE_ANSWER);
353 }
354 cleanup(z);
355 return 1;
356 }
357
358 if (dns_domain_equal(d,"\014ip6-localnet\0")) {
359 if (z->level) goto LOWERLEVEL;
360 if (!rqa(z)) goto DIE;
361 if (typematch(DNS_T_AAAA,dtype)) {
362 if (!response_rstart(d,DNS_T_AAAA,MAX_TTL)) goto DIE;
363 if (!response_addbytes(IP6_LOCALNET,16)) goto DIE;
364 response_rfinish(RESPONSE_ANSWER);
365 }
366 cleanup(z);
367 return 1;
368 }
369
370 if (dns_domain_equal(d,"\017ip6-mcastprefix\0")) {
371 if (z->level) goto LOWERLEVEL;
372 if (!rqa(z)) goto DIE;
373 if (typematch(DNS_T_AAAA,dtype)) {
374 if (!response_rstart(d,DNS_T_AAAA,MAX_TTL)) goto DIE;
375 if (!response_addbytes(IP6_MULTICASTPFX_OCTAL,16)) goto DIE;
376 response_rfinish(RESPONSE_ANSWER);
377 }
378 cleanup(z);
379 return 1;
380 }
381
382 if (dns_domain_equal(d,"\14ip6-allnodes\0")) {
383 if (z->level) goto LOWERLEVEL;
384 if (!rqa(z)) goto DIE;
385 if (typematch(DNS_T_AAAA,dtype)) {
386 if (!response_rstart(d,DNS_T_AAAA,MAX_TTL)) goto DIE;
387 if (!response_addbytes(IP6_ALLNODES_OCTAL,16)) goto DIE;
388 response_rfinish(RESPONSE_ANSWER);
389 }
390 cleanup(z);
391 return 1;
392 }
393
394 if (dns_domain_equal(d,"\16ip6-allrouters\0")) {
395 if (z->level) goto LOWERLEVEL;
396 if (!rqa(z)) goto DIE;
397 if (typematch(DNS_T_AAAA,dtype)) {
398 if (!response_rstart(d,DNS_T_AAAA,MAX_TTL)) goto DIE;
399 if (!response_addbytes(IP6_ALLROUTERS_OCTAL,16)) goto DIE;
400 response_rfinish(RESPONSE_ANSWER);
401 }
402 cleanup(z);
403 return 1;
404 }
405
406 /* IPv4 well-known names (query.h) */
407
408 if (dns_domain_equal(d,IP4_LOOPBACK_ARPA)) {
409 if (z->level) goto LOWERLEVEL;
410 if (!rqa(z)) goto DIE;
411 if (typematch(DNS_T_PTR,dtype)) {
412 if (!response_rstart(d,DNS_T_PTR,MAX_TTL)) goto DIE;
413 if (!response_addname("\014ip4-loopback\0")) goto DIE;
414 response_rfinish(RESPONSE_ANSWER);
415 }
416 cleanup(z);
417 return 1;
418 }
419
420 if (dns_domain_equal(d,IP4_LOCALHOST_ARPA)) {
421 if (z->level) goto LOWERLEVEL;
422 if (!rqa(z)) goto DIE;
423 if (typematch(DNS_T_PTR,dtype)) {
424 if (!response_rstart(d,DNS_T_PTR,MAX_TTL)) goto DIE;
425 if (!response_addname("\015ip4-localhost\0")) goto DIE;
426 response_rfinish(RESPONSE_ANSWER);
427 }
428 cleanup(z);
429 log_stats();
430 return 1;
431 }
432
433 if (dns_domain_equal(d,"\014ip4-localnet\0")) {
434 if (z->level) goto LOWERLEVEL;
435 if (!rqa(z)) goto DIE;
436 if (typematch(DNS_T_A,dtype)) {
437 if (!response_rstart(d,DNS_T_A,MAX_TTL)) goto DIE;
438 if (!response_addbytes(IP4_LOCALNET,4)) goto DIE;
439 response_rfinish(RESPONSE_ANSWER);
440 }
441 cleanup(z);
442 return 1;
443 }
444
445 if (dns_domain_equal(d,"\015ip4-localhost\0") ||
446 dns_domain_equal(d,"\014ip4-loopback\0")) {
447 if (z->level) goto LOWERLEVEL;
448 if (!rqa(z)) goto DIE;
449 if (typematch(DNS_T_A,dtype)) {
450 if (!response_rstart(d,DNS_T_A,MAX_TTL)) goto DIE;
451 if (!response_addbytes(IP4_LOOPBACK_OCTAL,4)) goto DIE;
452 response_rfinish(RESPONSE_ANSWER);
453 }
454 cleanup(z);
455 return 1;
456 }
457
458 /* .onion TLD RFC 7686 */
459
460 if (dns_domain_suffix(d,"\05onion\0"))
461 goto NXDOMAIN;
462
463 /* Reverse lookup for locally assigned IPv6 addresses (FD00::/8) RFC 4193 */
464
465 if (typematch(DNS_T_PTR,dtype) &&
466 dns_domain_suffix(d,"\01d\01f\03ip6\04arpa\0") &&
467 roots_same(d,"\0") &&
468 !flagforwardonly) // the cache we'll ask might know a proper NS
469 goto NXDOMAIN;
470
471 /* special names done */
472
473 if (dlen <= LABLEN) {
474 byte_copy(key,2,DNS_T_ANY);
475 byte_copy(key + 2,dlen,d);
476 case_lowerb(key + 2,dlen);
477 cached = cache_get(key,dlen + 2,&cachedlen,&ttl);
478 if (cached) {
479 log_cachednxdomain(d);
480 goto NXDOMAIN;
481 }
482
483 byte_copy(key,2,DNS_T_CNAME);
484 cached = cache_get(key,dlen + 2,&cachedlen,&ttl);
485
486 if (cached && cachedlen) {
487 if (typematch(DNS_T_CNAME,dtype)) {
488 log_cachedanswer(d,DNS_T_CNAME);
489 if (!rqa(z)) goto DIE;
490 if (!response_cname(z->name[0],cached,ttl)) goto DIE;
491 cleanup(z);
492 return 1;
493 }
494 log_cachedcname(d,cached);
495
496 if (!dns_domain_copy(&cname,cached)) goto DIE;
497 goto CNAME;
498 }
499
500 if (typematch(DNS_T_NS,dtype)) {
501 byte_copy(key,2,DNS_T_NS);
502 cached = cache_get(key,dlen + 2,&cachedlen,&ttl);
503 if (cached && (cachedlen || byte_diff(dtype,2,DNS_T_ANY))) {
504 if (z->level) {
505 flaghaskey = cns_pubkey(d,pubkey);
506 flagns = cns_addns(z,cached,flaghaskey,pubkey); /* ok */
507 if (flagns) log_servflag(addr,flagns);
508 else log_cachedanswer(d,DNS_T_NS);
509 }
510 if (!rqa(z)) goto DIE;
511 pos = 0;
512 while ((pos = dns_packet_getname(cached,cachedlen,pos,&t2))) {
513 if (!response_rstart(d,DNS_T_NS,ttl)) goto DIE;
514 if (!response_addname(t2)) goto DIE;
515 response_rfinish(RESPONSE_ANSWER);
516 }
517 cleanup(z);
518 return 1;
519 }
520 }
521
522 if (typematch(DNS_T_PTR,dtype)) {
523 byte_copy(key,2,DNS_T_PTR);
524 cached = cache_get(key,dlen + 2,&cachedlen,&ttl);
525 if (cached && (cachedlen || byte_diff(dtype,2,DNS_T_ANY))) {
526 log_cachedanswer(d,DNS_T_PTR);
527 if (!rqa(z)) goto DIE;
528 pos = 0;
529 while ((pos = dns_packet_getname(cached,cachedlen,pos,&t2))) {
530 if (!response_rstart(d,DNS_T_PTR,ttl)) goto DIE;
531 if (!response_addname(t2)) goto DIE;
532 response_rfinish(RESPONSE_ANSWER);
533 }
534 cleanup(z);
535 return 1;
536 }
537 }
538
539 if (typematch(DNS_T_MX,dtype)) {
540 byte_copy(key,2,DNS_T_MX);
541 cached = cache_get(key,dlen + 2,&cachedlen,&ttl);
542 if (cached && (cachedlen || byte_diff(dtype,2,DNS_T_ANY))) {
543 log_cachedanswer(d,DNS_T_MX);
544 if (!rqa(z)) goto DIE;
545 pos = 0;
546 while ((pos = dns_packet_copy(cached,cachedlen,pos,misc,2))) {
547 pos = dns_packet_getname(cached,cachedlen,pos,&t2);
548 if (!pos) break;
549 if (!response_rstart(d,DNS_T_MX,ttl)) goto DIE;
550 if (!response_addbytes(misc,2)) goto DIE;
551 if (!response_addname(t2)) goto DIE;
552 response_rfinish(RESPONSE_ANSWER);
553 }
554 cleanup(z);
555 return 1;
556 }
557 }
558
559 if (typematch(DNS_T_A,dtype)) {
560 byte_copy(key,2,DNS_T_A);
561 cached = cache_get(key,dlen + 2,&cachedlen,&ttl);
562 /* if we were looking the A record up to find an NS, try IPv6 too */
563 if (cached && !cachedlen && z->level) {
564 z->ipv6[z->level] = 1;
565 goto NEWNAME;
566 }
567 if (cached && (cachedlen || byte_diff(dtype,2,DNS_T_ANY))) {
568 if (z->level) {
569 flaghaskey = cns_pubkey(d,pubkey);
570 log_cachedanswer(d,DNS_T_A);
571 while (cachedlen >= 4) {
572 for (k = 0; k < QUERY_MAXIPLEN; k += 16)
573 if (byte_equal(z->servers[z->level - 1] + k,16,V6localnet)) {
574 byte_copy(z->servers[z->level - 1] + k,12,V4mappedprefix);
575 byte_copy(z->servers[z->level - 1] + k + 12,4,cached);
576 break;
577 }
578 byte_copy(addr,12,V4mappedprefix);
579 byte_copy(addr+12,4,cached);
580 flagns = cns_addns(z,addr,flaghaskey,pubkey);
581 if (flagns) log_servflag(addr,flagns);
582 cached += 4;
583 cachedlen -= 4;
584 }
585 goto LOWERLEVEL;
586 }
587
588 log_cachedanswer(d,DNS_T_A);
589 if (!rqa(z)) goto DIE;
590 while (cachedlen >= 4) {
591 if (!response_rstart(d,DNS_T_A,ttl)) goto DIE;
592 if (!response_addbytes(cached,4)) goto DIE;
593 response_rfinish(RESPONSE_ANSWER);
594 cached += 4;
595 cachedlen -= 4;
596 }
597 cleanup(z);
598 return 1;
599 }
600 }
601
602 if (typematch(DNS_T_AAAA,dtype)) {
603 byte_copy(key,2,DNS_T_AAAA);
604 cached = cache_get(key,dlen + 2,&cachedlen,&ttl);
605 if (cached && (cachedlen || byte_diff(dtype,2,DNS_T_ANY))) {
606 if (z->level) {
607 flaghaskey = cns_pubkey(d,pubkey);
608 log_cachedanswer(d,DNS_T_AAAA);
609 while (cachedlen >= 16) {
610 flagns = cns_addns(z,cached,flaghaskey,pubkey);
611 if (flagns) log_servflag(addr,flagns);
612 cached += 16;
613 cachedlen -= 16;
614 }
615 goto LOWERLEVEL;
616 }
617
618 log_cachedanswer(d,DNS_T_AAAA);
619 if (!rqa(z)) goto DIE;
620 while (cachedlen >= 16) {
621 if (!response_rstart(d,DNS_T_AAAA,ttl)) goto DIE;
622 if (!response_addbytes(cached,16)) goto DIE;
623 response_rfinish(RESPONSE_ANSWER);
624 cached += 16;
625 cachedlen -= 16;
626 }
627 cleanup(z);
628 return 1;
629 }
630 }
631
632 if (!typematch(DNS_T_ANY,dtype) && !typematch(DNS_T_AXFR,dtype) &&
633 !typematch(DNS_T_NS,dtype) && !typematch(DNS_T_PTR,dtype) &&
634 !typematch(DNS_T_A,dtype) && !typematch(DNS_T_AAAA,dtype) &&
635 !typematch(DNS_T_MX,dtype)) {
636 byte_copy(key,2,dtype);
637 cached = cache_get(key,dlen + 2,&cachedlen,&ttl);
638 if (cached && (cachedlen || byte_diff(dtype,2,DNS_T_ANY))) {
639 log_cachedanswer(d,dtype);
640 if (!rqa(z)) goto DIE;
641 while (cachedlen >= 2) {
642 uint16_unpack_big(cached,&datalen);
643 cached += 2;
644 cachedlen -= 2;
645 if (datalen > cachedlen) goto DIE;
646 if (!response_rstart(d,dtype,ttl)) goto DIE;
647 if (!response_addbytes(cached,datalen)) goto DIE;
648 response_rfinish(RESPONSE_ANSWER);
649 cached += datalen;
650 cachedlen -= datalen;
651 }
652 cleanup(z);
653 return 1;
654 }
655 }
656 } /* end of dlen if */
657
658 for (;;) {
659 /* XXX: allow roots() to provide keys */
660 if (roots(z->servers[z->level],d)) {
661 z->flagnskeys[z->level] = 0;
662 for (j = 0; j < QUERY_MAXNS; ++j)
663 dns_domain_free(&z->ns[z->level][j]);
664 z->control[z->level] = d;
665 break;
666 }
667
668 if (!flagforwardonly && (z->level < 2))
669 if (dlen < LABLEN) {
670 byte_copy(key,2,DNS_T_NS);
671 byte_copy(key + 2,dlen,d);
672 case_lowerb(key + 2,dlen);
673 cached = cache_get(key,dlen + 2,&cachedlen,&ttl);
674 if (cached && cachedlen) {
675 z->control[z->level] = d;
676 byte_zero(z->servers[z->level],QUERY_MAXIPLEN);
677 z->flagnskeys[z->level] = 0; /* XXX */
678 for (j = 0; j < QUERY_MAXNS; ++j)
679 dns_domain_free(&z->ns[z->level][j]);
680 pos = 0;
681 j = 0;
682 while ((pos = dns_packet_getname(cached,cachedlen,pos,&t1))) {
683 log_cachedns(d,t1);
684 if (j < QUERY_MAXNS)
685 if (!dns_domain_copy(&z->ns[z->level][j++],t1)) goto DIE;
686 }
687 break;
688 }
689 }
690
691 if (!*d) goto DIE;
692 j = 1 + (unsigned int) (unsigned char) *d;
693 dlen -= j;
694 d += j;
695 }
696
697
698 HAVENS:
699 for (j = 0; j < QUERY_MAXNS; ++j)
700 if (z->ns[z->level][j]) {
701 if (z->level + 1 < QUERY_MAXLEVEL) {
702 if (!dns_domain_copy(&z->name[z->level + 1],z->ns[z->level][j])) goto DIE;
703 dns_domain_free(&z->ns[z->level][j]);
704 ++z->level;
705 z->ipv6[z->level] = 0;
706 goto NEWNAME;
707 }
708 dns_domain_free(&z->ns[z->level][j]);
709 }
710
711 for (j = 0; j < QUERY_MAXIPLEN; j += 16)
712 if (byte_diff(z->servers[z->level] + j,16,V6localnet)) break;
713 if (j == QUERY_MAXIPLEN) goto SERVFAIL;
714
715 if (z->flagnskeys[z->level]) {
716 byte_copy(key,2,DNS_T_AXFR);
717 for (j = 0; j < QUERY_MAXIPLEN; j += 16)
718 if (byte_diff(z->servers[z->level] + j,16,V6localnet)) {
719 whichkey = z->keys[z->level] + 2 * j;
720 byte_copy(key + 2,32,whichkey);
721 cached = cache_get(key,34,&cachedlen,&ttl);
722 if (cached && (cachedlen == 32)) {
723 byte_copy(whichkey,32,cached);
724 continue;
725 }
726 crypto_box_beforenm((unsigned char *) whichkey,(const unsigned char *) whichkey,(const unsigned char *) secretkey);
727 cache_set(key,34,whichkey,32,MAX_TTL);
728 }
729 }
730
731 cns_sortns(z->servers[z->level],z->keys[z->level],QUERY_MAXNS);
732 dtype = z->level ? DNS_T_A : z->type;
733 control = flagusetxtformat ? z->control[z->level] : 0;
734 cnskey = z->flagnskeys[z->level] ? z->keys[z->level] : 0;
735 log_tx(z->name[z->level],dtype,z->control[z->level],z->servers[z->level],z->flagnskeys[z->level],z->level);
736
737 if (cns_transmit_start(&z->dt,z->servers[z->level],flagforwardonly,z->name[z->level],\
738 dtype,z->localip,cnskey,publickey,control) < 0) goto DIE;
739
740 return 0;
741
742
743 LOWERLEVEL:
744 dns_domain_free(&z->name[z->level]);
745 for (j = 0; j < QUERY_MAXNS; ++j)
746 dns_domain_free(&z->ns[z->level][j]);
747 --z->level;
748 goto HAVENS;
749
750
751 HAVEPACKET:
752 if (++z->loop == QUERY_MAXLOOP) goto DIE;
753 buf = z->dt.packet;
754 len = z->dt.packetlen;
755
756 whichserver = z->dt.servers + 16 * z->dt.curserver;
757 control = z->control[z->level];
758 d = z->name[z->level];
759 /* dtype = z->level ? DNS_T_A : z->type; */
760 dtype = z->level ? (z->ipv6[z->level] ? DNS_T_AAAA : DNS_T_A) : z->type;
761
762 pos = dns_packet_copy(buf,len,0,header,12); if (!pos) goto DIE;
763 pos = dns_packet_skipname(buf,len,pos); if (!pos) goto DIE;
764 pos += 4;
765 posanswers = pos;
766
767 uint16_unpack_big(header + 6,&numanswers);
768 uint16_unpack_big(header + 8,&numauthority);
769 uint16_unpack_big(header + 10,&numglue);
770
771 rcode = header[3] & 15;
772 if (rcode && (rcode != 3)) goto DIE; /* impossible; see irrelevant() */
773
774 flagout = 0;
775 flagcname = 0;
776 flagreferral = 0;
777 flagsoa = 0;
778 soattl = 0;
779 cachettl = 0;
780 cnamettl = 0;
781
782 for (j = 0; j < numanswers; ++j) {
783 pos = dns_packet_getname(buf,len,pos,&t1); if (!pos) goto DIE;
784 pos = dns_packet_copy(buf,len,pos,header,10); if (!pos) goto DIE;
785
786 if (dns_domain_equal(t1,d))
787 if (byte_equal(header + 2,2,DNS_C_IN)) { /* should always be true */
788 if (typematch(header,dtype))
789 flagout = 1;
790 else if (typematch(header,DNS_T_CNAME)) {
791 if (!dns_packet_getname(buf,len,pos,&cname)) goto DIE;
792 flagcname = 1;
793 cnamettl = ttlget(header + 4);
794 }
795 }
796
797 uint16_unpack_big(header + 8,&datalen);
798 pos += datalen;
799 }
800 posauthority = pos;
801
802 for (j = 0; j < numauthority; ++j) {
803 pos = dns_packet_getname(buf,len,pos,&t1); if (!pos) goto DIE;
804 pos = dns_packet_copy(buf,len,pos,header,10); if (!pos) goto DIE;
805
806 if (typematch(header,DNS_T_SOA)) {
807 flagsoa = 1;
808 soattl = ttlget(header + 4);
809 if (soattl > 3600) soattl = 3600;
810 }
811 else if (typematch(header,DNS_T_NS)) {
812 flagreferral = 1;
813 if (!dns_domain_copy(&referral,t1)) goto DIE;
814 }
815
816 uint16_unpack_big(header + 8,&datalen);
817 pos += datalen;
818 }
819
820 /* JBP Negative cache patch and record in log */
821
822 if (flagsoa && (pos <= len)) {
823 cachettl = ttlget(buf + pos - 4);
824 if (soattl < cachettl) cachettl = soattl;
825 }
826
827 if (!flagcname && !rcode && !flagout && flagreferral && !flagsoa)
828 if (dns_domain_equal(referral,control) || !dns_domain_suffix(referral,control)) {
829 log_lame(whichserver,control,referral);
830 byte_zero(whichserver,4);
831 goto HAVENS;
832 }
833
834 if (records) { alloc_free(records); records = 0; }
835
836 k = numanswers + numauthority + numglue;
837 records = (unsigned int *) alloc(k * sizeof(unsigned int));
838 if (!records) goto DIE;
839
840 pos = posanswers;
841 for (j = 0; j < k; ++j) {
842 records[j] = pos;
843 pos = dns_packet_getname(buf,len,pos,&t1); if (!pos) goto DIE;
844 pos = dns_packet_copy(buf,len,pos,header,10); if (!pos) goto DIE;
845 uint16_unpack_big(header + 8,&datalen);
846 pos += datalen;
847 }
848
849 i = j = k;
850 while (j > 1) {
851 if (i > 1) { --i; pos = records[i - 1]; }
852 else { pos = records[j - 1]; records[j - 1] = records[i - 1]; --j; }
853
854 q = i;
855 while ((p = q * 2) < j) {
856 if (!smaller(buf,len,records[p],records[p - 1])) ++p;
857 records[q - 1] = records[p - 1]; q = p;
858 }
859 if (p == j) {
860 records[q - 1] = records[p - 1]; q = p;
861 }
862 while ((q > i) && smaller(buf,len,records[(p = q/2) - 1],pos)) {
863 records[q - 1] = records[p - 1]; q = p;
864 }
865 records[q - 1] = pos;
866 }
867
868 i = 0;
869 while (i < k) {
870 char type[2];
871
872 pos = dns_packet_getname(buf,len,records[i],&t1); if (!pos) goto DIE;
873 pos = dns_packet_copy(buf,len,pos,header,10); if (!pos) goto DIE;
874 ttl = ttlget(header + 4);
875
876 byte_copy(type,2,header);
877 if (byte_diff(header + 2,2,DNS_C_IN)) { ++i; continue; }
878
879 for (j = i + 1; j < k; ++j) {
880 pos = dns_packet_getname(buf,len,records[j],&t2); if (!pos) goto DIE;
881 pos = dns_packet_copy(buf,len,pos,header,10); if (!pos) goto DIE;
882 if (!dns_domain_equal(t1,t2)) break;
883 if (byte_diff(header,2,type)) break;
884 if (byte_diff(header + 2,2,DNS_C_IN)) break;
885 }
886
887 if (!dns_domain_suffix(t1,control)) { i = j; continue; }
888 if (!roots_same(t1,control)) { i = j; continue; }
889
890 if (byte_equal(type,2,DNS_T_ANY))
891 ;
892 else if (byte_equal(type,2,DNS_T_AXFR))
893 ;
894 else if (byte_equal(type,2,DNS_T_SOA)) {
895 while (i < j) {
896 pos = dns_packet_skipname(buf,len,records[i]); if (!pos) goto DIE;
897 pos = dns_packet_getname(buf,len,pos + 10,&t2); if (!pos) goto DIE;
898 pos = dns_packet_getname(buf,len,pos,&t3); if (!pos) goto DIE;
899 pos = dns_packet_copy(buf,len,pos,misc,20); if (!pos) goto DIE;
900 if (records[i] < posauthority)
901 log_rrsoa(whichserver,t1,t2,t3,misc,ttl);
902 ++i;
903 }
904 }
905 else if (byte_equal(type,2,DNS_T_CNAME)) {
906 pos = dns_packet_skipname(buf,len,records[j - 1]); if (!pos) goto DIE;
907 pos = dns_packet_getname(buf,len,pos + 10,&t2); if (!pos) goto DIE;
908 log_rrcname(whichserver,t1,t2,ttl);
909 cachegeneric(DNS_T_CNAME,t1,t2,dns_domain_length(t2),ttl);
910 }
911 else if (byte_equal(type,2,DNS_T_PTR)) {
912 save_start();
913 while (i < j) {
914 pos = dns_packet_skipname(buf,len,records[i]); if (!pos) goto DIE;
915 pos = dns_packet_getname(buf,len,pos + 10,&t2); if (!pos) goto DIE;
916 log_rrptr(whichserver,t1,t2,ttl);
917 save_data(t2,dns_domain_length(t2));
918 ++i;
919 }
920 save_finish(DNS_T_PTR,t1,ttl);
921 }
922 else if (byte_equal(type,2,DNS_T_NS)) {
923 save_start();
924 while (i < j) {
925 pos = dns_packet_skipname(buf,len,records[i]); if (!pos) goto DIE;
926 pos = dns_packet_getname(buf,len,pos + 10,&t2); if (!pos) goto DIE;
927 log_rrns(whichserver,t1,t2,ttl);
928 save_data(t2,dns_domain_length(t2));
929 ++i;
930 }
931 save_finish(DNS_T_NS,t1,ttl);
932 }
933 else if (byte_equal(type,2,DNS_T_MX)) {
934 save_start();
935 while (i < j) {
936 pos = dns_packet_skipname(buf,len,records[i]); if (!pos) goto DIE;
937 pos = dns_packet_copy(buf,len,pos + 10,misc,2); if (!pos) goto DIE;
938 pos = dns_packet_getname(buf,len,pos,&t2); if (!pos) goto DIE;
939 log_rrmx(whichserver,t1,t2,misc,ttl);
940 save_data(misc,2);
941 save_data(t2,dns_domain_length(t2));
942 ++i;
943 }
944 save_finish(DNS_T_MX,t1,ttl);
945 }
946 else if (byte_equal(type,2,DNS_T_A)) {
947 save_start();
948 while (i < j) {
949 pos = dns_packet_skipname(buf,len,records[i]); if (!pos) goto DIE;
950 pos = dns_packet_copy(buf,len,pos,header,10); if (!pos) goto DIE;
951 if (byte_equal(header + 8,2,"\0\4")) {
952 pos = dns_packet_copy(buf,len,pos,header,4); if (!pos) goto DIE;
953 save_data(header,4);
954 log_rr(whichserver,t1,DNS_T_A,header,4,ttl);
955 }
956 ++i;
957 }
958 save_finish(DNS_T_A,t1,ttl);
959 }
960 else if (byte_equal(type,2,DNS_T_AAAA)) {
961 save_start();
962 while (i < j) {
963 pos = dns_packet_skipname(buf,len,records[i]); if (!pos) goto DIE;
964 pos = dns_packet_copy(buf,len,pos,header,10); if (!pos) goto DIE;
965 if (byte_equal(header + 8,2,"\0\20")) {
966 pos = dns_packet_copy(buf,len,pos,header,16); if (!pos) goto DIE;
967 save_data(header,16);
968 log_rr(whichserver,t1,DNS_T_AAAA,header,16,ttl);
969 }
970 ++i;
971 }
972 save_finish(DNS_T_AAAA,t1,ttl);
973 }
974 else {
975 save_start();
976 while (i < j) {
977 pos = dns_packet_skipname(buf,len,records[i]); if (!pos) goto DIE;
978 pos = dns_packet_copy(buf,len,pos,header,10); if (!pos) goto DIE;
979 uint16_unpack_big(header + 8,&datalen);
980 if (datalen > len - pos) goto DIE;
981 save_data(header + 8,2);
982 save_data(buf + pos,datalen);
983 log_rr(whichserver,t1,type,buf + pos,datalen,ttl);
984 ++i;
985 }
986 save_finish(type,t1,ttl);
987 }
988
989 i = j;
990 }
991
992 alloc_free(records); records = 0;
993
994 /* Original DJB's CNAME handling instead of JBP;
995 ** the latter does not work well under all given circumstances */
996
997 if (flagcname) {
998 ttl = cnamettl;
999 CNAME:
1000 if (!z->level) {
1001 if (z->alias[QUERY_MAXALIAS - 1]) goto DIE;
1002 for (j = QUERY_MAXALIAS - 1; j > 0; --j)
1003 z->alias[j] = z->alias[j - 1];
1004
1005 for (j = QUERY_MAXALIAS - 1; j > 0; --j)
1006 z->aliasttl[j] = z->aliasttl[j - 1];
1007
1008 z->alias[0] = z->name[0];
1009 z->aliasttl[0] = ttl;
1010 z->name[0] = 0;
1011 }
1012 if (!dns_domain_copy(&z->name[z->level],cname)) goto DIE;
1013 goto NEWNAME;
1014 }
1015
1016 if (rcode == 3) {
1017 log_nxdomain(whichserver,d,cachettl);
1018 cachegeneric(DNS_T_ANY,d,"",0,cachettl);
1019
1020 NXDOMAIN:
1021 if (z->level) goto LOWERLEVEL;
1022 if (!rqa(z)) goto DIE;
1023 response_nxdomain();
1024 cleanup(z);
1025 return 1;
1026 }
1027
1028 /* Don't save empty RRSets for those types that we use as special markers */
1029
1030 if (!flagout && flagsoa)
1031 if (byte_diff(DNS_T_ANY,2,dtype))
1032 if (byte_diff(DNS_T_AXFR,2,dtype)) {
1033 save_start();
1034 save_finish(dtype,d,soattl);
1035 log_nodata(whichserver,d,dtype,soattl);
1036 if (z->level && !byte_diff(DNS_T_A,2,dtype)) {
1037 d = z->name[z->level];
1038 z->ipv6[z->level] = 1;
1039 goto NEWNAME; /* retry, will ask for AAAA next */
1040 }
1041 }
1042
1043 log_stats();
1044
1045 if (flagout || flagsoa || !flagreferral) {
1046 if (z->level) {
1047 flaghaskey = cns_pubkey(d,pubkey);
1048 pos = posanswers;
1049 for (j = 0; j < numanswers; ++j) {
1050 pos = dns_packet_getname(buf,len,pos,&t1); if (!pos) goto DIE;
1051 pos = dns_packet_copy(buf,len,pos,header,10); if (!pos) goto DIE;
1052 uint16_unpack_big(header + 8,&datalen);
1053 if (dns_domain_equal(t1,d)) {
1054 if (typematch(header,DNS_T_A))
1055 if (byte_equal(header + 2,2,DNS_C_IN)) /* should always be true */
1056 if (datalen == 4) {
1057 if (!dns_packet_copy(buf,len,pos,misc,4)) goto DIE;
1058 byte_copy(addr,12,V4mappedprefix);
1059 byte_copy(addr+12,4,misc);
1060 flagns = cns_addns(z,addr,flaghaskey,pubkey);
1061 if (flagns) log_servflag(addr,flagns);
1062 }
1063 if (typematch(header,DNS_T_AAAA))
1064 if (byte_equal(header + 2,2,DNS_C_IN)) /* should always be true */
1065 if (datalen == 16) {
1066 if (!dns_packet_copy(buf,len,pos,misc,16)) goto DIE;
1067 flagns = cns_addns(z,misc,flaghaskey,pubkey);
1068 if (flagns) log_servflag(addr,flagns);
1069 }
1070 }
1071 pos += datalen;
1072 }
1073 goto LOWERLEVEL;
1074 }
1075
1076 if (!rqa(z)) goto DIE;
1077
1078 pos = posanswers;
1079 for (j = 0; j < numanswers; ++j) {
1080 pos = dns_packet_getname(buf,len,pos,&t1); if (!pos) goto DIE;
1081 pos = dns_packet_copy(buf,len,pos,header,10); if (!pos) goto DIE;
1082 ttl = ttlget(header + 4);
1083 uint16_unpack_big(header + 8,&datalen);
1084 if (dns_domain_equal(t1,d))
1085 if (byte_equal(header + 2,2,DNS_C_IN)) /* should always be true */
1086 if (typematch(header,dtype)) {
1087 if (!response_rstart(t1,header,ttl)) goto DIE;
1088
1089 if (typematch(header,DNS_T_NS) || typematch(header,DNS_T_CNAME) || typematch(header,DNS_T_PTR)) {
1090 if (!dns_packet_getname(buf,len,pos,&t2)) goto DIE;
1091 if (!response_addname(t2)) goto DIE;
1092 }
1093 else if (typematch(header,DNS_T_MX)) {
1094 pos2 = dns_packet_copy(buf,len,pos,misc,2); if (!pos2) goto DIE;
1095 if (!response_addbytes(misc,2)) goto DIE;
1096 if (!dns_packet_getname(buf,len,pos2,&t2)) goto DIE;
1097 if (!response_addname(t2)) goto DIE;
1098 }
1099 else if (typematch(header,DNS_T_SOA)) {
1100 pos2 = dns_packet_getname(buf,len,pos,&t2); if (!pos2) goto DIE;
1101 if (!response_addname(t2)) goto DIE;
1102 pos2 = dns_packet_getname(buf,len,pos2,&t3); if (!pos2) goto DIE;
1103 if (!response_addname(t3)) goto DIE;
1104 pos2 = dns_packet_copy(buf,len,pos2,misc,20); if (!pos2) goto DIE;
1105 if (!response_addbytes(misc,20)) goto DIE;
1106 }
1107 else {
1108 if (pos + datalen > len) goto DIE;
1109 if (!response_addbytes(buf + pos,datalen)) goto DIE;
1110 }
1111
1112 response_rfinish(RESPONSE_ANSWER);
1113 }
1114 pos += datalen;
1115 }
1116
1117 cleanup(z);
1118 return 1;
1119 }
1120
1121
1122 if (!dns_domain_suffix(d,referral)) goto DIE;
1123
1124 /* In strict "forwardonly" mode, we don't, as the manual states,
1125 ** contact a chain of servers according to "NS" resource records.
1126 ** We don't obey any referral responses, therefore. Instead, we
1127 ** eliminate the server from the list and try the next one. */
1128
1129 if (flagforwardonly) {
1130 log_ignore_referral(whichserver,control,referral);
1131 byte_zero(whichserver,16);
1132 goto HAVENS;
1133 }
1134
1135 control = d + dns_domain_suffixpos(d,referral);
1136 z->control[z->level] = control;
1137 z->byzg = numauthority*100 + numglue;
1138 z->flagnskeys[z->level] = 0; /* XXX */
1139 byte_zero(z->servers[z->level],QUERY_MAXIPLEN);
1140 for (j = 0; j < QUERY_MAXNS; ++j)
1141 dns_domain_free(&z->ns[z->level][j]);
1142 k = 0;
1143
1144 pos = posauthority;
1145 for (j = 0; j < numauthority; ++j) {
1146 pos = dns_packet_getname(buf,len,pos,&t1); if (!pos) goto DIE;
1147 pos = dns_packet_copy(buf,len,pos,header,10); if (!pos) goto DIE;
1148 uint16_unpack_big(header + 8,&datalen);
1149 if (dns_domain_equal(referral,t1)) /* should always be true */
1150 if (typematch(header,DNS_T_NS)) /* should always be true */
1151 if (byte_equal(header + 2,2,DNS_C_IN)) /* should always be true */
1152 if (k < QUERY_MAXNS)
1153 if (!dns_packet_getname(buf,len,pos,&z->ns[z->level][k++])) goto DIE;
1154 pos += datalen;
1155 }
1156
1157 goto HAVENS;
1158
1159
1160 SERVFAIL:
1161 if (z->level) goto LOWERLEVEL;
1162 if (!rqa(z)) goto DIE;
1163 response_servfail();
1164 cleanup(z);
1165 return 1;
1166
1167
1168 DIE:
1169 cleanup(z);
1170 if (records) { alloc_free(records); records = 0; }
1171 return DNS_ERR;
1172}
1173
1174int query_start(struct query *z,char *dn,char type[2],char class[2],char localip[16],uint32 scope_id)
1175{
1176 if (byte_equal(type,2,DNS_T_AXFR)) { errno = EPERM; return DNS_ERR; }
1177
1178 cleanup(z);
1179 z->level = 0;
1180 z->loop = 0;
1181
1182 if (!dns_domain_copy(&z->name[0],dn)) return DNS_ERR;
1183 byte_copy(z->type,2,type);
1184 byte_copy(z->class,2,class);
1185 byte_copy(z->localip,16,localip);
1186 z->scope_id = scope_id;
1187 z->ipv6[0] = 0;
1188
1189 return doit(z,0);
1190}
1191
1192int query_get(struct query *z,iopause_fd *x,struct taia *stamp)
1193{
1194 switch (dns_transmit_get(&z->dt,x,stamp)) {
1195 case 1:
1196 return doit(z,1);
1197 case -1: case -2: case -3:
1198 return doit(z,-1);
1199 }
1200 return 0;
1201}
1202
1203void query_io(struct query *z,iopause_fd *x,struct taia *deadline)
1204{
1205 dns_transmit_io(&z->dt,x,deadline);
1206}
doit
unsigned int doit(char *buf, unsigned int len, unsigned int pos)
Definition: axfr-get.c:131
data
char data[32767]
Definition: axfrdns.c:130
ip
char ip[16]
Definition: axfrdns.c:125
len
uint16 len
Definition: axfrdns.c:319
buf
char buf[MSGSIZE]
Definition: axfrdns.c:318
dlen
uint32 dlen
Definition: axfrdns.c:131
crypto_box_beforenm
#define crypto_box_beforenm
Definition: curve.h:12
crypto_scalarmult_base
#define crypto_scalarmult_base
Definition: curve.h:10
cns_transmit_start
int cns_transmit_start(struct dns_transmit *d, const char servers[QUERY_MAXIPLEN], int flagrecursive, const char *q, const char qtype[2], const char localip[16], const char keys[1024], const char pubkey[32], const char *suffix)
Definition: curvedns.c:246
cns_sortns
void cns_sortns(char *s, char *t, unsigned int n)
Definition: curvedns.c:192
cns_pubkey
int cns_pubkey(const char *dn, char key[32])
Definition: curvedns.c:178
cns_addns
int cns_addns(struct query *z, const char *addr, int flagnskey, const char *key)
Definition: curvedns.c:212
dd4
int dd4(const char *q, const char *base, char ip[4])
Definition: dd.c:7
DNS_ERR
#define DNS_ERR
Definition: dns.h:32
DNS_T_A
#define DNS_T_A
Definition: dns.h:56
QUERY_MAXIPLEN
#define QUERY_MAXIPLEN
Definition: dns.h:45
DNS_T_AXFR
#define DNS_T_AXFR
Definition: dns.h:84
DNS_C_IN
#define DNS_C_IN
Definition: dns.h:53
DNS_T_ANY
#define DNS_T_ANY
Definition: dns.h:85
MAX_TTL
#define MAX_TTL
Definition: dns.h:42
DNS_T_PTR
#define DNS_T_PTR
Definition: dns.h:60
DNS_T_SOA
#define DNS_T_SOA
Definition: dns.h:59
DNS_T_NS
#define DNS_T_NS
Definition: dns.h:57
QUERY_MAXNS
#define QUERY_MAXNS
Definition: dns.h:44
DNS_T_CNAME
#define DNS_T_CNAME
Definition: dns.h:58
DNS_T_AAAA
#define DNS_T_AAAA
Definition: dns.h:67
DNS_T_MX
#define DNS_T_MX
Definition: dns.h:62
dns_domain_equal
int dns_domain_equal(const char *dn1, const char *dn2)
Definition: dns_domain.c:39
dns_domain_length
unsigned int dns_domain_length(const char *dn)
Definition: dns_domain.c:6
dns_domain_copy
int dns_domain_copy(char **out, const char *in)
Definition: dns_domain.c:25
dns_domain_suffix
int dns_domain_suffix(const char *big, const char *little)
Definition: dns_domain.c:50
dns_domain_free
void dns_domain_free(char **out)
Definition: dns_domain.c:17
dns_domain_suffixpos
unsigned int dns_domain_suffixpos(const char *big, const char *little)
Definition: dns_domain.c:62
dns_packet_getname
unsigned int dns_packet_getname(const char *buf, unsigned int len, unsigned int pos, char **d)
Definition: dns_packet.c:35
dns_packet_copy
unsigned int dns_packet_copy(const char *buf, unsigned int len, unsigned int pos, char *out, unsigned int outlen)
Definition: dns_packet.c:8
dns_packet_skipname
unsigned int dns_packet_skipname(const char *buf, unsigned int len, unsigned int pos)
Definition: dns_packet.c:18
dns_random
unsigned int dns_random(unsigned int n)
Definition: dns_random.c:56
dns_transmit_io
void dns_transmit_io(struct dns_transmit *d, iopause_fd *x, struct taia *deadline)
Definition: dns_transmit.c:279
dns_transmit_free
void dns_transmit_free(struct dns_transmit *d)
Definition: dns_transmit.c:95
dns_transmit_get
int dns_transmit_get(struct dns_transmit *d, const iopause_fd *x, const struct taia *when)
Definition: dns_transmit.c:296
p
char * p
Definition: dnscache.c:37
x
struct line * x
type
char type[2]
Definition: dnsq.c:56
d
void d(const char *home, const char *subdir, int uid, int gid, int mode)
z
void z(char *home, char *subdir, char *file, int len, int uid, int gid, int mode)
Definition: install.c:103
log_nxdomain
void log_nxdomain(const char *, const char *, unsigned int)
log_rrptr
void log_rrptr(const char *, const char *, const char *, unsigned int)
log_ignore_referral
void log_ignore_referral(const char *, const char *, const char *)
log_cachedanswer
void log_cachedanswer(const char *, const char *)
log_rrns
void log_rrns(const char *, const char *, const char *, unsigned int)
log_lame
void log_lame(const char *, const char *, const char *)
log_rr
void log_rr(const char *, const char *, const char *, const char *, unsigned int, unsigned int)
log_servfail
void log_servfail(const char *)
Definition: log.c:237
log_nodata
void log_nodata(const char *, const char *, const char *, unsigned int)
log_rrsoa
void log_rrsoa(const char *, const char *, const char *, const char *, const char *, unsigned int)
log_stats
void log_stats(void)
Definition: log.c:312
log_rrcname
void log_rrcname(const char *, const char *, const char *, unsigned int)
log_rrmx
void log_rrmx(const char *, const char *, const char *, const char *, unsigned int)
log_servflag
void log_servflag(const char *, int)
log_cachedcname
void log_cachedcname(const char *, const char *)
Definition: log.c:188
log_cachednxdomain
void log_cachednxdomain(const char *)
Definition: log.c:200
log_cachedns
void log_cachedns(const char *, const char *)
Definition: log.c:194
log_tx
void log_tx(const char *, const char *, const char *, const char *, int, unsigned int)
LABLEN
#define LABLEN
Definition: query.c:16
query_init
void query_init(void)
Definition: query.c:23
query_io
void query_io(struct query *z, iopause_fd *x, struct taia *deadline)
Definition: query.c:1203
query_get
int query_get(struct query *z, iopause_fd *x, struct taia *stamp)
Definition: query.c:1192
flagusetxtformat
int flagusetxtformat
Definition: dnscache.c:34
query_forwardonly
void query_forwardonly(void)
Definition: query.c:36
query_start
int query_start(struct query *z, char *dn, char type[2], char class[2], char localip[16], uint32 scope_id)
Definition: query.c:1174
QUERY_MAXALIAS
#define QUERY_MAXALIAS
Definition: query.h:10
IP6_LOOPBACK_OCTAL
#define IP6_LOOPBACK_OCTAL
Definition: query.h:29
IP6_ALLROUTERS_OCTAL
#define IP6_ALLROUTERS_OCTAL
Definition: query.h:37
IP6_MULTICASTPFX_OCTAL
#define IP6_MULTICASTPFX_OCTAL
Definition: query.h:33
IP6_MULTICAST_ARPA
#define IP6_MULTICAST_ARPA
Definition: query.h:22
QUERY_MAXLEVEL
#define QUERY_MAXLEVEL
Definition: query.h:9
IP6_ALLNODESMULTICAST_ARPA
#define IP6_ALLNODESMULTICAST_ARPA
Definition: query.h:24
QUERY_MAXLOOP
#define QUERY_MAXLOOP
Definition: query.h:11
IP4_LOOPBACK_ARPA
#define IP4_LOOPBACK_ARPA
Definition: query.h:42
IP4_LOCALHOST_ARPA
#define IP4_LOCALHOST_ARPA
Definition: query.h:40
IP6_LOCALHOST_ARPA
#define IP6_LOCALHOST_ARPA
Definition: query.h:54
IP6_LOOPBACK_ARPA
#define IP6_LOOPBACK_ARPA
Definition: query.h:18
IP6_LOCALNET
#define IP6_LOCALNET
Definition: query.h:52
IP4_LOOPBACK_OCTAL
#define IP4_LOOPBACK_OCTAL
Definition: query.h:45
IP6_ALLROUTERSMULTICAST_ARPA
#define IP6_ALLROUTERSMULTICAST_ARPA
Definition: query.h:26
IP6_LOCALNET_ARPA
#define IP6_LOCALNET_ARPA
Definition: query.h:20
IP4_LOCALNET
#define IP4_LOCALNET
Definition: query.h:51
IP6_ALLNODES_OCTAL
#define IP6_ALLNODES_OCTAL
Definition: query.h:35
response_addname
int response_addname(const char *)
Definition: response.c:25
response_rfinish
void response_rfinish(int)
Definition: response.c:89
response_addbytes
int response_addbytes(const char *, unsigned int)
Definition: response.c:17
response_cname
int response_cname(const char *, const char *, uint32)
Definition: response.c:95
response_rstart
int response_rstart(const char *, const char *, uint32)
response_query
int response_query(const char *, const char *, const char *)
RESPONSE_ANSWER
#define RESPONSE_ANSWER
Definition: response.h:23
response_nxdomain
void response_nxdomain(void)
Definition: response.c:103
response_servfail
void response_servfail(void)
Definition: response.c:109
roots
int roots(char *, char *)
roots_same
int roots_same(char *, char *)
Definition: roots.c:57
cache_get
char * cache_get(const char *, unsigned int, unsigned int *, uint32 *)
Definition: sipcache.c:73
cache_set
void cache_set(const char *, unsigned int, const char *, unsigned int, uint32)
Definition: sipcache.c:119
query
Definition: query.h:56
Generated on Fri Aug 30 2024 11:58:34 for djbdnscurve6 by doxygen 1.9.6