contrib/ldns/ldns/packet.h

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