- * contributors may be used to endorse or promote products derived from this

- * software without specific prior written permission.

- ******************************************************************************/

- ldns_pkt *$1_pkt;

- $1 = &$1_pkt;

-/* result generation */

- $result = SWIG_Python_AppendOutput($result, SWIG_NewPointerObj(SWIG_as_voidptr($1_pkt), SWIGTYPE_p_ldns_struct_pkt, SWIG_POINTER_OWN | 0 ));

-%nodefaultctor ldns_struct_pkt; //no default constructor & destructor

-%nodefaultdtor ldns_struct_pkt;

-#ifdef LDNS_DEBUG

-%rename(__ldns_pkt_free) ldns_pkt_free;

-%inline %{

-void _ldns_pkt_free (ldns_pkt* p) {

- printf("******** LDNS_PKT free 0x%lX ************\n", (long unsigned int)p);

- ldns_pkt_free(p);

-}

-%}

-#else

-%rename(_ldns_pkt_free) ldns_pkt_free;

-#endif

-/* cloning of packet_lists to make them independent of the original packet */

-%newobject _ldns_pkt_additional;

-%newobject _ldns_pkt_answer;

-%newobject _ldns_pkt_authority;

-%newobject _ldns_pkt_question;

-%inline %{

-ldns_rr_list* _ldns_pkt_additional(ldns_pkt* p) {

- return ldns_rr_list_clone(ldns_pkt_additional(p));

-}

-%inline %{

-ldns_rr_list* _ldns_pkt_answer(ldns_pkt* p) {

- return ldns_rr_list_clone(ldns_pkt_answer(p));

-}

-%inline %{

-ldns_rr_list* _ldns_pkt_authority(ldns_pkt* p) {

- return ldns_rr_list_clone(ldns_pkt_authority(p));

-}

-%inline %{

-ldns_rr_list* _ldns_pkt_question(ldns_pkt* p) {

- return ldns_rr_list_clone(ldns_pkt_question(p));

-}

-/* clone data when pushed in */

-%inline %{

-bool _ldns_pkt_push_rr(ldns_pkt* p, ldns_pkt_section sec, ldns_rr *rr) {

- return ldns_pkt_push_rr(p, sec, ldns_rr_clone(rr));

-}

-%inline %{

-bool _ldns_pkt_push_rr_list(ldns_pkt* p, ldns_pkt_section sec, ldns_rr_list *rrl) {

- return ldns_pkt_push_rr_list(p, sec, ldns_rr_list_clone(rrl));

-}

-The ldns_pkt object contains DNS packed (either a query or an answer). It is the complete representation of what you actually send to a nameserver, and what you get back (see :class:`ldns.ldns_resolver`).

-This simple example instances a resolver in order to resolve NS for nic.cz.

-"

- %pythoncode %{

- raise Exception("This class can't be created directly. Please use: ldns_pkt_new(), ldns_pkt_query_new() or ldns_pkt_query_new_frm_str()")

- #LDNS_PKT_CONSTRUCTORS_#

- """Creates a packet with a query in it for the given name, type and class.

-

- :param rr_name: the name to query for

- :param rr_type: the type to query for

- :param rr_class: the class to query for

- :param flags: packet flags

- :returns: new ldns_pkt object

- return _ldns.ldns_pkt_query_new(rr_name, rr_type, rr_class, flags)

- """Creates a query packet for the given name, type, class.

-

- :param rr_name: the name to query for

- :param rr_type: the type to query for

- :param rr_class: the class to query for

- :param flags: packet flags

- :param raiseException: if True, an exception occurs in case a resolver object can't be created

- :returns: query packet object or None. If the object can't be created and raiseException is True, an exception occurs.

- #_LDNS_PKT_CONSTRUCTORS#

- """Converts the data in the DNS packet to presentation format"""

- """Converts a packet opcode to its mnemonic and returns that as an allocated null-terminated string."""

- """Converts a packet rcode to its mnemonic and returns that as an allocated null-terminated string."""

- def print_to_file(self,output):

- """Prints the data in the DNS packet to the given file stream (in presentation format)."""

- _ldns.ldns_pkt_print(output,self)

- """Copies the packet data to the buffer in wire format.

- :param buffer: buffer to append the result to

- :returns: (ldns_status) ldns_status

- """Converts a signing algorithms to its mnemonic and returns that as an allocated null-terminated string."""

- """Converts a cert algorithm to its mnemonic and returns that as an allocated null-terminated string."""

- #LDNS_PKT_METHODS_#

- """Read the packet's aa bit.

- :returns: (bool) value of the bit

- """Read the packet's ad bit.

- :returns: (bool) value of the bit

- """Return the packet's additional section.

- :returns: (ldns_rr_list \*) the section

- """Return the packet's an count.

- :returns: (uint16_t) the an count

- """Return the packet's answer section.

- :returns: (ldns_rr_list \*) the section

- """Return the packet's answerfrom.

- :returns: (ldns_rdf \*) the name of the server

- return _ldns.ldns_pkt_answerfrom(self)

- """Return the packet's ar count.

- :returns: (uint16_t) the ar count

- """Return the packet's authority section.

- :returns: (ldns_rr_list \*) the section

- """Read the packet's cd bit.

- :returns: (bool) value of the bit

- """clones the given packet, creating a fully allocated copy

- :returns: (ldns_pkt \*) ldns_pkt* pointer to the new packet

- """returns true if this packet needs and EDNS rr to be sent.

- At the moment the only reason is an expected packet size larger than 512 bytes, but for instance dnssec would be a good reason too.

- :returns: (bool) true if packet needs edns rr

- """return the packet's edns data

- :returns: (ldns_rdf \*) the data

- return _ldns.ldns_pkt_edns_data(self)

- """return the packet's edns do bit

- :returns: (bool) the bit's value

- """return the packet's edns extended rcode

- :returns: (uint8_t) the rcode

- """return the packet's edns udp size

- :returns: (uint16_t) the size

- """return the packet's edns version

- :returns: (uint8_t) the version

- """return the packet's edns z value

- :returns: (uint16_t) the z value

- """check if a packet is empty

- :returns: (bool) true: empty, false: empty

- """Read the packet's code.

- :returns: (ldns_pkt_opcode) the opcode

- """Return the packet's respons code.

- :returns: (ldns_pkt_rcode) the respons code

- def get_section_clone(self,s):

- """return all the rr_list's in the packet.

-

- Clone the lists, instead of returning pointers.

- :param s:

- what section(s) to return

- :returns: (ldns_rr_list \*) ldns_rr_list with the rr's or NULL if none were found

- return _ldns.ldns_pkt_get_section_clone(self,s)

- """Read the packet id.

- :returns: (uint16_t) the packet id

- """Return the packet's ns count.

- :returns: (uint16_t) the ns count

- def push_rr(self,section,rr):

- """push an rr on a packet

- :param section:

- where to put it

- :param rr:

- rr to push

- :returns: (bool) a boolean which is true when the rr was added

- def push_rr_list(self,section,list):

- """push a rr_list on a packet

- :param section:

- where to put it

- :param list:

- the rr_list to push

- :returns: (bool) a boolean which is true when the rr was added

- """Return the packet's qd count.

- :returns: (uint16_t) the qd count

- """Read the packet's qr bit.

- :returns: (bool) value of the bit

- """Return the packet's querytime.

- :returns: (uint32_t) the querytime

- """Return the packet's question section.

- :returns: (ldns_rr_list \*) the section

- """Read the packet's ra bit.

- :returns: (bool) value of the bit

- """Read the packet's rd bit.

- :returns: (bool) value of the bit

- """looks inside the packet to determine what kind of packet it is, AUTH, NXDOMAIN, REFERRAL, etc.

- :returns: (ldns_pkt_type) the type of packet

- def rr(self,sec,rr):

- """check to see if an rr exist in the packet

- :param sec:

- in which section to look

- :param rr:

- the rr to look for

- :returns: (bool)

- return _ldns.ldns_pkt_rr(self,sec,rr)

- def rr_list_by_name(self,r,s):

- """return all the rr with a specific name from a packet.

-

- Optionally specify from which section in the packet

- :param r:

- the name

- :param s:

- the packet's section

- :returns: (ldns_rr_list \*) a list with the rr's or NULL if none were found

- def rr_list_by_name_and_type(self,ownername,atype,sec):

- """return all the rr with a specific type and type from a packet.

-

- Optionally specify from which section in the packet

- :param ownername:

- the name

- :param atype:

- :param sec:

- the packet's section

- :returns: (ldns_rr_list \*) a list with the rr's or NULL if none were found

- return _ldns.ldns_pkt_rr_list_by_name_and_type(self,ownername,atype,sec)

- def rr_list_by_type(self,t,s):

- """return all the rr with a specific type from a packet.

-

- Optionally specify from which section in the packet

- :param t:

- the type

- :param s:

- the packet's section

- :returns: (ldns_rr_list \*) a list with the rr's or NULL if none were found

- return _ldns.ldns_pkt_rr_list_by_type(self,t,s)

- def safe_push_rr(self,sec,rr):

- """push an rr on a packet, provided the RR is not there.

- :param sec:

- where to put it

- :param rr:

- rr to push

- :returns: (bool) a boolean which is true when the rr was added

- return _ldns.ldns_pkt_safe_push_rr(self,sec,rr)

- def safe_push_rr_list(self,sec,list):

- """push an rr_list to a packet, provided the RRs are not already there.

- :param sec:

- where to put it

- :param list:

- the rr_list to push

- :returns: (bool) a boolean which is true when the rr was added

- return _ldns.ldns_pkt_safe_push_rr_list(self,sec,list)

- def section_count(self,s):

- return _ldns.ldns_pkt_section_count(self,s)

- #parameters: const ldns_pkt *,ldns_pkt_section,

- #retvals: uint16_t

-

- def set_aa(self,b):

- """Set the packet's aa bit.

- :param b:

- the value to set (boolean)

- _ldns.ldns_pkt_set_aa(self,b)

- def set_ad(self,b):

- """Set the packet's ad bit.

- :param b:

- the value to set (boolean)

- _ldns.ldns_pkt_set_ad(self,b)

- def set_additional(self,rr):

- """directly set the additional section

- :param rr:

- rrlist to set

- _ldns.ldns_pkt_set_additional(self,rr)

- def set_ancount(self,c):

- """Set the packet's an count.

- :param c:

- the count

- _ldns.ldns_pkt_set_ancount(self,c)

- def set_answer(self,rr):

- """directly set the answer section

- :param rr:

- rrlist to set

- _ldns.ldns_pkt_set_answer(self,rr)

- def set_answerfrom(self,r):

- """Set the packet's answering server.

- :param r:

- the address

- _ldns.ldns_pkt_set_answerfrom(self,r)

- def set_arcount(self,c):

- """Set the packet's arcount.

- :param c:

- the count

- def set_authority(self,rr):

- """directly set the auhority section

- :param rr:

- rrlist to set

- _ldns.ldns_pkt_set_authority(self,rr)

- def set_cd(self,b):

- """Set the packet's cd bit.

- :param b:

- the value to set (boolean)

- _ldns.ldns_pkt_set_cd(self,b)

- def set_edns_data(self,data):

- """Set the packet's edns data.

- :param data:

- the data

- _ldns.ldns_pkt_set_edns_data(self,data)

- def set_edns_do(self,value):

- """Set the packet's edns do bit.

- :param value:

- the bit's new value

- _ldns.ldns_pkt_set_edns_do(self,value)

- def set_edns_extended_rcode(self,c):

- """Set the packet's edns extended rcode.

- :param c:

- the code

- _ldns.ldns_pkt_set_edns_extended_rcode(self,c)

- def set_edns_udp_size(self,s):

- """Set the packet's edns udp size.

- :param s:

- the size

- _ldns.ldns_pkt_set_edns_udp_size(self,s)

- def set_edns_version(self,v):

- """Set the packet's edns version.

- :param v:

- the version

- _ldns.ldns_pkt_set_edns_version(self,v)

- def set_edns_z(self,z):

- """Set the packet's edns z value.

- :param z:

- the value

- _ldns.ldns_pkt_set_edns_z(self,z)

- def set_flags(self,flags):

- """sets the flags in a packet.

- :param flags:

- ORed values: LDNS_QR| LDNS_AR for instance

- :returns: (bool) true on success otherwise false

- return _ldns.ldns_pkt_set_flags(self,flags)

- def set_id(self,id):

- """Set the packet's id.

- :param id:

- the id to set

- _ldns.ldns_pkt_set_id(self,id)

- def set_nscount(self,c):

- """Set the packet's ns count.

- :param c:

- the count

- _ldns.ldns_pkt_set_nscount(self,c)

- def set_opcode(self,c):

- """Set the packet's opcode.

- :param c:

- the opcode

- _ldns.ldns_pkt_set_opcode(self,c)

- def set_qdcount(self,c):

- """Set the packet's qd count.

- :param c:

- the count

- _ldns.ldns_pkt_set_qdcount(self,c)

- def set_qr(self,b):

- """Set the packet's qr bit.

- :param b:

- the value to set (boolean)

- _ldns.ldns_pkt_set_qr(self,b)

- def set_querytime(self,t):

- """Set the packet's query time.

- :param t:

- the querytime in msec

- _ldns.ldns_pkt_set_querytime(self,t)

- def set_question(self,rr):

- """directly set the question section

- :param rr:

- rrlist to set

- _ldns.ldns_pkt_set_question(self,rr)

- def set_ra(self,b):

- """Set the packet's ra bit.

- :param b:

- the value to set (boolean)

- _ldns.ldns_pkt_set_ra(self,b)

- """Set the packet's id to a random value.

- def set_rcode(self,c):

- """Set the packet's respons code.

- :param c:

- the rcode

- _ldns.ldns_pkt_set_rcode(self,c)

- def set_rd(self,b):

- """Set the packet's rd bit.

- :param b:

- the value to set (boolean)

- _ldns.ldns_pkt_set_rd(self,b)

- def set_section_count(self,s,x):

- """Set a packet's section count to x.

- :param s:

- the section

- :param x:

- the section count

- _ldns.ldns_pkt_set_section_count(self,s,x)

- def set_size(self,s):

- """Set the packet's size.

- :param s:

- the size

- def set_tc(self,b):

- """Set the packet's tc bit.

- :param b:

- the value to set (boolean)

- _ldns.ldns_pkt_set_tc(self,b)

- def set_timestamp(self,timeval):

- _ldns.ldns_pkt_set_timestamp(self,timeval)

- def set_tsig(self,t):

- """Set the packet's tsig rr.

- :param t:

- the tsig rr

- _ldns.ldns_pkt_set_tsig(self,t)

- """Return the packet's size in bytes.

- :returns: (size_t) the size

- """Read the packet's tc bit.

- :returns: (bool) value of the bit

- """Return the packet's timestamp.

- :returns: (struct timeval) the timestamp

- """Return the packet's tsig pseudo rr's.

- :returns: (ldns_rr \*) the tsig rr

- return _ldns.ldns_pkt_tsig(self)

- #_LDNS_PKT_METHODS#

- #LDNS update methods

- #LDNS_METHODS_#

- def update_pkt_tsig_add(self,r):

- """add tsig credentials to a packet from a resolver

- :param r:

- resolver to copy from

- :returns: (ldns_status) status wether successfull or not

- return _ldns.ldns_update_pkt_tsig_add(self,r)

- """Get the zo count.

- :returns: (uint16_t) the pr count

- def update_set_adcount(self,c):

- """Set the ad count.

- :param c:

- the ad count to set

- _ldns.ldns_update_set_adcount(self,c)

- def update_set_prcount(self,c):

- """Set the pr count.

- :param c:

- the pr count to set

- _ldns.ldns_update_set_prcount(self,c)

- def update_set_upcount(self,c):

- """Set the up count.

- :param c:

- the up count to set

- def update_set_zo(self,v):

- _ldns.ldns_update_set_zo(self,v)

- """Get the zo count.

- :returns: (uint16_t) the up count

- """Get the zo count.

- :returns: (uint16_t) the zo count

- #_LDNS_METHODS#

- %}