?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
rc.conf: Add and document the missing root_rw_mount=YES
[dragonfly.git] / contrib / ldns / packet.c
blobafa59005c3bda65e35a0d521327d648d427f5c16
1 /*
2 * packet.c
3 *
4 * dns packet implementation
5 *
6 * a Net::DNS like library for C
7 *
8 * (c) NLnet Labs, 2004-2006
9 *
10 * See the file LICENSE for the license
11 */
12
13 #include <ldns/config.h>
14
15 #include <ldns/ldns.h>
16
17 #include <strings.h>
18 #include <limits.h>
19
20 #ifdef HAVE_SSL
21 #include <openssl/rand.h>
22 #endif
23
24 /* Access functions
25 * do this as functions to get type checking
26 */
27
28 #define LDNS_EDNS_MASK_DO_BIT 0x8000
29 #define LDNS_EDNS_MASK_UNASSIGNED (0xFFFF & ~LDNS_EDNS_MASK_DO_BIT)
30
31 /* TODO defines for 3600 */
32 /* convert to and from numerical flag values */
33 ldns_lookup_table ldns_edns_flags[] = {
34 { 3600, "do"},
35 { 0, NULL}
36 };
37
38 /* read */
39 uint16_t
40 ldns_pkt_id(const ldns_pkt *packet)
41 {
42 return packet->_header->_id;
43 }
44
45 bool
46 ldns_pkt_qr(const ldns_pkt *packet)
47 {
48 return packet->_header->_qr;
49 }
50
51 bool
52 ldns_pkt_aa(const ldns_pkt *packet)
53 {
54 return packet->_header->_aa;
55 }
56
57 bool
58 ldns_pkt_tc(const ldns_pkt *packet)
59 {
60 return packet->_header->_tc;
61 }
62
63 bool
64 ldns_pkt_rd(const ldns_pkt *packet)
65 {
66 return packet->_header->_rd;
67 }
68
69 bool
70 ldns_pkt_cd(const ldns_pkt *packet)
71 {
72 return packet->_header->_cd;
73 }
74
75 bool
76 ldns_pkt_ra(const ldns_pkt *packet)
77 {
78 return packet->_header->_ra;
79 }
80
81 bool
82 ldns_pkt_ad(const ldns_pkt *packet)
83 {
84 return packet->_header->_ad;
85 }
86
87 ldns_pkt_opcode
88 ldns_pkt_get_opcode(const ldns_pkt *packet)
89 {
90 return packet->_header->_opcode;
91 }
92
93 ldns_pkt_rcode
94 ldns_pkt_get_rcode(const ldns_pkt *packet)
95 {
96 return packet->_header->_rcode;
97 }
98
99 uint16_t
100 ldns_pkt_qdcount(const ldns_pkt *packet)
101 {
102 return packet->_header->_qdcount;
103 }
104
105 uint16_t
106 ldns_pkt_ancount(const ldns_pkt *packet)
107 {
108 return packet->_header->_ancount;
109 }
110
111 uint16_t
112 ldns_pkt_nscount(const ldns_pkt *packet)
113 {
114 return packet->_header->_nscount;
115 }
116
117 uint16_t
118 ldns_pkt_arcount(const ldns_pkt *packet)
119 {
120 return packet->_header->_arcount;
121 }
122
123 ldns_rr_list *
124 ldns_pkt_question(const ldns_pkt *packet)
125 {
126 return packet->_question;
127 }
128
129 ldns_rr_list *
130 ldns_pkt_answer(const ldns_pkt *packet)
131 {
132 return packet->_answer;
133 }
134
135 ldns_rr_list *
136 ldns_pkt_authority(const ldns_pkt *packet)
137 {
138 return packet->_authority;
139 }
140
141 ldns_rr_list *
142 ldns_pkt_additional(const ldns_pkt *packet)
143 {
144 return packet->_additional;
145 }
146
147 /* return ALL section concatenated */
148 ldns_rr_list *
149 ldns_pkt_all(const ldns_pkt *packet)
150 {
151 ldns_rr_list *all, *prev_all;
152
153 all = ldns_rr_list_cat_clone(
154 ldns_pkt_question(packet),
155 ldns_pkt_answer(packet));
156 prev_all = all;
157 all = ldns_rr_list_cat_clone(all,
158 ldns_pkt_authority(packet));
159 ldns_rr_list_deep_free(prev_all);
160 prev_all = all;
161 all = ldns_rr_list_cat_clone(all,
162 ldns_pkt_additional(packet));
163 ldns_rr_list_deep_free(prev_all);
164 return all;
165 }
166
167 ldns_rr_list *
168 ldns_pkt_all_noquestion(const ldns_pkt *packet)
169 {
170 ldns_rr_list *all, *all2;
171
172 all = ldns_rr_list_cat_clone(
173 ldns_pkt_answer(packet),
174 ldns_pkt_authority(packet));
175 all2 = ldns_rr_list_cat_clone(all,
176 ldns_pkt_additional(packet));
177
178 ldns_rr_list_deep_free(all);
179 return all2;
180 }
181
182 size_t
183 ldns_pkt_size(const ldns_pkt *packet)
184 {
185 return packet->_size;
186 }
187
188 uint32_t
189 ldns_pkt_querytime(const ldns_pkt *packet)
190 {
191 return packet->_querytime;
192 }
193
194 ldns_rdf *
195 ldns_pkt_answerfrom(const ldns_pkt *packet)
196 {
197 return packet->_answerfrom;
198 }
199
200 struct timeval
201 ldns_pkt_timestamp(const ldns_pkt *packet)
202 {
203 return packet->timestamp;
204 }
205
206 uint16_t
207 ldns_pkt_edns_udp_size(const ldns_pkt *packet)
208 {
209 return packet->_edns_udp_size;
210 }
211
212 uint8_t
213 ldns_pkt_edns_extended_rcode(const ldns_pkt *packet)
214 {
215 return packet->_edns_extended_rcode;
216 }
217
218 uint8_t
219 ldns_pkt_edns_version(const ldns_pkt *packet)
220 {
221 return packet->_edns_version;
222 }
223
224 uint16_t
225 ldns_pkt_edns_z(const ldns_pkt *packet)
226 {
227 return packet->_edns_z;
228 }
229
230 bool
231 ldns_pkt_edns_do(const ldns_pkt *packet)
232 {
233 return (packet->_edns_z & LDNS_EDNS_MASK_DO_BIT);
234 }
235
236 void
237 ldns_pkt_set_edns_do(ldns_pkt *packet, bool value)
238 {
239 if (value) {
240 packet->_edns_z = packet->_edns_z | LDNS_EDNS_MASK_DO_BIT;
241 } else {
242 packet->_edns_z = packet->_edns_z & ~LDNS_EDNS_MASK_DO_BIT;
243 }
244 }
245
246 uint16_t
247 ldns_pkt_edns_unassigned(const ldns_pkt *packet)
248 {
249 return (packet->_edns_z & LDNS_EDNS_MASK_UNASSIGNED);
250 }
251
252 void
253 ldns_pkt_set_edns_unassigned(ldns_pkt *packet, uint16_t value)
254 {
255 packet->_edns_z = (packet->_edns_z & ~LDNS_EDNS_MASK_UNASSIGNED)
256 | (value & LDNS_EDNS_MASK_UNASSIGNED);
257 }
258
259 ldns_rdf *
260 ldns_pkt_edns_data(const ldns_pkt *packet)
261 {
262 return packet->_edns_data;
263 }
264
265 /* return only those rr that share the ownername */
266 ldns_rr_list *
267 ldns_pkt_rr_list_by_name(const ldns_pkt *packet,
268 const ldns_rdf *ownername,
269 ldns_pkt_section sec)
270 {
271 ldns_rr_list *rrs;
272 ldns_rr_list *ret;
273 uint16_t i;
274
275 if (!packet) {
276 return NULL;
277 }
278
279 rrs = ldns_pkt_get_section_clone(packet, sec);
280 ret = NULL;
281
282 for(i = 0; i < ldns_rr_list_rr_count(rrs); i++) {
283 if (ldns_dname_compare(ldns_rr_owner(
284 ldns_rr_list_rr(rrs, i)),
285 ownername) == 0) {
286 /* owner names match */
287 if (ret == NULL) {
288 ret = ldns_rr_list_new();
289 }
290 ldns_rr_list_push_rr(ret,
291 ldns_rr_clone(
292 ldns_rr_list_rr(rrs, i))
293 );
294 }
295 }
296
297 ldns_rr_list_deep_free(rrs);
298
299 return ret;
300 }
301
302 /* return only those rr that share a type */
303 ldns_rr_list *
304 ldns_pkt_rr_list_by_type(const ldns_pkt *packet,
305 ldns_rr_type type,
306 ldns_pkt_section sec)
307 {
308 ldns_rr_list *rrs;
309 ldns_rr_list *new;
310 uint16_t i;
311
312 if(!packet) {
313 return NULL;
314 }
315
316 rrs = ldns_pkt_get_section_clone(packet, sec);
317 new = ldns_rr_list_new();
318
319 for(i = 0; i < ldns_rr_list_rr_count(rrs); i++) {
320 if (type == ldns_rr_get_type(ldns_rr_list_rr(rrs, i))) {
321 /* types match */
322 ldns_rr_list_push_rr(new,
323 ldns_rr_clone(
324 ldns_rr_list_rr(rrs, i))
325 );
326 }
327 }
328 ldns_rr_list_deep_free(rrs);
329
330 if (ldns_rr_list_rr_count(new) == 0) {
331 ldns_rr_list_free(new);
332 return NULL;
333 } else {
334 return new;
335 }
336 }
337
338 /* return only those rrs that share name and type */
339 ldns_rr_list *
340 ldns_pkt_rr_list_by_name_and_type(const ldns_pkt *packet,
341 const ldns_rdf *ownername,
342 ldns_rr_type type,
343 ldns_pkt_section sec)
344 {
345 ldns_rr_list *rrs;
346 ldns_rr_list *new;
347 ldns_rr_list *ret;
348 uint16_t i;
349
350 if(!packet) {
351 return NULL;
352 }
353
354 rrs = ldns_pkt_get_section_clone(packet, sec);
355 new = ldns_rr_list_new();
356 ret = NULL;
357
358 for(i = 0; i < ldns_rr_list_rr_count(rrs); i++) {
359 if (type == ldns_rr_get_type(ldns_rr_list_rr(rrs, i)) &&
360 ldns_dname_compare(ldns_rr_owner(ldns_rr_list_rr(rrs, i)),
361 ownername
362 ) == 0
363 ) {
364 /* types match */
365 ldns_rr_list_push_rr(new, ldns_rr_clone(ldns_rr_list_rr(rrs, i)));
366 ret = new;
367 }
368 }
369 ldns_rr_list_deep_free(rrs);
370 if (!ret) {
371 ldns_rr_list_free(new);
372 }
373 return ret;
374 }
375
376 bool
377 ldns_pkt_rr(const ldns_pkt *pkt, ldns_pkt_section sec, const ldns_rr *rr)
378 {
379 bool result = false;
380
381 switch (sec) {
382 case LDNS_SECTION_QUESTION:
383 return ldns_rr_list_contains_rr(ldns_pkt_question(pkt), rr);
384 case LDNS_SECTION_ANSWER:
385 return ldns_rr_list_contains_rr(ldns_pkt_answer(pkt), rr);
386 case LDNS_SECTION_AUTHORITY:
387 return ldns_rr_list_contains_rr(ldns_pkt_authority(pkt), rr);
388 case LDNS_SECTION_ADDITIONAL:
389 return ldns_rr_list_contains_rr(ldns_pkt_additional(pkt), rr);
390 case LDNS_SECTION_ANY:
391 result = ldns_rr_list_contains_rr(ldns_pkt_question(pkt), rr);
392 /* fallthrough */
393 case LDNS_SECTION_ANY_NOQUESTION:
394 result = result
395 || ldns_rr_list_contains_rr(ldns_pkt_answer(pkt), rr)
396 || ldns_rr_list_contains_rr(ldns_pkt_authority(pkt), rr)
397 || ldns_rr_list_contains_rr(ldns_pkt_additional(pkt), rr);
398 }
399
400 return result;
401 }
402
403 uint16_t
404 ldns_pkt_section_count(const ldns_pkt *packet, ldns_pkt_section s)
405 {
406 switch(s) {
407 case LDNS_SECTION_QUESTION:
408 return ldns_pkt_qdcount(packet);
409 case LDNS_SECTION_ANSWER:
410 return ldns_pkt_ancount(packet);
411 case LDNS_SECTION_AUTHORITY:
412 return ldns_pkt_nscount(packet);
413 case LDNS_SECTION_ADDITIONAL:
414 return ldns_pkt_arcount(packet);
415 case LDNS_SECTION_ANY:
416 return ldns_pkt_qdcount(packet) +
417 ldns_pkt_ancount(packet) +
418 ldns_pkt_nscount(packet) +
419 ldns_pkt_arcount(packet);
420 case LDNS_SECTION_ANY_NOQUESTION:
421 return ldns_pkt_ancount(packet) +
422 ldns_pkt_nscount(packet) +
423 ldns_pkt_arcount(packet);
424 default:
425 return 0;
426 }
427 }
428
429 bool
430 ldns_pkt_empty(ldns_pkt *p)
431 {
432 if (!p) {
433 return true; /* NULL is empty? */
434 }
435 if (ldns_pkt_section_count(p, LDNS_SECTION_ANY) > 0) {
436 return false;
437 } else {
438 return true;
439 }
440 }
441
442
443 ldns_rr_list *
444 ldns_pkt_get_section_clone(const ldns_pkt *packet, ldns_pkt_section s)
445 {
446 switch(s) {
447 case LDNS_SECTION_QUESTION:
448 return ldns_rr_list_clone(ldns_pkt_question(packet));
449 case LDNS_SECTION_ANSWER:
450 return ldns_rr_list_clone(ldns_pkt_answer(packet));
451 case LDNS_SECTION_AUTHORITY:
452 return ldns_rr_list_clone(ldns_pkt_authority(packet));
453 case LDNS_SECTION_ADDITIONAL:
454 return ldns_rr_list_clone(ldns_pkt_additional(packet));
455 case LDNS_SECTION_ANY:
456 /* these are already clones */
457 return ldns_pkt_all(packet);
458 case LDNS_SECTION_ANY_NOQUESTION:
459 return ldns_pkt_all_noquestion(packet);
460 default:
461 return NULL;
462 }
463 }
464
465 ldns_rr *ldns_pkt_tsig(const ldns_pkt *pkt) {
466 return pkt->_tsig_rr;
467 }
468
469 /* write */
470 void
471 ldns_pkt_set_id(ldns_pkt *packet, uint16_t id)
472 {
473 packet->_header->_id = id;
474 }
475
476 void
477 ldns_pkt_set_random_id(ldns_pkt *packet)
478 {
479 uint16_t rid = ldns_get_random();
480 ldns_pkt_set_id(packet, rid);
481 }
482
483
484 void
485 ldns_pkt_set_qr(ldns_pkt *packet, bool qr)
486 {
487 packet->_header->_qr = qr;
488 }
489
490 void
491 ldns_pkt_set_aa(ldns_pkt *packet, bool aa)
492 {
493 packet->_header->_aa = aa;
494 }
495
496 void
497 ldns_pkt_set_tc(ldns_pkt *packet, bool tc)
498 {
499 packet->_header->_tc = tc;
500 }
501
502 void
503 ldns_pkt_set_rd(ldns_pkt *packet, bool rd)
504 {
505 packet->_header->_rd = rd;
506 }
507
508 void
509 ldns_pkt_set_additional(ldns_pkt *p, ldns_rr_list *rr)
510 {
511 p->_additional = rr;
512 }
513
514 void
515 ldns_pkt_set_question(ldns_pkt *p, ldns_rr_list *rr)
516 {
517 p->_question = rr;
518 }
519
520 void
521 ldns_pkt_set_answer(ldns_pkt *p, ldns_rr_list *rr)
522 {
523 p->_answer = rr;
524 }
525
526 void
527 ldns_pkt_set_authority(ldns_pkt *p, ldns_rr_list *rr)
528 {
529 p->_authority = rr;
530 }
531
532 void
533 ldns_pkt_set_cd(ldns_pkt *packet, bool cd)
534 {
535 packet->_header->_cd = cd;
536 }
537
538 void
539 ldns_pkt_set_ra(ldns_pkt *packet, bool ra)
540 {
541 packet->_header->_ra = ra;
542 }
543
544 void
545 ldns_pkt_set_ad(ldns_pkt *packet, bool ad)
546 {
547 packet->_header->_ad = ad;
548 }
549
550 void
551 ldns_pkt_set_opcode(ldns_pkt *packet, ldns_pkt_opcode opcode)
552 {
553 packet->_header->_opcode = opcode;
554 }
555
556 void
557 ldns_pkt_set_rcode(ldns_pkt *packet, uint8_t rcode)
558 {
559 packet->_header->_rcode = rcode;
560 }
561
562 void
563 ldns_pkt_set_qdcount(ldns_pkt *packet, uint16_t qdcount)
564 {
565 packet->_header->_qdcount = qdcount;
566 }
567
568 void
569 ldns_pkt_set_ancount(ldns_pkt *packet, uint16_t ancount)
570 {
571 packet->_header->_ancount = ancount;
572 }
573
574 void
575 ldns_pkt_set_nscount(ldns_pkt *packet, uint16_t nscount)
576 {
577 packet->_header->_nscount = nscount;
578 }
579
580 void
581 ldns_pkt_set_arcount(ldns_pkt *packet, uint16_t arcount)
582 {
583 packet->_header->_arcount = arcount;
584 }
585
586 void
587 ldns_pkt_set_querytime(ldns_pkt *packet, uint32_t time)
588 {
589 packet->_querytime = time;
590 }
591
592 void
593 ldns_pkt_set_answerfrom(ldns_pkt *packet, ldns_rdf *answerfrom)
594 {
595 packet->_answerfrom = answerfrom;
596 }
597
598 void
599 ldns_pkt_set_timestamp(ldns_pkt *packet, struct timeval timeval)
600 {
601 packet->timestamp.tv_sec = timeval.tv_sec;
602 packet->timestamp.tv_usec = timeval.tv_usec;
603 }
604
605 void
606 ldns_pkt_set_size(ldns_pkt *packet, size_t s)
607 {
608 packet->_size = s;
609 }
610
611 void
612 ldns_pkt_set_edns_udp_size(ldns_pkt *packet, uint16_t s)
613 {
614 packet->_edns_udp_size = s;
615 }
616
617 void
618 ldns_pkt_set_edns_extended_rcode(ldns_pkt *packet, uint8_t c)
619 {
620 packet->_edns_extended_rcode = c;
621 }
622
623 void
624 ldns_pkt_set_edns_version(ldns_pkt *packet, uint8_t v)
625 {
626 packet->_edns_version = v;
627 }
628
629 void
630 ldns_pkt_set_edns_z(ldns_pkt *packet, uint16_t z)
631 {
632 packet->_edns_z = z;
633 }
634
635 void
636 ldns_pkt_set_edns_data(ldns_pkt *packet, ldns_rdf *data)
637 {
638 packet->_edns_data = data;
639 }
640
641 void
642 ldns_pkt_set_edns_option_list(ldns_pkt *packet, ldns_edns_option_list *list)
643 {
644 if (packet->_edns_list)
645 ldns_edns_option_list_deep_free(packet->_edns_list);
646 packet->_edns_list = list;
647 }
648
649
650 void
651 ldns_pkt_set_section_count(ldns_pkt *packet, ldns_pkt_section s, uint16_t count)
652 {
653 switch(s) {
654 case LDNS_SECTION_QUESTION:
655 ldns_pkt_set_qdcount(packet, count);
656 break;
657 case LDNS_SECTION_ANSWER:
658 ldns_pkt_set_ancount(packet, count);
659 break;
660 case LDNS_SECTION_AUTHORITY:
661 ldns_pkt_set_nscount(packet, count);
662 break;
663 case LDNS_SECTION_ADDITIONAL:
664 ldns_pkt_set_arcount(packet, count);
665 break;
666 case LDNS_SECTION_ANY:
667 case LDNS_SECTION_ANY_NOQUESTION:
668 break;
669 }
670 }
671
672 void ldns_pkt_set_tsig(ldns_pkt *pkt, ldns_rr *rr)
673 {
674 pkt->_tsig_rr = rr;
675 }
676
677 bool
678 ldns_pkt_push_rr(ldns_pkt *packet, ldns_pkt_section section, ldns_rr *rr)
679 {
680 switch(section) {
681 case LDNS_SECTION_QUESTION:
682 if (!ldns_rr_list_push_rr(ldns_pkt_question(packet), rr)) {
683 return false;
684 }
685 ldns_pkt_set_qdcount(packet, ldns_pkt_qdcount(packet) + 1);
686 break;
687 case LDNS_SECTION_ANSWER:
688 if (!ldns_rr_list_push_rr(ldns_pkt_answer(packet), rr)) {
689 return false;
690 }
691 ldns_pkt_set_ancount(packet, ldns_pkt_ancount(packet) + 1);
692 break;
693 case LDNS_SECTION_AUTHORITY:
694 if (!ldns_rr_list_push_rr(ldns_pkt_authority(packet), rr)) {
695 return false;
696 }
697 ldns_pkt_set_nscount(packet, ldns_pkt_nscount(packet) + 1);
698 break;
699 case LDNS_SECTION_ADDITIONAL:
700 if (!ldns_rr_list_push_rr(ldns_pkt_additional(packet), rr)) {
701 return false;
702 }
703 ldns_pkt_set_arcount(packet, ldns_pkt_arcount(packet) + 1);
704 break;
705 case LDNS_SECTION_ANY:
706 case LDNS_SECTION_ANY_NOQUESTION:
707 /* shouldn't this error? */
708 break;
709 }
710 return true;
711 }
712
713 bool
714 ldns_pkt_safe_push_rr(ldns_pkt *pkt, ldns_pkt_section sec, ldns_rr *rr)
715 {
716
717 /* check to see if its there */
718 if (ldns_pkt_rr(pkt, sec, rr)) {
719 /* already there */
720 return false;
721 }
722 return ldns_pkt_push_rr(pkt, sec, rr);
723 }
724
725 bool
726 ldns_pkt_push_rr_list(ldns_pkt *p, ldns_pkt_section s, ldns_rr_list *list)
727 {
728 size_t i;
729 for(i = 0; i < ldns_rr_list_rr_count(list); i++) {
730 if (!ldns_pkt_push_rr(p, s, ldns_rr_list_rr(list, i))) {
731 return false;
732 }
733 }
734 return true;
735 }
736
737 bool
738 ldns_pkt_safe_push_rr_list(ldns_pkt *p, ldns_pkt_section s, ldns_rr_list *list)
739 {
740 size_t i;
741 for(i = 0; i < ldns_rr_list_rr_count(list); i++) {
742 if (!ldns_pkt_safe_push_rr(p, s, ldns_rr_list_rr(list, i))) {
743 return false;
744 }
745 }
746 return true;
747 }
748
749 bool
750 ldns_pkt_edns(const ldns_pkt *pkt)
751 {
752 return (ldns_pkt_edns_udp_size(pkt) > 0 ||
753 ldns_pkt_edns_extended_rcode(pkt) > 0 ||
754 ldns_pkt_edns_data(pkt) ||
755 ldns_pkt_edns_do(pkt) ||
756 pkt->_edns_list ||
757 pkt->_edns_present
758 );
759 }
760
761 ldns_edns_option_list*
762 pkt_edns_data2edns_option_list(const ldns_rdf *edns_data)
763 {
764 size_t pos = 0;
765 ldns_edns_option_list* edns_list;
766 size_t max;
767 const uint8_t* wire;
768
769 if (!edns_data)
770 return NULL;
771
772 max = ldns_rdf_size(edns_data);
773 wire = ldns_rdf_data(edns_data);
774 if (!max)
775 return NULL;
776
777 if (!(edns_list = ldns_edns_option_list_new()))
778 return NULL;
779
780 while (pos < max) {
781 ldns_edns_option* edns;
782 uint8_t *data;
783
784 if (pos + 4 > max) { /* make sure the header is */
785 ldns_edns_option_list_deep_free(edns_list);
786 return NULL;
787 }
788 ldns_edns_option_code code = ldns_read_uint16(&wire[pos]);
789 size_t size = ldns_read_uint16(&wire[pos+2]);
790 pos += 4;
791
792 if (pos + size > max) { /* make sure the size fits the data */
793 ldns_edns_option_list_deep_free(edns_list);
794 return NULL;
795 }
796 data = LDNS_XMALLOC(uint8_t, size);
797
798 if (!data) {
799 ldns_edns_option_list_deep_free(edns_list);
800 return NULL;
801 }
802 memcpy(data, &wire[pos], size);
803 pos += size;
804
805 edns = ldns_edns_new(code, size, data);
806
807 if (!edns) {
808 ldns_edns_option_list_deep_free(edns_list);
809 return NULL;
810 }
811 if (!ldns_edns_option_list_push(edns_list, edns)) {
812 ldns_edns_option_list_deep_free(edns_list);
813 return NULL;
814 }
815 }
816 return edns_list;
817
818 }
819
820 ldns_edns_option_list*
821 ldns_pkt_edns_get_option_list(ldns_pkt *packet)
822 {
823 /* return the list if it already exists */
824 if (packet->_edns_list != NULL)
825 return packet->_edns_list;
826
827 /* if the list doesn't exists, we create it by parsing the
828 * packet->_edns_data
829 */
830 if (!ldns_pkt_edns_data(packet))
831 return NULL;
832
833 return ( packet->_edns_list
834 = pkt_edns_data2edns_option_list(ldns_pkt_edns_data(packet)));
835 }
836
837
838 /* Create/destroy/convert functions
839 */
840 ldns_pkt *
841 ldns_pkt_new(void)
842 {
843 ldns_pkt *packet;
844 packet = LDNS_MALLOC(ldns_pkt);
845 if (!packet) {
846 return NULL;
847 }
848
849 packet->_header = LDNS_MALLOC(ldns_hdr);
850 if (!packet->_header) {
851 LDNS_FREE(packet);
852 return NULL;
853 }
854
855 packet->_question = ldns_rr_list_new();
856 packet->_answer = ldns_rr_list_new();
857 packet->_authority = ldns_rr_list_new();
858 packet->_additional = ldns_rr_list_new();
859
860 /* default everything to false */
861 ldns_pkt_set_qr(packet, false);
862 ldns_pkt_set_aa(packet, false);
863 ldns_pkt_set_tc(packet, false);
864 ldns_pkt_set_rd(packet, false);
865 ldns_pkt_set_ra(packet, false);
866 ldns_pkt_set_ad(packet, false);
867 ldns_pkt_set_cd(packet, false);
868
869 ldns_pkt_set_opcode(packet, LDNS_PACKET_QUERY);
870 ldns_pkt_set_rcode(packet, 0);
871 ldns_pkt_set_id(packet, 0);
872 ldns_pkt_set_size(packet, 0);
873 ldns_pkt_set_querytime(packet, 0);
874 memset(&packet->timestamp, 0, sizeof(packet->timestamp));
875 ldns_pkt_set_answerfrom(packet, NULL);
876 ldns_pkt_set_section_count(packet, LDNS_SECTION_QUESTION, 0);
877 ldns_pkt_set_section_count(packet, LDNS_SECTION_ANSWER, 0);
878 ldns_pkt_set_section_count(packet, LDNS_SECTION_AUTHORITY, 0);
879 ldns_pkt_set_section_count(packet, LDNS_SECTION_ADDITIONAL, 0);
880
881 ldns_pkt_set_edns_udp_size(packet, 0);
882 ldns_pkt_set_edns_extended_rcode(packet, 0);
883 ldns_pkt_set_edns_version(packet, 0);
884 ldns_pkt_set_edns_z(packet, 0);
885 ldns_pkt_set_edns_data(packet, NULL);
886 packet->_edns_list = NULL;
887 packet->_edns_present = false;
888
889 ldns_pkt_set_tsig(packet, NULL);
890
891 return packet;
892 }
893
894 void
895 ldns_pkt_free(ldns_pkt *packet)
896 {
897 if (packet) {
898 LDNS_FREE(packet->_header);
899 ldns_rr_list_deep_free(packet->_question);
900 ldns_rr_list_deep_free(packet->_answer);
901 ldns_rr_list_deep_free(packet->_authority);
902 ldns_rr_list_deep_free(packet->_additional);
903 ldns_rr_free(packet->_tsig_rr);
904 ldns_rdf_deep_free(packet->_edns_data);
905 ldns_edns_option_list_deep_free(packet->_edns_list);
906 ldns_rdf_deep_free(packet->_answerfrom);
907 LDNS_FREE(packet);
908 }
909 }
910
911 bool
912 ldns_pkt_set_flags(ldns_pkt *packet, uint16_t flags)
913 {
914 if (!packet) {
915 return false;
916 }
917 if ((flags & LDNS_QR) == LDNS_QR) {
918 ldns_pkt_set_qr(packet, true);
919 }
920 if ((flags & LDNS_AA) == LDNS_AA) {
921 ldns_pkt_set_aa(packet, true);
922 }
923 if ((flags & LDNS_RD) == LDNS_RD) {
924 ldns_pkt_set_rd(packet, true);
925 }
926 if ((flags & LDNS_TC) == LDNS_TC) {
927 ldns_pkt_set_tc(packet, true);
928 }
929 if ((flags & LDNS_CD) == LDNS_CD) {
930 ldns_pkt_set_cd(packet, true);
931 }
932 if ((flags & LDNS_RA) == LDNS_RA) {
933 ldns_pkt_set_ra(packet, true);
934 }
935 if ((flags & LDNS_AD) == LDNS_AD) {
936 ldns_pkt_set_ad(packet, true);
937 }
938 return true;
939 }
940
941
942 static ldns_rr*
943 ldns_pkt_authsoa(const ldns_rdf* rr_name, ldns_rr_class rr_class)
944 {
945 ldns_rr* soa_rr = ldns_rr_new();
946 ldns_rdf *owner_rdf;
947 ldns_rdf *mname_rdf;
948 ldns_rdf *rname_rdf;
949 ldns_rdf *serial_rdf;
950 ldns_rdf *refresh_rdf;
951 ldns_rdf *retry_rdf;
952 ldns_rdf *expire_rdf;
953 ldns_rdf *minimum_rdf;
954
955 if (!soa_rr) {
956 return NULL;
957 }
958 owner_rdf = ldns_rdf_clone(rr_name);
959 if (!owner_rdf) {
960 ldns_rr_free(soa_rr);
961 return NULL;
962 }
963
964 ldns_rr_set_owner(soa_rr, owner_rdf);
965 ldns_rr_set_type(soa_rr, LDNS_RR_TYPE_SOA);
966 ldns_rr_set_class(soa_rr, rr_class);
967 ldns_rr_set_question(soa_rr, false);
968
969 if (ldns_str2rdf_dname(&mname_rdf, ".") != LDNS_STATUS_OK) {
970 ldns_rr_free(soa_rr);
971 return NULL;
972 } else {
973 ldns_rr_push_rdf(soa_rr, mname_rdf);
974 }
975 if (ldns_str2rdf_dname(&rname_rdf, ".") != LDNS_STATUS_OK) {
976 ldns_rr_free(soa_rr);
977 return NULL;
978 } else {
979 ldns_rr_push_rdf(soa_rr, rname_rdf);
980 }
981 serial_rdf = ldns_native2rdf_int32(LDNS_RDF_TYPE_INT32, 0);
982 if (!serial_rdf) {
983 ldns_rr_free(soa_rr);
984 return NULL;
985 } else {
986 ldns_rr_push_rdf(soa_rr, serial_rdf);
987 }
988 refresh_rdf = ldns_native2rdf_int32(LDNS_RDF_TYPE_INT32, 0);
989 if (!refresh_rdf) {
990 ldns_rr_free(soa_rr);
991 return NULL;
992 } else {
993 ldns_rr_push_rdf(soa_rr, refresh_rdf);
994 }
995 retry_rdf = ldns_native2rdf_int32(LDNS_RDF_TYPE_INT32, 0);
996 if (!retry_rdf) {
997 ldns_rr_free(soa_rr);
998 return NULL;
999 } else {
1000 ldns_rr_push_rdf(soa_rr, retry_rdf);
1001 }
1002 expire_rdf = ldns_native2rdf_int32(LDNS_RDF_TYPE_INT32, 0);
1003 if (!expire_rdf) {
1004 ldns_rr_free(soa_rr);
1005 return NULL;
1006 } else {
1007 ldns_rr_push_rdf(soa_rr, expire_rdf);
1008 }
1009 minimum_rdf = ldns_native2rdf_int32(LDNS_RDF_TYPE_INT32, 0);
1010 if (!minimum_rdf) {
1011 ldns_rr_free(soa_rr);
1012 return NULL;
1013 } else {
1014 ldns_rr_push_rdf(soa_rr, minimum_rdf);
1015 }
1016 return soa_rr;
1017 }
1018
1019
1020 static ldns_status
1021 ldns_pkt_query_new_frm_str_internal(ldns_pkt **p, const char *name,
1022 ldns_rr_type rr_type, ldns_rr_class rr_class, uint16_t flags,
1023 ldns_rr* authsoa_rr)
1024 {
1025 ldns_pkt *packet;
1026 ldns_rr *question_rr;
1027 ldns_rdf *name_rdf;
1028
1029 packet = ldns_pkt_new();
1030 if (!packet) {
1031 return LDNS_STATUS_MEM_ERR;
1032 }
1033
1034 if (!ldns_pkt_set_flags(packet, flags)) {
1035 ldns_pkt_free(packet);
1036 return LDNS_STATUS_ERR;
1037 }
1038
1039 question_rr = ldns_rr_new();
1040 if (!question_rr) {
1041 ldns_pkt_free(packet);
1042 return LDNS_STATUS_MEM_ERR;
1043 }
1044
1045 if (rr_type == 0) {
1046 rr_type = LDNS_RR_TYPE_A;
1047 }
1048 if (rr_class == 0) {
1049 rr_class = LDNS_RR_CLASS_IN;
1050 }
1051
1052 if (ldns_str2rdf_dname(&name_rdf, name) == LDNS_STATUS_OK) {
1053 ldns_rr_set_owner(question_rr, name_rdf);
1054 ldns_rr_set_type(question_rr, rr_type);
1055 ldns_rr_set_class(question_rr, rr_class);
1056 ldns_rr_set_question(question_rr, true);
1057
1058 ldns_pkt_push_rr(packet, LDNS_SECTION_QUESTION, question_rr);
1059 } else {
1060 ldns_rr_free(question_rr);
1061 ldns_pkt_free(packet);
1062 return LDNS_STATUS_ERR;
1063 }
1064
1065 if (authsoa_rr) {
1066 ldns_pkt_push_rr(packet, LDNS_SECTION_AUTHORITY, authsoa_rr);
1067 }
1068
1069 packet->_tsig_rr = NULL;
1070 ldns_pkt_set_answerfrom(packet, NULL);
1071 if (p) {
1072 *p = packet;
1073 return LDNS_STATUS_OK;
1074 } else {
1075 ldns_pkt_free(packet);
1076 return LDNS_STATUS_NULL;
1077 }
1078 }
1079
1080 ldns_status
1081 ldns_pkt_query_new_frm_str(ldns_pkt **p, const char *name,
1082 ldns_rr_type rr_type, ldns_rr_class rr_class, uint16_t flags)
1083 {
1084 return ldns_pkt_query_new_frm_str_internal(p, name, rr_type,
1085 rr_class, flags, NULL);
1086 }
1087
1088 ldns_status
1089 ldns_pkt_ixfr_request_new_frm_str(ldns_pkt **p, const char *name,
1090 ldns_rr_class rr_class, uint16_t flags, ldns_rr *soa)
1091 {
1092 ldns_rr* authsoa_rr = soa;
1093 if (!authsoa_rr) {
1094 ldns_rdf *name_rdf;
1095 if (ldns_str2rdf_dname(&name_rdf, name) == LDNS_STATUS_OK) {
1096 authsoa_rr = ldns_pkt_authsoa(name_rdf, rr_class);
1097 }
1098 ldns_rdf_free(name_rdf);
1099 }
1100 return ldns_pkt_query_new_frm_str_internal(p, name, LDNS_RR_TYPE_IXFR,
1101 rr_class, flags, authsoa_rr);
1102 }
1103
1104 static ldns_pkt *
1105 ldns_pkt_query_new_internal(ldns_rdf *rr_name, ldns_rr_type rr_type,
1106 ldns_rr_class rr_class, uint16_t flags, ldns_rr* authsoa_rr)
1107 {
1108 ldns_pkt *packet;
1109 ldns_rr *question_rr;
1110
1111 packet = ldns_pkt_new();
1112 if (!packet) {
1113 return NULL;
1114 }
1115
1116 if (!ldns_pkt_set_flags(packet, flags)) {
1117 return NULL;
1118 }
1119
1120 question_rr = ldns_rr_new();
1121 if (!question_rr) {
1122 ldns_pkt_free(packet);
1123 return NULL;
1124 }
1125
1126 if (rr_type == 0) {
1127 rr_type = LDNS_RR_TYPE_A;
1128 }
1129 if (rr_class == 0) {
1130 rr_class = LDNS_RR_CLASS_IN;
1131 }
1132
1133 ldns_rr_set_owner(question_rr, rr_name);
1134 ldns_rr_set_type(question_rr, rr_type);
1135 ldns_rr_set_class(question_rr, rr_class);
1136 ldns_rr_set_question(question_rr, true);
1137 ldns_pkt_push_rr(packet, LDNS_SECTION_QUESTION, question_rr);
1138
1139 if (authsoa_rr) {
1140 ldns_pkt_push_rr(packet, LDNS_SECTION_AUTHORITY, authsoa_rr);
1141 }
1142
1143 packet->_tsig_rr = NULL;
1144 return packet;
1145 }
1146
1147 ldns_pkt *
1148 ldns_pkt_query_new(ldns_rdf *rr_name, ldns_rr_type rr_type,
1149 ldns_rr_class rr_class, uint16_t flags)
1150 {
1151 return ldns_pkt_query_new_internal(rr_name, rr_type,
1152 rr_class, flags, NULL);
1153 }
1154
1155 ldns_pkt *
1156 ldns_pkt_ixfr_request_new(ldns_rdf *rr_name, ldns_rr_class rr_class,
1157 uint16_t flags, ldns_rr* soa)
1158 {
1159 ldns_rr* authsoa_rr = soa;
1160 if (!authsoa_rr) {
1161 authsoa_rr = ldns_pkt_authsoa(rr_name, rr_class);
1162 }
1163 return ldns_pkt_query_new_internal(rr_name, LDNS_RR_TYPE_IXFR,
1164 rr_class, flags, authsoa_rr);
1165 }
1166
1167 ldns_pkt_type
1168 ldns_pkt_reply_type(const ldns_pkt *p)
1169 {
1170 ldns_rr_list *tmp;
1171
1172 if (!p) {
1173 return LDNS_PACKET_UNKNOWN;
1174 }
1175
1176 if (ldns_pkt_get_rcode(p) == LDNS_RCODE_NXDOMAIN) {
1177 return LDNS_PACKET_NXDOMAIN;
1178 }
1179
1180 if (ldns_pkt_ancount(p) == 0 && ldns_pkt_arcount(p) == 0
1181 && ldns_pkt_nscount(p) == 1) {
1182
1183 /* check for SOA */
1184 tmp = ldns_pkt_rr_list_by_type(p, LDNS_RR_TYPE_SOA,
1185 LDNS_SECTION_AUTHORITY);
1186 if (tmp) {
1187 ldns_rr_list_deep_free(tmp);
1188 return LDNS_PACKET_NODATA;
1189 } else {
1190 /* I have no idea ... */
1191 }
1192 }
1193
1194 if (ldns_pkt_ancount(p) == 0 && ldns_pkt_nscount(p) > 0) {
1195 tmp = ldns_pkt_rr_list_by_type(p, LDNS_RR_TYPE_NS,
1196 LDNS_SECTION_AUTHORITY);
1197 if (tmp) {
1198 /* there are nameservers here */
1199 ldns_rr_list_deep_free(tmp);
1200 return LDNS_PACKET_REFERRAL;
1201 } else {
1202 /* I have no idea */
1203 }
1204 ldns_rr_list_deep_free(tmp);
1205 }
1206
1207 /* if we cannot determine the packet type, we say it's an
1208 * answer...
1209 */
1210 return LDNS_PACKET_ANSWER;
1211 }
1212
1213 ldns_pkt *
1214 ldns_pkt_clone(const ldns_pkt *pkt)
1215 {
1216 ldns_pkt *new_pkt;
1217
1218 if (!pkt) {
1219 return NULL;
1220 }
1221 new_pkt = ldns_pkt_new();
1222
1223 ldns_pkt_set_id(new_pkt, ldns_pkt_id(pkt));
1224 ldns_pkt_set_qr(new_pkt, ldns_pkt_qr(pkt));
1225 ldns_pkt_set_aa(new_pkt, ldns_pkt_aa(pkt));
1226 ldns_pkt_set_tc(new_pkt, ldns_pkt_tc(pkt));
1227 ldns_pkt_set_rd(new_pkt, ldns_pkt_rd(pkt));
1228 ldns_pkt_set_cd(new_pkt, ldns_pkt_cd(pkt));
1229 ldns_pkt_set_ra(new_pkt, ldns_pkt_ra(pkt));
1230 ldns_pkt_set_ad(new_pkt, ldns_pkt_ad(pkt));
1231 ldns_pkt_set_opcode(new_pkt, ldns_pkt_get_opcode(pkt));
1232 ldns_pkt_set_rcode(new_pkt, ldns_pkt_get_rcode(pkt));
1233 ldns_pkt_set_qdcount(new_pkt, ldns_pkt_qdcount(pkt));
1234 ldns_pkt_set_ancount(new_pkt, ldns_pkt_ancount(pkt));
1235 ldns_pkt_set_nscount(new_pkt, ldns_pkt_nscount(pkt));
1236 ldns_pkt_set_arcount(new_pkt, ldns_pkt_arcount(pkt));
1237 if (ldns_pkt_answerfrom(pkt))
1238 ldns_pkt_set_answerfrom(new_pkt,
1239 ldns_rdf_clone(ldns_pkt_answerfrom(pkt)));
1240 ldns_pkt_set_timestamp(new_pkt, ldns_pkt_timestamp(pkt));
1241 ldns_pkt_set_querytime(new_pkt, ldns_pkt_querytime(pkt));
1242 ldns_pkt_set_size(new_pkt, ldns_pkt_size(pkt));
1243 ldns_pkt_set_tsig(new_pkt, ldns_rr_clone(ldns_pkt_tsig(pkt)));
1244
1245 ldns_pkt_set_edns_udp_size(new_pkt, ldns_pkt_edns_udp_size(pkt));
1246 ldns_pkt_set_edns_extended_rcode(new_pkt,
1247 ldns_pkt_edns_extended_rcode(pkt));
1248 ldns_pkt_set_edns_version(new_pkt, ldns_pkt_edns_version(pkt));
1249 new_pkt->_edns_present = pkt->_edns_present;
1250 ldns_pkt_set_edns_z(new_pkt, ldns_pkt_edns_z(pkt));
1251 if(ldns_pkt_edns_data(pkt))
1252 ldns_pkt_set_edns_data(new_pkt,
1253 ldns_rdf_clone(ldns_pkt_edns_data(pkt)));
1254 ldns_pkt_set_edns_do(new_pkt, ldns_pkt_edns_do(pkt));
1255 if (pkt->_edns_list)
1256 ldns_pkt_set_edns_option_list(new_pkt,
1257 ldns_edns_option_list_clone(pkt->_edns_list));
1258
1259 ldns_rr_list_deep_free(new_pkt->_question);
1260 ldns_rr_list_deep_free(new_pkt->_answer);
1261 ldns_rr_list_deep_free(new_pkt->_authority);
1262 ldns_rr_list_deep_free(new_pkt->_additional);
1263 new_pkt->_question = ldns_rr_list_clone(ldns_pkt_question(pkt));
1264 new_pkt->_answer = ldns_rr_list_clone(ldns_pkt_answer(pkt));
1265 new_pkt->_authority = ldns_rr_list_clone(ldns_pkt_authority(pkt));
1266 new_pkt->_additional = ldns_rr_list_clone(ldns_pkt_additional(pkt));
1267 return new_pkt;
1268 }
DragonFly BSD