4 * DNS packet definitions
6 * a Net::DNS like library for C
8 * (c) NLnet Labs, 2005-2006
10 * See the file LICENSE for the license
16 * Contains the definition of ldns_pkt and its parts, as well
17 * as functions to manipulate those.
24 #define LDNS_MAX_PACKETLEN 65535
26 /* allow flags to be given to ldns_pkt_query_new */
27 #define LDNS_QR 1 /* Query Response flag */
28 #define LDNS_AA 2 /* Authoritative Answer - server flag */
29 #define LDNS_TC 4 /* TrunCated - server flag */
30 #define LDNS_RD 8 /* Recursion Desired - query flag */
31 #define LDNS_CD 16 /* Checking Disabled - query flag */
32 #define LDNS_RA 32 /* Recursion Available - server flag */
33 #define LDNS_AD 64 /* Authenticated Data - server flag */
35 #include <ldns/error.h>
36 #include <ldns/common.h>
44 /* opcodes for pkt's */
45 enum ldns_enum_pkt_opcode {
46 LDNS_PACKET_QUERY = 0,
47 LDNS_PACKET_IQUERY = 1,
48 LDNS_PACKET_STATUS = 2, /* there is no 3?? DNS is weird */
49 LDNS_PACKET_NOTIFY = 4,
50 LDNS_PACKET_UPDATE = 5
52 typedef enum ldns_enum_pkt_opcode ldns_pkt_opcode;
55 enum ldns_enum_pkt_rcode {
56 LDNS_RCODE_NOERROR = 0,
57 LDNS_RCODE_FORMERR = 1,
58 LDNS_RCODE_SERVFAIL = 2,
59 LDNS_RCODE_NXDOMAIN = 3,
60 LDNS_RCODE_NOTIMPL = 4,
61 LDNS_RCODE_REFUSED = 5,
62 LDNS_RCODE_YXDOMAIN = 6,
63 LDNS_RCODE_YXRRSET = 7,
64 LDNS_RCODE_NXRRSET = 8,
65 LDNS_RCODE_NOTAUTH = 9,
66 LDNS_RCODE_NOTZONE = 10
68 typedef enum ldns_enum_pkt_rcode ldns_pkt_rcode;
71 * Header of a dns packet
73 * Contains the information about the packet itself, as specified in RFC1035
75 4.1.1. Header section format
77 The header contains the following fields:
80 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5
81 +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
83 +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
84 |QR| Opcode |AA|TC|RD|RA| Z | RCODE |
85 +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
87 +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
89 +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
91 +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
93 +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
97 ID A 16 bit identifier assigned by the program that
98 generates any kind of query. This identifier is copied
99 the corresponding reply and can be used by the requester
100 to match up replies to outstanding queries.
102 QR A one bit field that specifies whether this message is a
103 query (0), or a response (1).
105 OPCODE A four bit field that specifies kind of query in this
106 message. This value is set by the originator of a query
107 and copied into the response. The values are:
109 0 a standard query (QUERY)
111 1 an inverse query (IQUERY)
113 2 a server status request (STATUS)
115 3-15 reserved for future use
117 AA Authoritative Answer - this bit is valid in responses,
118 and specifies that the responding name server is an
119 authority for the domain name in question section.
121 Note that the contents of the answer section may have
122 multiple owner names because of aliases. The AA bit
124 corresponds to the name which matches the query name, or
125 the first owner name in the answer section.
127 TC TrunCation - specifies that this message was truncated
128 due to length greater than that permitted on the
129 transmission channel.
131 RD Recursion Desired - this bit may be set in a query and
132 is copied into the response. If RD is set, it directs
133 the name server to pursue the query recursively.
134 Recursive query support is optional.
136 RA Recursion Available - this be is set or cleared in a
137 response, and denotes whether recursive query support is
138 available in the name server.
140 Z Reserved for future use. Must be zero in all queries
143 RCODE Response code - this 4 bit field is set as part of
144 responses. The values have the following
149 1 Format error - The name server was
150 unable to interpret the query.
152 2 Server failure - The name server was
153 unable to process this query due to a
154 problem with the name server.
156 3 Name Error - Meaningful only for
157 responses from an authoritative name
158 server, this code signifies that the
159 domain name referenced in the query does
162 4 Not Implemented - The name server does
163 not support the requested kind of query.
165 5 Refused - The name server refuses to
166 perform the specified operation for
167 policy reasons. For example, a name
168 server may not wish to provide the
169 information to the particular requester,
170 or a name server may not wish to perform
171 a particular operation (e.g., zone
173 transfer) for particular data.
175 6-15 Reserved for future use.
177 QDCOUNT an unsigned 16 bit integer specifying the number of
178 entries in the question section.
180 ANCOUNT an unsigned 16 bit integer specifying the number of
181 resource records in the answer section.
183 NSCOUNT an unsigned 16 bit integer specifying the number of name
184 server resource records in the authority records
187 ARCOUNT an unsigned 16 bit integer specifying the number of
188 resource records in the additional records section.
192 struct ldns_struct_hdr
194 /** Id of a packet */
196 /** Query bit (0=query, 1=answer) */
198 /** Authoritative answer */
200 /** Packet truncated */
202 /** Recursion desired */
204 /** Checking disabled */
206 /** Recursion available */
208 /** Authentic data */
211 ldns_pkt_opcode _opcode; /* XXX 8 bits? */
223 typedef struct ldns_struct_hdr ldns_hdr;
228 * This structure contains a complete DNS packet (either a query or an answer)
230 * It is the complete representation of what you actually send to a
231 * nameserver, and what it sends back (assuming you are the client here).
233 struct ldns_struct_pkt
235 /** Header section */
237 /* extra items needed in a packet */
238 /** an rdf (A or AAAA) with the IP address of the server it is from */
239 ldns_rdf *_answerfrom;
240 /** Timestamp of the time the packet was sent or created */
241 struct timeval timestamp;
242 /** The duration of the query this packet is an answer to */
244 /** The size of the wire format of the packet in octets */
246 /** Optional tsig rr */
248 /** EDNS0 available buffer size, see RFC2671 */
249 uint16_t _edns_udp_size;
250 /** EDNS0 Extended rcode */
251 uint8_t _edns_extended_rcode;
253 uint8_t _edns_version;
254 /* OPT pseudo-RR presence flag */
255 uint8_t _edns_present;
256 /** Reserved EDNS data bits */
258 /** Arbitrary EDNS rdata */
259 ldns_rdf *_edns_data;
260 /** Question section */
261 ldns_rr_list *_question;
262 /** Answer section */
263 ldns_rr_list *_answer;
264 /** Authority section */
265 ldns_rr_list *_authority;
266 /** Additional section */
267 ldns_rr_list *_additional;
269 typedef struct ldns_struct_pkt ldns_pkt;
272 * The sections of a packet
274 enum ldns_enum_pkt_section {
275 LDNS_SECTION_QUESTION = 0,
276 LDNS_SECTION_ANSWER = 1,
277 LDNS_SECTION_AUTHORITY = 2,
278 LDNS_SECTION_ADDITIONAL = 3,
279 /** bogus section, if not interested */
280 LDNS_SECTION_ANY = 4,
281 /** used to get all non-question rrs from a packet */
282 LDNS_SECTION_ANY_NOQUESTION = 5
284 typedef enum ldns_enum_pkt_section ldns_pkt_section;
287 * The different types of packets
289 enum ldns_enum_pkt_type {
290 LDNS_PACKET_QUESTION,
291 LDNS_PACKET_REFERRAL,
293 LDNS_PACKET_NXDOMAIN,
297 typedef enum ldns_enum_pkt_type ldns_pkt_type;
305 * \param[in] p the packet
306 * \return the packet id
308 uint16_t ldns_pkt_id(const ldns_pkt *p);
310 * Read the packet's qr bit
311 * \param[in] p the packet
312 * \return value of the bit
314 bool ldns_pkt_qr(const ldns_pkt *p);
316 * Read the packet's aa bit
317 * \param[in] p the packet
318 * \return value of the bit
320 bool ldns_pkt_aa(const ldns_pkt *p);
322 * Read the packet's tc bit
323 * \param[in] p the packet
324 * \return value of the bit
326 bool ldns_pkt_tc(const ldns_pkt *p);
328 * Read the packet's rd bit
329 * \param[in] p the packet
330 * \return value of the bit
332 bool ldns_pkt_rd(const ldns_pkt *p);
334 * Read the packet's cd bit
335 * \param[in] p the packet
336 * \return value of the bit
338 bool ldns_pkt_cd(const ldns_pkt *p);
340 * Read the packet's ra bit
341 * \param[in] p the packet
342 * \return value of the bit
344 bool ldns_pkt_ra(const ldns_pkt *p);
346 * Read the packet's ad bit
347 * \param[in] p the packet
348 * \return value of the bit
350 bool ldns_pkt_ad(const ldns_pkt *p);
352 * Read the packet's code
353 * \param[in] p the packet
356 ldns_pkt_opcode ldns_pkt_get_opcode(const ldns_pkt *p);
358 * Return the packet's respons code
359 * \param[in] p the packet
360 * \return the respons code
362 ldns_pkt_rcode ldns_pkt_get_rcode(const ldns_pkt *p);
364 * Return the packet's qd count
365 * \param[in] p the packet
366 * \return the qd count
368 uint16_t ldns_pkt_qdcount(const ldns_pkt *p);
370 * Return the packet's an count
371 * \param[in] p the packet
372 * \return the an count
374 uint16_t ldns_pkt_ancount(const ldns_pkt *p);
376 * Return the packet's ns count
377 * \param[in] p the packet
378 * \return the ns count
380 uint16_t ldns_pkt_nscount(const ldns_pkt *p);
382 * Return the packet's ar count
383 * \param[in] p the packet
384 * \return the ar count
386 uint16_t ldns_pkt_arcount(const ldns_pkt *p);
389 * Return the packet's answerfrom
390 * \param[in] p packet
391 * \return the name of the server
393 ldns_rdf *ldns_pkt_answerfrom(const ldns_pkt *p);
396 * Return the packet's timestamp
397 * \param[in] p the packet
398 * \return the timestamp
400 struct timeval ldns_pkt_timestamp(const ldns_pkt *p);
402 * Return the packet's querytime
403 * \param[in] p the packet
404 * \return the querytime
406 uint32_t ldns_pkt_querytime(const ldns_pkt *p);
409 * Return the packet's size in bytes
410 * \param[in] p the packet
413 size_t ldns_pkt_size(const ldns_pkt *p);
416 * Return the number of RRs in the given section.
417 * Returns the sum of all RRs when LDNS_SECTION_ANY is given.
418 * Returns the sum of all non-question RRs when LDNS_SECTION_ANY_NOQUESTION
420 * \param[in] p the packet
421 * \param[in] s the section
422 * \return the number of RRs in the given section
424 uint16_t ldns_pkt_section_count(const ldns_pkt *p, ldns_pkt_section s);
427 * Return the packet's tsig pseudo rr's
428 * \param[in] p the packet
429 * \return the tsig rr
431 ldns_rr *ldns_pkt_tsig(const ldns_pkt *p);
434 * Return the packet's question section
435 * \param[in] p the packet
436 * \return the section
438 ldns_rr_list *ldns_pkt_question(const ldns_pkt *p);
440 * Return the packet's answer section
441 * \param[in] p the packet
442 * \return the section
444 ldns_rr_list *ldns_pkt_answer(const ldns_pkt *p);
446 * Return the packet's authority section
447 * \param[in] p the packet
448 * \return the section
450 ldns_rr_list *ldns_pkt_authority(const ldns_pkt *p);
452 * Return the packet's additional section
453 * \param[in] p the packet
454 * \return the section
456 ldns_rr_list *ldns_pkt_additional(const ldns_pkt *p);
458 * Return the packet's question, answer, authority and additional sections
459 * concatenated, in a new rr_list clone.
460 * \param[in] p the packet
463 ldns_rr_list *ldns_pkt_all(const ldns_pkt *p);
465 * Return the packet's answer, authority and additional sections concatenated,
466 * in a new rr_list clone. Like ldns_pkt_all but without the questions.
467 * \param[in] p the packet
468 * \return the rrs except the question rrs
470 ldns_rr_list *ldns_pkt_all_noquestion(const ldns_pkt *p);
473 * return all the rr_list's in the packet. Clone the lists, instead
474 * of returning pointers.
475 * \param[in] p the packet to look in
476 * \param[in] s what section(s) to return
477 * \return ldns_rr_list with the rr's or NULL if none were found
479 ldns_rr_list *ldns_pkt_get_section_clone(const ldns_pkt *p, ldns_pkt_section s);
482 * return all the rr with a specific name from a packet. Optionally
483 * specify from which section in the packet
484 * \param[in] p the packet
485 * \param[in] r the name
486 * \param[in] s the packet's section
487 * \return a list with the rr's or NULL if none were found
489 ldns_rr_list *ldns_pkt_rr_list_by_name(const ldns_pkt *p, const ldns_rdf *r, ldns_pkt_section s);
491 * return all the rr with a specific type from a packet. Optionally
492 * specify from which section in the packet
493 * \param[in] p the packet
494 * \param[in] t the type
495 * \param[in] s the packet's section
496 * \return a list with the rr's or NULL if none were found
498 ldns_rr_list *ldns_pkt_rr_list_by_type(const ldns_pkt *p, ldns_rr_type t, ldns_pkt_section s);
500 * return all the rr with a specific type and type from a packet. Optionally
501 * specify from which section in the packet
502 * \param[in] packet the packet
503 * \param[in] ownername the name
504 * \param[in] type the type
505 * \param[in] sec the packet's section
506 * \return a list with the rr's or NULL if none were found
508 ldns_rr_list *ldns_pkt_rr_list_by_name_and_type(const ldns_pkt *packet, const ldns_rdf *ownername, ldns_rr_type type, ldns_pkt_section sec);
512 * check to see if an rr exist in the packet
513 * \param[in] pkt the packet to examine
514 * \param[in] sec in which section to look
515 * \param[in] rr the rr to look for
517 bool ldns_pkt_rr(const ldns_pkt *pkt, ldns_pkt_section sec, const ldns_rr *rr);
521 * sets the flags in a packet.
522 * \param[in] pkt the packet to operate on
523 * \param[in] flags ORed values: LDNS_QR| LDNS_AR for instance
524 * \return true on success otherwise false
526 bool ldns_pkt_set_flags(ldns_pkt *pkt, uint16_t flags);
529 * Set the packet's id
530 * \param[in] p the packet
531 * \param[in] id the id to set
533 void ldns_pkt_set_id(ldns_pkt *p, uint16_t id);
535 * Set the packet's id to a random value
536 * \param[in] p the packet
538 void ldns_pkt_set_random_id(ldns_pkt *p);
540 * Set the packet's qr bit
541 * \param[in] p the packet
542 * \param[in] b the value to set (boolean)
544 void ldns_pkt_set_qr(ldns_pkt *p, bool b);
546 * Set the packet's aa bit
547 * \param[in] p the packet
548 * \param[in] b the value to set (boolean)
550 void ldns_pkt_set_aa(ldns_pkt *p, bool b);
552 * Set the packet's tc bit
553 * \param[in] p the packet
554 * \param[in] b the value to set (boolean)
556 void ldns_pkt_set_tc(ldns_pkt *p, bool b);
558 * Set the packet's rd bit
559 * \param[in] p the packet
560 * \param[in] b the value to set (boolean)
562 void ldns_pkt_set_rd(ldns_pkt *p, bool b);
564 * Set the packet's cd bit
565 * \param[in] p the packet
566 * \param[in] b the value to set (boolean)
568 void ldns_pkt_set_cd(ldns_pkt *p, bool b);
570 * Set the packet's ra bit
571 * \param[in] p the packet
572 * \param[in] b the value to set (boolean)
574 void ldns_pkt_set_ra(ldns_pkt *p, bool b);
576 * Set the packet's ad bit
577 * \param[in] p the packet
578 * \param[in] b the value to set (boolean)
580 void ldns_pkt_set_ad(ldns_pkt *p, bool b);
583 * Set the packet's opcode
584 * \param[in] p the packet
585 * \param[in] c the opcode
587 void ldns_pkt_set_opcode(ldns_pkt *p, ldns_pkt_opcode c);
589 * Set the packet's respons code
590 * \param[in] p the packet
591 * \param[in] c the rcode
593 void ldns_pkt_set_rcode(ldns_pkt *p, uint8_t c);
595 * Set the packet's qd count
596 * \param[in] p the packet
597 * \param[in] c the count
599 void ldns_pkt_set_qdcount(ldns_pkt *p, uint16_t c);
601 * Set the packet's an count
602 * \param[in] p the packet
603 * \param[in] c the count
605 void ldns_pkt_set_ancount(ldns_pkt *p, uint16_t c);
607 * Set the packet's ns count
608 * \param[in] p the packet
609 * \param[in] c the count
611 void ldns_pkt_set_nscount(ldns_pkt *p, uint16_t c);
613 * Set the packet's arcount
614 * \param[in] p the packet
615 * \param[in] c the count
617 void ldns_pkt_set_arcount(ldns_pkt *p, uint16_t c);
619 * Set the packet's answering server
620 * \param[in] p the packet
621 * \param[in] r the address
623 void ldns_pkt_set_answerfrom(ldns_pkt *p, ldns_rdf *r);
625 * Set the packet's query time
626 * \param[in] p the packet
627 * \param[in] t the querytime in msec
629 void ldns_pkt_set_querytime(ldns_pkt *p, uint32_t t);
631 * Set the packet's size
632 * \param[in] p the packet
633 * \param[in] s the size
635 void ldns_pkt_set_size(ldns_pkt *p, size_t s);
638 * Set the packet's timestamp
639 * \param[in] p the packet
640 * \param[in] timeval the timestamp
642 void ldns_pkt_set_timestamp(ldns_pkt *p, struct timeval timeval);
644 * Set a packet's section count to x
645 * \param[in] p the packet
646 * \param[in] s the section
647 * \param[in] x the section count
649 void ldns_pkt_set_section_count(ldns_pkt *p, ldns_pkt_section s, uint16_t x);
651 * Set the packet's tsig rr
652 * \param[in] p the packet
653 * \param[in] t the tsig rr
655 void ldns_pkt_set_tsig(ldns_pkt *p, ldns_rr *t);
658 * looks inside the packet to determine
659 * what kind of packet it is, AUTH, NXDOMAIN, REFERRAL, etc.
660 * \param[in] p the packet to examine
661 * \return the type of packet
663 ldns_pkt_type ldns_pkt_reply_type(const ldns_pkt *p);
666 * return the packet's edns udp size
667 * \param[in] packet the packet
670 uint16_t ldns_pkt_edns_udp_size(const ldns_pkt *packet);
672 * return the packet's edns extended rcode
673 * \param[in] packet the packet
676 uint8_t ldns_pkt_edns_extended_rcode(const ldns_pkt *packet);
678 * return the packet's edns version
679 * \param[in] packet the packet
680 * \return the version
682 uint8_t ldns_pkt_edns_version(const ldns_pkt *packet);
684 * return the packet's edns z value
685 * \param[in] packet the packet
686 * \return the z value
688 uint16_t ldns_pkt_edns_z(const ldns_pkt *packet);
690 * return the packet's edns data
691 * \param[in] packet the packet
694 ldns_rdf *ldns_pkt_edns_data(const ldns_pkt *packet);
697 * return the packet's edns do bit
698 * \param[in] packet the packet
699 * \return the bit's value
701 bool ldns_pkt_edns_do(const ldns_pkt *packet);
703 * Set the packet's edns do bit
704 * \param[in] packet the packet
705 * \param[in] value the bit's new value
707 void ldns_pkt_set_edns_do(ldns_pkt *packet, bool value);
710 * returns true if this packet needs and EDNS rr to be sent.
711 * At the moment the only reason is an expected packet
712 * size larger than 512 bytes, but for instance dnssec would
713 * be a good reason too.
715 * \param[in] packet the packet to check
716 * \return true if packet needs edns rr
718 bool ldns_pkt_edns(const ldns_pkt *packet);
721 * Set the packet's edns udp size
722 * \param[in] packet the packet
723 * \param[in] s the size
725 void ldns_pkt_set_edns_udp_size(ldns_pkt *packet, uint16_t s);
727 * Set the packet's edns extended rcode
728 * \param[in] packet the packet
729 * \param[in] c the code
731 void ldns_pkt_set_edns_extended_rcode(ldns_pkt *packet, uint8_t c);
733 * Set the packet's edns version
734 * \param[in] packet the packet
735 * \param[in] v the version
737 void ldns_pkt_set_edns_version(ldns_pkt *packet, uint8_t v);
739 * Set the packet's edns z value
740 * \param[in] packet the packet
741 * \param[in] z the value
743 void ldns_pkt_set_edns_z(ldns_pkt *packet, uint16_t z);
745 * Set the packet's edns data
746 * \param[in] packet the packet
747 * \param[in] data the data
749 void ldns_pkt_set_edns_data(ldns_pkt *packet, ldns_rdf *data);
752 * allocates and initializes a ldns_pkt structure.
753 * \return pointer to the new packet
755 ldns_pkt *ldns_pkt_new(void);
758 * frees the packet structure and all data that it contains.
759 * \param[in] packet The packet structure to free
762 void ldns_pkt_free(ldns_pkt *packet);
765 * creates a query packet for the given name, type, class.
766 * \param[out] p the packet to be returned
767 * \param[in] rr_name the name to query for (as string)
768 * \param[in] rr_type the type to query for
769 * \param[in] rr_class the class to query for
770 * \param[in] flags packet flags
771 * \return LDNS_STATUS_OK or a ldns_status mesg with the error
773 ldns_status ldns_pkt_query_new_frm_str(ldns_pkt **p, const char *rr_name, ldns_rr_type rr_type, ldns_rr_class rr_class , uint16_t flags);
776 * creates an IXFR request packet for the given name, class.
777 * adds the SOA record to the authority section.
778 * \param[out] p the packet to be returned
779 * \param[in] rr_name the name to query for (as string)
780 * \param[in] rr_class the class to query for
781 * \param[in] flags packet flags
782 * \param[in] soa soa record to be added to the authority section (not copied).
783 * \return LDNS_STATUS_OK or a ldns_status mesg with the error
785 ldns_status ldns_pkt_ixfr_request_new_frm_str(ldns_pkt **p, const char *rr_name, ldns_rr_class rr_class, uint16_t flags, ldns_rr* soa);
788 * creates a packet with a query in it for the given name, type and class.
789 * \param[in] rr_name the name to query for (not copied).
790 * The returned packet will take ownership of rr_name, so the caller should not free it.
791 * \param[in] rr_type the type to query for
792 * \param[in] rr_class the class to query for
793 * \param[in] flags packet flags
794 * \return ldns_pkt* a pointer to the new pkt
796 ldns_pkt *ldns_pkt_query_new(ldns_rdf *rr_name, ldns_rr_type rr_type, ldns_rr_class rr_class, uint16_t flags);
799 * creates an IXFR request packet for the given name, type and class.
800 * adds the SOA record to the authority section.
801 * \param[in] rr_name the name to query for (not copied).
802 * The returned packet will take ownership of rr_name, so the caller should not free it.
803 * \param[in] rr_class the class to query for
804 * \param[in] flags packet flags
805 * \param[in] soa soa record to be added to the authority section (not copied).
806 * \return ldns_pkt* a pointer to the new pkt
808 ldns_pkt *ldns_pkt_ixfr_request_new(ldns_rdf *rr_name, ldns_rr_class rr_class, uint16_t flags, ldns_rr* soa);
811 * clones the given packet, creating a fully allocated copy
813 * \param[in] pkt the packet to clone
814 * \return ldns_pkt* pointer to the new packet
816 ldns_pkt *ldns_pkt_clone(const ldns_pkt *pkt);
819 * directly set the additional section
820 * \param[in] p packet to operate on
821 * \param[in] rr rrlist to set
823 void ldns_pkt_set_additional(ldns_pkt *p, ldns_rr_list *rr);
826 * directly set the answer section
827 * \param[in] p packet to operate on
828 * \param[in] rr rrlist to set
830 void ldns_pkt_set_answer(ldns_pkt *p, ldns_rr_list *rr);
833 * directly set the question section
834 * \param[in] p packet to operate on
835 * \param[in] rr rrlist to set
837 void ldns_pkt_set_question(ldns_pkt *p, ldns_rr_list *rr);
840 * directly set the auhority section
841 * \param[in] p packet to operate on
842 * \param[in] rr rrlist to set
844 void ldns_pkt_set_authority(ldns_pkt *p, ldns_rr_list *rr);
847 * push an rr on a packet
848 * \param[in] packet packet to operate on
849 * \param[in] section where to put it
850 * \param[in] rr rr to push
851 * \return a boolean which is true when the rr was added
853 bool ldns_pkt_push_rr(ldns_pkt *packet, ldns_pkt_section section, ldns_rr *rr);
856 * push an rr on a packet, provided the RR is not there.
857 * \param[in] pkt packet to operate on
858 * \param[in] sec where to put it
859 * \param[in] rr rr to push
860 * \return a boolean which is true when the rr was added
862 bool ldns_pkt_safe_push_rr(ldns_pkt *pkt, ldns_pkt_section sec, ldns_rr *rr);
865 * push a rr_list on a packet
866 * \param[in] packet packet to operate on
867 * \param[in] section where to put it
868 * \param[in] list the rr_list to push
869 * \return a boolean which is true when the rr was added
871 bool ldns_pkt_push_rr_list(ldns_pkt *packet, ldns_pkt_section section, ldns_rr_list *list);
874 * push an rr_list to a packet, provided the RRs are not already there.
875 * \param[in] pkt packet to operate on
876 * \param[in] sec where to put it
877 * \param[in] list the rr_list to push
878 * \return a boolean which is true when the rr was added
880 bool ldns_pkt_safe_push_rr_list(ldns_pkt *pkt, ldns_pkt_section sec, ldns_rr_list *list);
883 * check if a packet is empty
884 * \param[in] p packet
885 * \return true: empty, false: not empty
887 bool ldns_pkt_empty(ldns_pkt *p);
893 #endif /* LDNS_PACKET_H */