1 /* 2 * packet.h 3 * 4 * DNS packet definitions 5 * 6 * a Net::DNS like library for C 7 * 8 * (c) NLnet Labs, 2005-2006 9 * 10 * See the file LICENSE for the license 11 */ 12 13 /** 14 * \file 15 * 16 * Contains the definition of ldns_pkt and its parts, as well 17 * as functions to manipulate those. 18 */ 19 20 21 #ifndef LDNS_PACKET_H 22 #define LDNS_PACKET_H 23 24 #define LDNS_MAX_PACKETLEN 65535 25 26 /* allow flags to be given to mk_query */ 27 #define LDNS_QR 1 /* QueRy - query 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 */ 34 35 #include <ldns/error.h> 36 #include <ldns/common.h> 37 #include <ldns/rr.h> 38 #include <sys/time.h> 39 40 /* opcodes for pkt's */ 41 enum ldns_enum_pkt_opcode { 42 LDNS_PACKET_QUERY = 0, 43 LDNS_PACKET_IQUERY = 1, 44 LDNS_PACKET_STATUS = 2, /* there is no 3?? DNS is weird */ 45 LDNS_PACKET_NOTIFY = 4, 46 LDNS_PACKET_UPDATE = 5 47 }; 48 typedef enum ldns_enum_pkt_opcode ldns_pkt_opcode; 49 50 /* rcodes for pkts */ 51 enum ldns_enum_pkt_rcode { 52 LDNS_RCODE_NOERROR = 0, 53 LDNS_RCODE_FORMERR = 1, 54 LDNS_RCODE_SERVFAIL = 2, 55 LDNS_RCODE_NXDOMAIN = 3, 56 LDNS_RCODE_NOTIMPL = 4, 57 LDNS_RCODE_REFUSED = 5, 58 LDNS_RCODE_YXDOMAIN = 6, 59 LDNS_RCODE_YXRRSET = 7, 60 LDNS_RCODE_NXRRSET = 8, 61 LDNS_RCODE_NOTAUTH = 9, 62 LDNS_RCODE_NOTZONE = 10 63 }; 64 typedef enum ldns_enum_pkt_rcode ldns_pkt_rcode; 65 66 /** 67 * Header of a dns packet 68 * 69 * Contains the information about the packet itself, as specified in RFC1035 70 <pre> 71 4.1.1. Header section format 72 73 The header contains the following fields: 74 75 1 1 1 1 1 1 76 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 77 +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+ 78 | ID | 79 +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+ 80 |QR| Opcode |AA|TC|RD|RA| Z | RCODE | 81 +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+ 82 | QDCOUNT | 83 +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+ 84 | ANCOUNT | 85 +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+ 86 | NSCOUNT | 87 +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+ 88 | ARCOUNT | 89 +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+ 90 91 where: 92 93 ID A 16 bit identifier assigned by the program that 94 generates any kind of query. This identifier is copied 95 the corresponding reply and can be used by the requester 96 to match up replies to outstanding queries. 97 98 QR A one bit field that specifies whether this message is a 99 query (0), or a response (1). 100 101 OPCODE A four bit field that specifies kind of query in this 102 message. This value is set by the originator of a query 103 and copied into the response. The values are: 104 105 0 a standard query (QUERY) 106 107 1 an inverse query (IQUERY) 108 109 2 a server status request (STATUS) 110 111 3-15 reserved for future use 112 113 AA Authoritative Answer - this bit is valid in responses, 114 and specifies that the responding name server is an 115 authority for the domain name in question section. 116 117 Note that the contents of the answer section may have 118 multiple owner names because of aliases. The AA bit 119 120 corresponds to the name which matches the query name, or 121 the first owner name in the answer section. 122 123 TC TrunCation - specifies that this message was truncated 124 due to length greater than that permitted on the 125 transmission channel. 126 127 RD Recursion Desired - this bit may be set in a query and 128 is copied into the response. If RD is set, it directs 129 the name server to pursue the query recursively. 130 Recursive query support is optional. 131 132 RA Recursion Available - this be is set or cleared in a 133 response, and denotes whether recursive query support is 134 available in the name server. 135 136 Z Reserved for future use. Must be zero in all queries 137 and responses. 138 139 RCODE Response code - this 4 bit field is set as part of 140 responses. The values have the following 141 interpretation: 142 143 0 No error condition 144 145 1 Format error - The name server was 146 unable to interpret the query. 147 148 2 Server failure - The name server was 149 unable to process this query due to a 150 problem with the name server. 151 152 3 Name Error - Meaningful only for 153 responses from an authoritative name 154 server, this code signifies that the 155 domain name referenced in the query does 156 not exist. 157 158 4 Not Implemented - The name server does 159 not support the requested kind of query. 160 161 5 Refused - The name server refuses to 162 perform the specified operation for 163 policy reasons. For example, a name 164 server may not wish to provide the 165 information to the particular requester, 166 or a name server may not wish to perform 167 a particular operation (e.g., zone 168 169 transfer) for particular data. 170 171 6-15 Reserved for future use. 172 173 QDCOUNT an unsigned 16 bit integer specifying the number of 174 entries in the question section. 175 176 ANCOUNT an unsigned 16 bit integer specifying the number of 177 resource records in the answer section. 178 179 NSCOUNT an unsigned 16 bit integer specifying the number of name 180 server resource records in the authority records 181 section. 182 183 ARCOUNT an unsigned 16 bit integer specifying the number of 184 resource records in the additional records section. 185 186 </pre> 187 */ 188 struct ldns_struct_hdr 189 { 190 /** Id of a packet */ 191 uint16_t _id; 192 /** Query bit (0=query, 1=answer) */ 193 bool _qr; 194 /** Authoritative answer */ 195 bool _aa; 196 /** Packet truncated */ 197 bool _tc; 198 /** Recursion desired */ 199 bool _rd; 200 /** Checking disabled */ 201 bool _cd; 202 /** Recursion available */ 203 bool _ra; 204 /** Authentic data */ 205 bool _ad; 206 /** Query type */ 207 ldns_pkt_opcode _opcode; /* XXX 8 bits? */ 208 /** Response code */ 209 uint8_t _rcode; 210 /** question sec */ 211 uint16_t _qdcount; 212 /** answer sec */ 213 uint16_t _ancount; 214 /** auth sec */ 215 uint16_t _nscount; 216 /** add sec */ 217 uint16_t _arcount; 218 }; 219 typedef struct ldns_struct_hdr ldns_hdr; 220 221 /** 222 * DNS packet 223 * 224 * This structure contains a complete DNS packet (either a query or an answer) 225 * 226 * It is the complete representation of what you actually send to a 227 * nameserver, and what it sends back (assuming you are the client here). 228 */ 229 struct ldns_struct_pkt 230 { 231 /** Header section */ 232 ldns_hdr *_header; 233 /* extra items needed in a packet */ 234 /** The size of the wire format of the packet in octets */ 235 ldns_rdf *_answerfrom; 236 /** Timestamp of the time the packet was sent or created */ 237 struct timeval timestamp; 238 /** The duration of the query this packet is an answer to */ 239 uint32_t _querytime; 240 /** The size of the wire format of the packet in octets */ 241 size_t _size; 242 /** Optional tsig rr */ 243 ldns_rr *_tsig_rr; 244 /** EDNS0 available buffer size, see RFC2671 */ 245 uint16_t _edns_udp_size; 246 /** EDNS0 Extended rcode */ 247 uint8_t _edns_extended_rcode; 248 /** EDNS Version */ 249 uint8_t _edns_version; 250 /** Reserved EDNS data bits */ 251 uint16_t _edns_z; 252 /** Arbitrary EDNS rdata */ 253 ldns_rdf *_edns_data; 254 /** Question section */ 255 ldns_rr_list *_question; 256 /** Answer section */ 257 ldns_rr_list *_answer; 258 /** Authority section */ 259 ldns_rr_list *_authority; 260 /** Additional section */ 261 ldns_rr_list *_additional; 262 }; 263 typedef struct ldns_struct_pkt ldns_pkt; 264 265 /** 266 * The sections of a packet 267 */ 268 enum ldns_enum_pkt_section { 269 LDNS_SECTION_QUESTION = 0, 270 LDNS_SECTION_ANSWER = 1, 271 LDNS_SECTION_AUTHORITY = 2, 272 LDNS_SECTION_ADDITIONAL = 3, 273 /** bogus section, if not interested */ 274 LDNS_SECTION_ANY = 4, 275 /** used to get all non-question rrs from a packet */ 276 LDNS_SECTION_ANY_NOQUESTION = 5 277 }; 278 typedef enum ldns_enum_pkt_section ldns_pkt_section; 279 280 /** 281 * The different types of packets 282 */ 283 enum ldns_enum_pkt_type { 284 LDNS_PACKET_QUESTION, 285 LDNS_PACKET_REFERRAL, 286 LDNS_PACKET_ANSWER, 287 LDNS_PACKET_NXDOMAIN, 288 LDNS_PACKET_NODATA, 289 LDNS_PACKET_UNKNOWN 290 }; 291 typedef enum ldns_enum_pkt_type ldns_pkt_type; 292 293 /* prototypes */ 294 295 /* read */ 296 297 /** 298 * Read the packet id 299 * \param[in] p the packet 300 * \return the packet id 301 */ 302 uint16_t ldns_pkt_id(const ldns_pkt *p); 303 /** 304 * Read the packet's qr bit 305 * \param[in] p the packet 306 * \return value of the bit 307 */ 308 bool ldns_pkt_qr(const ldns_pkt *p); 309 /** 310 * Read the packet's aa bit 311 * \param[in] p the packet 312 * \return value of the bit 313 */ 314 bool ldns_pkt_aa(const ldns_pkt *p); 315 /** 316 * Read the packet's tc bit 317 * \param[in] p the packet 318 * \return value of the bit 319 */ 320 bool ldns_pkt_tc(const ldns_pkt *p); 321 /** 322 * Read the packet's rd bit 323 * \param[in] p the packet 324 * \return value of the bit 325 */ 326 bool ldns_pkt_rd(const ldns_pkt *p); 327 /** 328 * Read the packet's cd bit 329 * \param[in] p the packet 330 * \return value of the bit 331 */ 332 bool ldns_pkt_cd(const ldns_pkt *p); 333 /** 334 * Read the packet's ra bit 335 * \param[in] p the packet 336 * \return value of the bit 337 */ 338 bool ldns_pkt_ra(const ldns_pkt *p); 339 /** 340 * Read the packet's ad bit 341 * \param[in] p the packet 342 * \return value of the bit 343 */ 344 bool ldns_pkt_ad(const ldns_pkt *p); 345 /** 346 * Read the packet's code 347 * \param[in] p the packet 348 * \return the opcode 349 */ 350 ldns_pkt_opcode ldns_pkt_get_opcode(const ldns_pkt *p); 351 /** 352 * Return the packet's respons code 353 * \param[in] p the packet 354 * \return the respons code 355 */ 356 ldns_pkt_rcode ldns_pkt_get_rcode(const ldns_pkt *p); 357 /** 358 * Return the packet's qd count 359 * \param[in] p the packet 360 * \return the qd count 361 */ 362 uint16_t ldns_pkt_qdcount(const ldns_pkt *p); 363 /** 364 * Return the packet's an count 365 * \param[in] p the packet 366 * \return the an count 367 */ 368 uint16_t ldns_pkt_ancount(const ldns_pkt *p); 369 /** 370 * Return the packet's ns count 371 * \param[in] p the packet 372 * \return the ns count 373 */ 374 uint16_t ldns_pkt_nscount(const ldns_pkt *p); 375 /** 376 * Return the packet's ar count 377 * \param[in] p the packet 378 * \return the ar count 379 */ 380 uint16_t ldns_pkt_arcount(const ldns_pkt *p); 381 382 /** 383 * Return the packet's answerfrom 384 * \param[in] p packet 385 * \return the name of the server 386 */ 387 ldns_rdf *ldns_pkt_answerfrom(const ldns_pkt *p); 388 389 /** 390 * Return the packet's timestamp 391 * \param[in] p the packet 392 * \return the timestamp 393 */ 394 struct timeval ldns_pkt_timestamp(const ldns_pkt *p); 395 /** 396 * Return the packet's querytime 397 * \param[in] p the packet 398 * \return the querytime 399 */ 400 uint32_t ldns_pkt_querytime(const ldns_pkt *p); 401 402 /** 403 * Return the packet's size in bytes 404 * \param[in] p the packet 405 * \return the size 406 */ 407 size_t ldns_pkt_size(const ldns_pkt *p); 408 409 /** 410 * Return the packet's tsig pseudo rr's 411 * \param[in] p the packet 412 * \return the tsig rr 413 */ 414 ldns_rr *ldns_pkt_tsig(const ldns_pkt *p); 415 416 /** 417 * Return the packet's question section 418 * \param[in] p the packet 419 * \return the section 420 */ 421 ldns_rr_list *ldns_pkt_question(const ldns_pkt *p); 422 /** 423 * Return the packet's answer section 424 * \param[in] p the packet 425 * \return the section 426 */ 427 ldns_rr_list *ldns_pkt_answer(const ldns_pkt *p); 428 /** 429 * Return the packet's authority section 430 * \param[in] p the packet 431 * \return the section 432 */ 433 ldns_rr_list *ldns_pkt_authority(const ldns_pkt *p); 434 /** 435 * Return the packet's additional section 436 * \param[in] p the packet 437 * \return the section 438 */ 439 ldns_rr_list *ldns_pkt_additional(const ldns_pkt *p); 440 /** 441 * Return the packet's question, answer, authority and additional sections 442 * concatenated, in a new rr_list clone. 443 * \param[in] p the packet 444 * \return the rrs 445 */ 446 ldns_rr_list *ldns_pkt_all(const ldns_pkt *p); 447 /** 448 * Return the packet's answer, authority and additional sections concatenated, 449 * in a new rr_list clone. Like ldns_pkt_all but without the questions. 450 * \param[in] p the packet 451 * \return the rrs except the question rrs 452 */ 453 ldns_rr_list *ldns_pkt_all_noquestion(const ldns_pkt *p); 454 455 /** 456 * return all the rr_list's in the packet. Clone the lists, instead 457 * of returning pointers. 458 * \param[in] p the packet to look in 459 * \param[in] s what section(s) to return 460 * \return ldns_rr_list with the rr's or NULL if none were found 461 */ 462 ldns_rr_list *ldns_pkt_get_section_clone(const ldns_pkt *p, ldns_pkt_section s); 463 464 /** 465 * return all the rr with a specific name from a packet. Optionally 466 * specify from which section in the packet 467 * \param[in] p the packet 468 * \param[in] r the name 469 * \param[in] s the packet's section 470 * \return a list with the rr's or NULL if none were found 471 */ 472 ldns_rr_list *ldns_pkt_rr_list_by_name(ldns_pkt *p, ldns_rdf *r, ldns_pkt_section s); 473 /** 474 * return all the rr with a specific type from a packet. Optionally 475 * specify from which section in the packet 476 * \param[in] p the packet 477 * \param[in] t the type 478 * \param[in] s the packet's section 479 * \return a list with the rr's or NULL if none were found 480 */ 481 ldns_rr_list *ldns_pkt_rr_list_by_type(const ldns_pkt *p, ldns_rr_type t, ldns_pkt_section s); 482 /** 483 * return all the rr with a specific type and type from a packet. Optionally 484 * specify from which section in the packet 485 * \param[in] packet the packet 486 * \param[in] ownername the name 487 * \param[in] type the type 488 * \param[in] sec the packet's section 489 * \return a list with the rr's or NULL if none were found 490 */ 491 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); 492 493 494 /** 495 * check to see if an rr exist in the packet 496 * \param[in] pkt the packet to examine 497 * \param[in] sec in which section to look 498 * \param[in] rr the rr to look for 499 */ 500 bool ldns_pkt_rr(ldns_pkt *pkt, ldns_pkt_section sec, ldns_rr *rr); 501 502 503 /** 504 * sets the flags in a packet. 505 * \param[in] pkt the packet to operate on 506 * \param[in] flags ORed values: LDNS_QR| LDNS_AR for instance 507 * \return true on success otherwise false 508 */ 509 bool ldns_pkt_set_flags(ldns_pkt *pkt, uint16_t flags); 510 511 /** 512 * Set the packet's id 513 * \param[in] p the packet 514 * \param[in] id the id to set 515 */ 516 void ldns_pkt_set_id(ldns_pkt *p, uint16_t id); 517 /** 518 * Set the packet's id to a random value 519 * \param[in] p the packet 520 */ 521 void ldns_pkt_set_random_id(ldns_pkt *p); 522 /** 523 * Set the packet's qr bit 524 * \param[in] p the packet 525 * \param[in] b the value to set (boolean) 526 */ 527 void ldns_pkt_set_qr(ldns_pkt *p, bool b); 528 /** 529 * Set the packet's aa bit 530 * \param[in] p the packet 531 * \param[in] b the value to set (boolean) 532 */ 533 void ldns_pkt_set_aa(ldns_pkt *p, bool b); 534 /** 535 * Set the packet's tc bit 536 * \param[in] p the packet 537 * \param[in] b the value to set (boolean) 538 */ 539 void ldns_pkt_set_tc(ldns_pkt *p, bool b); 540 /** 541 * Set the packet's rd bit 542 * \param[in] p the packet 543 * \param[in] b the value to set (boolean) 544 */ 545 void ldns_pkt_set_rd(ldns_pkt *p, bool b); 546 /** 547 * Set the packet's cd bit 548 * \param[in] p the packet 549 * \param[in] b the value to set (boolean) 550 */ 551 void ldns_pkt_set_cd(ldns_pkt *p, bool b); 552 /** 553 * Set the packet's ra bit 554 * \param[in] p the packet 555 * \param[in] b the value to set (boolean) 556 */ 557 void ldns_pkt_set_ra(ldns_pkt *p, bool b); 558 /** 559 * Set the packet's ad bit 560 * \param[in] p the packet 561 * \param[in] b the value to set (boolean) 562 */ 563 void ldns_pkt_set_ad(ldns_pkt *p, bool b); 564 565 /** 566 * Set the packet's opcode 567 * \param[in] p the packet 568 * \param[in] c the opcode 569 */ 570 void ldns_pkt_set_opcode(ldns_pkt *p, ldns_pkt_opcode c); 571 /** 572 * Set the packet's respons code 573 * \param[in] p the packet 574 * \param[in] c the rcode 575 */ 576 void ldns_pkt_set_rcode(ldns_pkt *p, uint8_t c); 577 /** 578 * Set the packet's qd count 579 * \param[in] p the packet 580 * \param[in] c the count 581 */ 582 void ldns_pkt_set_qdcount(ldns_pkt *p, uint16_t c); 583 /** 584 * Set the packet's an count 585 * \param[in] p the packet 586 * \param[in] c the count 587 */ 588 void ldns_pkt_set_ancount(ldns_pkt *p, uint16_t c); 589 /** 590 * Set the packet's ns count 591 * \param[in] p the packet 592 * \param[in] c the count 593 */ 594 void ldns_pkt_set_nscount(ldns_pkt *p, uint16_t c); 595 /** 596 * Set the packet's arcount 597 * \param[in] p the packet 598 * \param[in] c the count 599 */ 600 void ldns_pkt_set_arcount(ldns_pkt *p, uint16_t c); 601 /** 602 * Set the packet's answering server 603 * \param[in] p the packet 604 * \param[in] r the address 605 */ 606 void ldns_pkt_set_answerfrom(ldns_pkt *p, ldns_rdf *r); 607 /** 608 * Set the packet's query time 609 * \param[in] p the packet 610 * \param[in] t the querytime in msec 611 */ 612 void ldns_pkt_set_querytime(ldns_pkt *p, uint32_t t); 613 /** 614 * Set the packet's size 615 * \param[in] p the packet 616 * \param[in] s the size 617 */ 618 void ldns_pkt_set_size(ldns_pkt *p, size_t s); 619 620 /** 621 * Set the packet's timestamp 622 * \param[in] p the packet 623 * \param[in] timeval the timestamp 624 */ 625 void ldns_pkt_set_timestamp(ldns_pkt *p, struct timeval); 626 /** 627 * Set a packet's section count to x 628 * \param[in] p the packet 629 * \param[in] s the section 630 * \param[in] x the section count 631 */ 632 void ldns_pkt_set_section_count(ldns_pkt *p, ldns_pkt_section s, uint16_t x); 633 /** 634 * Set the packet's tsig rr 635 * \param[in] p the packet 636 * \param[in] t the tsig rr 637 */ 638 void ldns_pkt_set_tsig(ldns_pkt *p, ldns_rr *t); 639 640 /** 641 * looks inside the packet to determine 642 * what kind of packet it is, AUTH, NXDOMAIN, REFERRAL, etc. 643 * \param[in] p the packet to examine 644 * \return the type of packet 645 */ 646 ldns_pkt_type ldns_pkt_reply_type(ldns_pkt *p); 647 648 /** 649 * return the packet's edns udp size 650 * \param[in] packet the packet 651 * \return the size 652 */ 653 uint16_t ldns_pkt_edns_udp_size(const ldns_pkt *packet); 654 /** 655 * return the packet's edns extended rcode 656 * \param[in] packet the packet 657 * \return the rcode 658 */ 659 uint8_t ldns_pkt_edns_extended_rcode(const ldns_pkt *packet); 660 /** 661 * return the packet's edns version 662 * \param[in] packet the packet 663 * \return the version 664 */ 665 uint8_t ldns_pkt_edns_version(const ldns_pkt *packet); 666 /** 667 * return the packet's edns z value 668 * \param[in] packet the packet 669 * \return the z value 670 */ 671 uint16_t ldns_pkt_edns_z(const ldns_pkt *packet); 672 /** 673 * return the packet's edns data 674 * \param[in] packet the packet 675 * \return the data 676 */ 677 ldns_rdf *ldns_pkt_edns_data(const ldns_pkt *packet); 678 679 /** 680 * return the packet's edns do bit 681 * \param[in] packet the packet 682 * \return the bit's value 683 */ 684 bool ldns_pkt_edns_do(const ldns_pkt *packet); 685 /** 686 * Set the packet's edns do bit 687 * \param[in] packet the packet 688 * \param[in] value the bit's new value 689 */ 690 void ldns_pkt_set_edns_do(ldns_pkt *packet, bool value); 691 692 /** 693 * returns true if this packet needs and EDNS rr to be sent. 694 * At the moment the only reason is an expected packet 695 * size larger than 512 bytes, but for instance dnssec would 696 * be a good reason too. 697 * 698 * \param[in] packet the packet to check 699 * \return true if packet needs edns rr 700 */ 701 bool ldns_pkt_edns(const ldns_pkt *packet); 702 703 /** 704 * Set the packet's edns udp size 705 * \param[in] packet the packet 706 * \param[in] s the size 707 */ 708 void ldns_pkt_set_edns_udp_size(ldns_pkt *packet, uint16_t s); 709 /** 710 * Set the packet's edns extended rcode 711 * \param[in] packet the packet 712 * \param[in] c the code 713 */ 714 void ldns_pkt_set_edns_extended_rcode(ldns_pkt *packet, uint8_t c); 715 /** 716 * Set the packet's edns version 717 * \param[in] packet the packet 718 * \param[in] v the version 719 */ 720 void ldns_pkt_set_edns_version(ldns_pkt *packet, uint8_t v); 721 /** 722 * Set the packet's edns z value 723 * \param[in] packet the packet 724 * \param[in] z the value 725 */ 726 void ldns_pkt_set_edns_z(ldns_pkt *packet, uint16_t z); 727 /** 728 * Set the packet's edns data 729 * \param[in] packet the packet 730 * \param[in] data the data 731 */ 732 void ldns_pkt_set_edns_data(ldns_pkt *packet, ldns_rdf *data); 733 734 /** 735 * allocates and initializes a ldns_pkt structure. 736 * \return pointer to the new packet 737 */ 738 ldns_pkt *ldns_pkt_new(); 739 740 /** 741 * frees the packet structure and all data that it contains. 742 * \param[in] packet The packet structure to free 743 * \return void 744 */ 745 void ldns_pkt_free(ldns_pkt *packet); 746 747 /** 748 * creates a query packet for the given name, type, class. 749 * \param[out] p the packet to be returned 750 * \param[in] rr_name the name to query for (as string) 751 * \param[in] rr_type the type to query for 752 * \param[in] rr_class the class to query for 753 * \param[in] flags packet flags 754 * \return LDNS_STATUS_OK or a ldns_status mesg with the error 755 */ 756 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); 757 758 /** 759 * creates a packet with a query in it for the given name, type and class. 760 * \param[in] rr_name the name to query for 761 * \param[in] rr_type the type to query for 762 * \param[in] rr_class the class to query for 763 * \param[in] flags packet flags 764 * \return ldns_pkt* a pointer to the new pkt 765 */ 766 ldns_pkt *ldns_pkt_query_new(ldns_rdf *rr_name, ldns_rr_type rr_type, ldns_rr_class rr_class, uint16_t flags); 767 768 /** 769 * clones the given packet, creating a fully allocated copy 770 * 771 * \param[in] pkt the packet to clone 772 * \return ldns_pkt* pointer to the new packet 773 */ 774 ldns_pkt *ldns_pkt_clone(ldns_pkt *pkt); 775 776 /** 777 * directly set the additional section 778 * \param[in] p packet to operate on 779 * \param[in] rr rrlist to set 780 */ 781 void ldns_pkt_set_additional(ldns_pkt *p, ldns_rr_list *rr); 782 783 /** 784 * directly set the answer section 785 * \param[in] p packet to operate on 786 * \param[in] rr rrlist to set 787 */ 788 void ldns_pkt_set_answer(ldns_pkt *p, ldns_rr_list *rr); 789 790 /** 791 * directly set the question section 792 * \param[in] p packet to operate on 793 * \param[in] rr rrlist to set 794 */ 795 void ldns_pkt_set_question(ldns_pkt *p, ldns_rr_list *rr); 796 797 /** 798 * directly set the auhority section 799 * \param[in] p packet to operate on 800 * \param[in] rr rrlist to set 801 */ 802 void ldns_pkt_set_authority(ldns_pkt *p, ldns_rr_list *rr); 803 804 /** 805 * push an rr on a packet 806 * \param[in] packet packet to operate on 807 * \param[in] section where to put it 808 * \param[in] rr rr to push 809 * \return a boolean which is true when the rr was added 810 */ 811 bool ldns_pkt_push_rr(ldns_pkt *packet, ldns_pkt_section section, ldns_rr *rr); 812 813 /** 814 * push an rr on a packet, provided the RR is not there. 815 * \param[in] pkt packet to operate on 816 * \param[in] sec where to put it 817 * \param[in] rr rr to push 818 * \return a boolean which is true when the rr was added 819 */ 820 bool ldns_pkt_safe_push_rr(ldns_pkt *pkt, ldns_pkt_section sec, ldns_rr *rr); 821 822 /** 823 * push a rr_list on a packet 824 * \param[in] packet packet to operate on 825 * \param[in] section where to put it 826 * \param[in] list the rr_list to push 827 * \return a boolean which is true when the rr was added 828 */ 829 bool ldns_pkt_push_rr_list(ldns_pkt *packet, ldns_pkt_section section, ldns_rr_list *list); 830 831 /** 832 * push an rr_list to a packet, provided the RRs are not already there. 833 * \param[in] pkt packet to operate on 834 * \param[in] sec where to put it 835 * \param[in] list the rr_list to push 836 * \return a boolean which is true when the rr was added 837 */ 838 bool ldns_pkt_safe_push_rr_list(ldns_pkt *pkt, ldns_pkt_section sec, ldns_rr_list *list); 839 840 /** 841 * check if a packet is empty 842 * \param[in] p packet 843 * \return true: empty, false: empty 844 */ 845 bool ldns_pkt_empty(ldns_pkt *p); 846 847 #endif /* LDNS_PACKET_H */ 848