diff options
Diffstat (limited to 'contrib/python')
| -rw-r--r-- | contrib/python/Changelog | 26 | ||||
| -rw-r--r-- | contrib/python/Makefile | 6 | ||||
| -rw-r--r-- | contrib/python/docs/source/conf.py | 4 | ||||
| -rw-r--r-- | contrib/python/docs/source/modules/ldns_rdf.rst | 2 | ||||
| -rwxr-xr-x | contrib/python/examples/test_buffer.py | 16 | ||||
| -rwxr-xr-x | contrib/python/examples/test_dname.py | 2 | ||||
| -rwxr-xr-x | contrib/python/examples/test_pkt.py | 1937 | ||||
| -rwxr-xr-x | contrib/python/examples/test_rdf.py | 23 | ||||
| -rwxr-xr-x | contrib/python/examples/test_resolver.py | 1751 | ||||
| -rw-r--r-- | contrib/python/examples/test_rr.py | 20 | ||||
| -rw-r--r-- | contrib/python/ldns_packet.i | 1348 | ||||
| -rw-r--r-- | contrib/python/ldns_rdf.i | 42 | ||||
| -rw-r--r-- | contrib/python/ldns_resolver.i | 1278 |
13 files changed, 5617 insertions, 838 deletions
diff --git a/contrib/python/Changelog b/contrib/python/Changelog index aaa57e13692b5..7c4ccd1187d4f 100644 --- a/contrib/python/Changelog +++ b/contrib/python/Changelog @@ -1,3 +1,29 @@ +1.6.17 2014-01-10 + * Added ldns_rdf.data_as_bytearray(). The method returns a bytearray object + containing rdf data. + * Changed the behaviour of ldns_resolver.trusted_key() in order to prevent + memory corrupotion and leaks. + * Fixed memory leaks when destroying ldns_resolver. + * Removed ldns_pkt.section_count(), ldns_resolver.set_searchlist_count() + because it is marked static in the library. + * Added ldns_pkt.new(), ldns_resolver.new(). + * Marked as returning new object ldns_pkt.get_section_clone(), + ldns_resolver.get_addr_by_name(), ldns_resolver.get_name_by_addr(), + ldns_resolver.search(). + * Added push cloning for ldns_pkt.safe_push_rr(), + ldns_pkt.safe_push_rr_list(), ldns_pkt.set_additional(), + ldns_pkt.set_answer(), ldns_pkt.set_answerfrom(), + ldns_pkt.set_authority(), ldns_pkt.set_edns_data(), + ldns_pkt.set_question(), ldns_pkt.set_tsig(), + ldns_resolver.set_dnssec_anchors(), ldns_resolver.set_domain(). + * Added pull cloning for ldns_pkt.answerfrom(), ldns_pkt.edns_data(), + ldns_pkt.tsig(), ldns_resolver.axfr_last_pkt(), + ldns_resolver.dnssec_anchors(), ldns_resolver.domain(), + ldns_resolver.tsig_algorithm(), ldns_resolver.tsig_keydata(), + ldns_resolver.tsig_keyname(). + * Method ldns_rdf.reverse() now throws an exception when not applied + on dname rdfs. This is to prevent assertion fails in ldns' C code. + 1.6.16 2012-11-13 * Fix typo in ldns_struct_pkt.opcode2str diff --git a/contrib/python/Makefile b/contrib/python/Makefile index 927685764bbf6..debc7d0486d2c 100644 --- a/contrib/python/Makefile +++ b/contrib/python/Makefile @@ -41,7 +41,7 @@ help: ../../Makefile: ../../configure cd ../.. && ./configure --with-python -_ldns.so: ../../Makefile +_ldns.so: ../../Makefile $(MAKE) -C ../.. ../../.libs/libldns.so.1: ../../Makefile @@ -59,13 +59,15 @@ testenv: ../../.libs/libldns.so.1 _ldns.so cd examples && LD_LIBRARY_PATH=ldns bash rm -rf examples/ldns -test: ../../.libs/libldns.so.1 _ldns.so examples/test_buffer.py examples/test_rdf.py examples/test_dname.py examples/test_rr.py +test: ../../.libs/libldns.so.1 _ldns.so examples/test_buffer.py examples/test_rdf.py examples/test_dname.py examples/test_rr.py examples/test_pkt.py examples/test_resolver.py @rm -rf examples/ldns @cd examples && mkdir ldns && ln -s ../../ldns.py ldns/__init__.py && ln -s ../../../../.libs/_ldns.so ldns/_ldns.so && ln -s ../../../../.libs/libldns.so.1 ldns/libldns.so.1 @cd examples && LD_LIBRARY_PATH=ldns ./test_buffer.py 2>/dev/null @cd examples && LD_LIBRARY_PATH=ldns ./test_rdf.py 2>/dev/null @cd examples && LD_LIBRARY_PATH=ldns ./test_dname.py 2>/dev/null @cd examples && LD_LIBRARY_PATH=ldns ./test_rr.py 2>/dev/null + @cd examples && LD_LIBRARY_PATH=ldns ./test_pkt.py 2>/dev/null + @cd examples && LD_LIBRARY_PATH=ldns ./test_resolver.py 2>/dev/null @rm -rf examples/ldns doc: ../../.libs/libldns.so.1 _ldns.so diff --git a/contrib/python/docs/source/conf.py b/contrib/python/docs/source/conf.py index 4d891543b1a32..468b827d8bfbe 100644 --- a/contrib/python/docs/source/conf.py +++ b/contrib/python/docs/source/conf.py @@ -37,7 +37,7 @@ master_doc = 'index' # General substitutions. project = 'pyLDNS' -copyright = '2009, Karel Slany, Zdenek Vasicek' +copyright = '2009-2013, Karel Slany, Zdenek Vasicek' # The default replacements for |version| and |release|, also used in various # other places throughout the built documents. @@ -45,7 +45,7 @@ copyright = '2009, Karel Slany, Zdenek Vasicek' # The short X.Y version. version = '1.6' # The full version, including alpha/beta/rc tags. -release = '1.6.16' +release = '1.6.17' # There are two options for replacing |today|: either, you set today to some # non-false value, then it is used: diff --git a/contrib/python/docs/source/modules/ldns_rdf.rst b/contrib/python/docs/source/modules/ldns_rdf.rst index 5ed1799b1bb17..4a482e4443984 100644 --- a/contrib/python/docs/source/modules/ldns_rdf.rst +++ b/contrib/python/docs/source/modules/ldns_rdf.rst @@ -35,7 +35,7 @@ Predefined constants * LDNS_RDF_TYPE_TIME, * LDNS_RDF_TYPE_PERIOD, * LDNS_RDF_TYPE_TSIGTIME, - * LDNS_RDF_TYPE_TSIG, + * LDNS_RDF_TYPE_HIP, * LDNS_RDF_TYPE_INT16_DATA, * LDNS_RDF_TYPE_SERVICE, * LDNS_RDF_TYPE_LOC, diff --git a/contrib/python/examples/test_buffer.py b/contrib/python/examples/test_buffer.py index 0baf76f6ab02f..472bd6fdbf4d0 100755 --- a/contrib/python/examples/test_buffer.py +++ b/contrib/python/examples/test_buffer.py @@ -174,7 +174,7 @@ if True: ret = buf.capacity() except: set_error() - if not isinstance(ret, int): + if (not isinstance(ret, int)) and (not isinstance(ret, long)): # Should be int. set_error() @@ -284,7 +284,7 @@ if True: ret = buf.position() except: set_error() - if not isinstance(ret, int): + if (not isinstance(ret, int)) and (not isinstance(ret, long)): set_error() @@ -328,7 +328,7 @@ if True: ret = buf.read_u16() except: set_error() - if not isinstance(ret, int): + if (not isinstance(ret, int)) and (not isinstance(ret, long)): set_error() if ret != (ord("a") * 0x0101): set_error() @@ -343,7 +343,7 @@ if True: ret = buf.read_u16_at(1) except: set_error() - if not isinstance(ret, int): + if (not isinstance(ret, int)) and (not isinstance(ret, long)): set_error() if ret != (ord("b") * 0x0101): set_error() @@ -418,7 +418,7 @@ if True: ret = buf.read_u8() except: set_error() - if not isinstance(ret, int): + if (not isinstance(ret, int)) and (not isinstance(ret, long)): set_error() if ret != ord("a"): set_error() @@ -433,7 +433,7 @@ if True: ret = buf.read_u8_at(1) except: set_error() - if not isinstance(ret, int): + if (not isinstance(ret, int)) and (not isinstance(ret, long)): set_error() if ret != ord("b"): set_error() @@ -462,7 +462,7 @@ if True: ret = buf.remaining() except: set_error() - if not isinstance(ret, int): + if (not isinstance(ret, int)) and (not isinstance(ret, long)): set_error() if ret != (capacity - 6): set_error() @@ -477,7 +477,7 @@ if True: ret = buf.remaining_at(1) except: set_error() - if not isinstance(ret, int): + if (not isinstance(ret, int)) and (not isinstance(ret, long)): set_error() if ret != (capacity - 1): set_error() diff --git a/contrib/python/examples/test_dname.py b/contrib/python/examples/test_dname.py index d69170737acc0..07e0a85070d62 100755 --- a/contrib/python/examples/test_dname.py +++ b/contrib/python/examples/test_dname.py @@ -388,7 +388,7 @@ if True: dn = ldns.ldns_dname("www.nic.cz.") try: ret = dn.label_count() - if not isinstance(ret, int): + if (not isinstance(ret, int)) and (not isinstance(ret, long)): set_error() if ret != 3: set_error() diff --git a/contrib/python/examples/test_pkt.py b/contrib/python/examples/test_pkt.py new file mode 100755 index 0000000000000..7ecb7bd8cc41d --- /dev/null +++ b/contrib/python/examples/test_pkt.py @@ -0,0 +1,1937 @@ +#!/usr/bin/env python + +# +# ldns_pkt testing script. +# +# Do not use constructs that differ between Python 2 and 3. +# Use write on stdout or stderr. +# + + +import ldns +import sys +import os +import inspect + + +class_name = "ldns_pkt" +method_name = None +error_detected = False +temp_fname = "tmp_pkt.txt" + + +def set_error(): + """ + Writes an error message and sets error flag. + """ + global class_name + global method_name + global error_detected + error_detected = True + sys.stderr.write("(line %d): malfunctioning method %s.\n" % \ + (inspect.currentframe().f_back.f_lineno, method_name)) + + +#if not error_detected: +if True: + method_name = class_name + ".aa()" + pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_QR | ldns.LDNS_AA) + try: + ret = pkt.aa() + if not isinstance(ret, bool): + set_error() + if ret != True: + set_error() + except: + set_error() + pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_QR) + try: + ret = pkt.aa() + if not isinstance(ret, bool): + set_error() + if ret != False: + set_error() + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".ad()" + pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_QR | ldns.LDNS_AD) + try: + ret = pkt.ad() + if not isinstance(ret, bool): + set_error() + if ret != True: + set_error() + except: + set_error() + pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_QR) + try: + ret = pkt.ad() + if not isinstance(ret, bool): + set_error() + if ret != False: + set_error() + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".additional()" + pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_QR | ldns.LDNS_AD) + try: + ret = pkt.additional() + if not isinstance(ret, ldns.ldns_rr_list): + set_error() + if ret.rr_count() != 0: + set_error() + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".algorithm2str()" + try: + ret = ldns.ldns_pkt.algorithm2str(ldns.LDNS_DSA) + if not isinstance(ret, str): + set_error() + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".all()" + pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_QR | ldns.LDNS_AD) + try: + ret = pkt.all() + if not isinstance(ret, ldns.ldns_rr_list): + set_error() + if ret.rr_count() != 1: + set_error() + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".all_noquestion()" + pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_QR | ldns.LDNS_AD) + try: + ret = pkt.all_noquestion() + if not isinstance(ret, ldns.ldns_rr_list): + set_error() + if ret.rr_count() != 0: + set_error() + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".ancount()" + pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_QR | ldns.LDNS_AD) + try: + ret = pkt.ancount() + if (not isinstance(ret, int)) and (not isinstance(ret, long)): + set_error() + if ret != 0: + set_error() + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".answer()" + pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_QR | ldns.LDNS_AD) + try: + ret = pkt.answer() + if not isinstance(ret, ldns.ldns_rr_list): + set_error() + if ret.rr_count() != 0: + set_error() + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".answerfrom()" + pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_QR | ldns.LDNS_AD) + try: + ret = pkt.answerfrom() + if ret != None: + set_error() + except: + set_error() + resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") + pkt = resolver.query("www.nic.cz", ldns.LDNS_RR_TYPE_A, ldns.LDNS_RR_CLASS_IN) + try: + ret = pkt.answerfrom() + if not isinstance(ret, ldns.ldns_rdf): + set_error() + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".arcount()" + pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_QR | ldns.LDNS_AD) + try: + ret = pkt.arcount() + if (not isinstance(ret, int)) and (not isinstance(ret, long)): + set_error() + if ret != 0: + set_error() + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".authority()" + pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_QR | ldns.LDNS_AD) + try: + ret = pkt.authority() + if not isinstance(ret, ldns.ldns_rr_list): + set_error() + if ret.rr_count() != 0: + set_error() + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".cd()" + pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_CD) + try: + ret = pkt.cd() + if not isinstance(ret, bool): + set_error() + if ret != True: + set_error() + except: + set_error() + pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_QR) + try: + ret = pkt.cd() + if not isinstance(ret, bool): + set_error() + if ret != False: + set_error() + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".cert_algorithm2str()" + try: + ret = ldns.ldns_pkt.cert_algorithm2str(ldns.LDNS_CERT_PGP) + if not isinstance(ret, str): + set_error() + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".clone()" + pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_QR | ldns.LDNS_AD) + try: + ret = pkt.clone() + if not isinstance(ret, ldns.ldns_pkt): + set_error() + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".ends()" + pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD | ldns.LDNS_AD) + try: + ret = pkt.edns() + if not isinstance(ret, bool): + set_error() + if ret != False: + set_error() + except: + set_error() + resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") + resolver.set_dnssec(True) + pkt = resolver.query("www.nic.cz", ldns.LDNS_RR_TYPE_A, ldns.LDNS_RR_CLASS_IN) + try: + ret = pkt.edns() + if not isinstance(ret, bool): + set_error() + if ret != True: + set_error() + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".ends_data()" + pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD | ldns.LDNS_AD) + try: + ret = pkt.edns_data() + if ret != None: + set_error() + except: + set_error() + #resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") + #resolver.set_dnssec(True) + #pkt = resolver.query("www.nic.cz", ldns.LDNS_RR_TYPE_A, ldns.LDNS_RR_CLASS_IN) + #try: + # ret = pkt.edns_data() + # print ret + # if not isinstance(ret, ldns.ldns_rdf): + # set_error() + # if ret != True: + # set_error() + #except: + # set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".edns_do()" + pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD | ldns.LDNS_AD) + try: + ret = pkt.edns_do() + if not isinstance(ret, bool): + set_error() + if ret != False: + set_error() + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".edns_extended_rcode()" + pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD | ldns.LDNS_AD) + try: + ret = pkt.edns_extended_rcode() + if (not isinstance(ret, int)) and (not isinstance(ret, long)): + set_error() + if ret != 0: + set_error() + except: + set_error() + #resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") + #resolver.set_dnssec(True) + #pkt = resolver.query("www.nic.cz", ldns.LDNS_RR_TYPE_A, ldns.LDNS_RR_CLASS_IN) + #try: + # ret = pkt.edns_extended_rcode() + # if (not isinstance(ret, int)) and (not isinstance(ret, long)): + # set_error() + # if ret != 0: + # set_error() + #except: + # set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".edns_udp_size()" + pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD | ldns.LDNS_AD) + try: + ret = pkt.edns_udp_size() + if (not isinstance(ret, int)) and (not isinstance(ret, long)): + set_error() + if ret != 0: + set_error() + except: + set_error() + resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") + resolver.set_dnssec(True) + pkt = resolver.query("www.nic.cz", ldns.LDNS_RR_TYPE_A, ldns.LDNS_RR_CLASS_IN) + try: + ret = pkt.edns_udp_size() + if (not isinstance(ret, int)) and (not isinstance(ret, long)): + set_error() + if ret == 0: # Don't know the actual size, but must be greater than 0. + set_error() + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".edns_version()" + pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD | ldns.LDNS_AD) + try: + ret = pkt.edns_version() + if (not isinstance(ret, int)) and (not isinstance(ret, long)): + set_error() + if ret != 0: + set_error() + except: + set_error() + #resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") + #resolver.set_dnssec(True) + #pkt = resolver.query("www.nic.cz", ldns.LDNS_RR_TYPE_A, ldns.LDNS_RR_CLASS_IN) + #try: + # ret = pkt.edns_version() + # if (not isinstance(ret, int)) and (not isinstance(ret, long)): + # set_error() + # if ret != 0: + # set_error() + #except: + # set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".edns_z()" + pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD | ldns.LDNS_AD) + try: + ret = pkt.edns_z() + if (not isinstance(ret, int)) and (not isinstance(ret, long)): + set_error() + if ret != 0: + set_error() + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".empty()" + pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD | ldns.LDNS_AD) + try: + ret = pkt.empty() + if not isinstance(ret, bool): + set_error() + if ret != False: + set_error() + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".get_opcode()" + pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD | ldns.LDNS_AD) + try: + ret = pkt.get_opcode() + if (not isinstance(ret, int)) and (not isinstance(ret, long)): + set_error() + if ret != ldns.LDNS_PACKET_QUERY: + set_error() + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".get_rcode()" + pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD | ldns.LDNS_AD) + try: + ret = pkt.get_rcode() + if (not isinstance(ret, int)) and (not isinstance(ret, long)): + set_error() + if ret != ldns.LDNS_RCODE_NOERROR: + set_error() + except: + set_error() + resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") + resolver.set_dnssec(True) + pkt = resolver.query("nonexistent_domain.nic.cz", ldns.LDNS_RR_TYPE_A, ldns.LDNS_RR_CLASS_IN) + try: + ret = pkt.get_rcode() + if (not isinstance(ret, int)) and (not isinstance(ret, long)): + set_error() + if ret != ldns.LDNS_RCODE_NXDOMAIN: + set_error() + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".get_section_clone()" + pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD | ldns.LDNS_AD) + try: + ret = pkt.get_section_clone(ldns.LDNS_SECTION_ANY) + if not isinstance(ret, ldns.ldns_rr_list): + set_error() + except: + set_error() + try: + ret = pkt.get_section_clone(ldns.LDNS_SECTION_ANSWER) + if not isinstance(ret, ldns.ldns_rr_list): + set_error() + except: + set_error() + try: + ret = pkt.get_section_clone("bad argument") + set_error() + except TypeError as e: + pass + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".id()" + pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD | ldns.LDNS_AD) + try: + ret = pkt.id() + if (not isinstance(ret, int)) and (not isinstance(ret, long)): + set_error() + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".new()" + try: + pkt = ldns.ldns_pkt.new() + if not isinstance(pkt, ldns.ldns_pkt): + set_error() + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".new_query()" + dname = ldns.ldns_dname("test.nic.cz.") + try: + pkt = ldns.ldns_pkt.new_query(dname, ldns.LDNS_RR_TYPE_A, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_QR | ldns.LDNS_RD) + if not isinstance(pkt, ldns.ldns_pkt): + set_error() + except: + set_error() + rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "test.nic.cz.") + try: + pkt = ldns.ldns_pkt.new_query(rdf, ldns.LDNS_RR_TYPE_A, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_QR | ldns.LDNS_RD) + if not isinstance(pkt, ldns.ldns_pkt): + set_error() + except: + set_error() + try: + pkt = ldns.ldns_pkt.new_query("bad argument", ldns.LDNS_RR_TYPE_A, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_QR | ldns.LDNS_RD) + set_error() + except TypeError as e: + pass + except: + set_error() + try: + pkt = ldns.ldns_pkt.new_query(dname, "bad argument", ldns.LDNS_RR_CLASS_IN, ldns.LDNS_QR | ldns.LDNS_RD) + set_error() + except TypeError as e: + pass + except: + set_error() + try: + pkt = ldns.ldns_pkt.new_query(dname, ldns.LDNS_RR_TYPE_A, "bad argument", ldns.LDNS_QR | ldns.LDNS_RD) + set_error() + except TypeError as e: + pass + except: + set_error() + try: + pkt = ldns.ldns_pkt.new_query(dname, ldns.LDNS_RR_TYPE_A, ldns.LDNS_RR_CLASS_IN, "bad argument") + set_error() + except TypeError as e: + pass + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".new_query_frm_str()" + try: + pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz", ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_QR | ldns.LDNS_AA) + except: + set_error() + try: + pkt = ldns.ldns_pkt.new_query_frm_str(pkt, ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_QR | ldns.LDNS_AA) + set_error() + except TypeError as e: + pass + except: + set_error() + try: + pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz", "bad argument", ldns.LDNS_RR_CLASS_IN, ldns.LDNS_QR | ldns.LDNS_AA) + set_error() + except TypeError as e: + pass + except: + set_error() + try: + pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz", ldns.LDNS_RR_TYPE_ANY, "bad argument", ldns.LDNS_QR | ldns.LDNS_AA) + set_error() + except TypeError as e: + pass + except: + set_error() + try: + pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz", ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, "bad argument") + set_error() + except TypeError as e: + pass + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".nscount()" + pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD | ldns.LDNS_AD) + try: + ret = pkt.nscount() + if (not isinstance(ret, int)) and (not isinstance(ret, long)): + set_error() + if ret != 0: + set_error() + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".opcode2str()" + pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD | ldns.LDNS_AD) + try: + ret = pkt.opcode2str() + if not isinstance(ret, str): + set_error() + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".print_to_file()" + pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD | ldns.LDNS_AD) + f = open(temp_fname, "w") + try: + pkt.print_to_file(f) + except: + set_error() + f.close() + f = open(temp_fname, "r") + if len(f.readlines()) != 14: + set_error() + f.close() + os.remove(temp_fname) + + +#if not error_detected: +if True: + method_name = class_name + ".push_rr()" + pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD | ldns.LDNS_AD) + rr = ldns.ldns_rr.new_frm_str("test1 600 IN A 0.0.0.0") + try: + ret = pkt.push_rr(ldns.LDNS_SECTION_ANSWER, rr) + if not isinstance(ret, bool): + set_error() + if ret != True: + set_error() + except: + set_error() + try: + ret = pkt.push_rr("bad argument", rr) + set_error() + except TypeError as e: + pass + except: + set_error() + try: + ret = pkt.push_rr(ldns.LDNS_SECTION_ANSWER, "bad argument") + set_error() + except TypeError as e: + pass + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".push_rr_list()" + pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD | ldns.LDNS_AD) + rrl = ldns.ldns_rr_list.new() + rr = ldns.ldns_rr.new_frm_str("test1 600 IN A 0.0.0.0") + rrl.push_rr(rr) + rrl.push_rr(rr) + try: + ret = pkt.push_rr_list(ldns.LDNS_SECTION_ANSWER, rrl) + if not isinstance(ret, bool): + set_error() + if ret != True: + set_error() + except: + set_error() + try: + ret = pkt.push_rr_list("bad argument", rrl) + set_error() + except TypeError as e: + pass + except: + set_error() + try: + ret = pkt.push_rr_list(ldns.LDNS_SECTION_ANSWER, "bad argument") + set_error() + except TypeError as e: + pass + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".qdcount()" + pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_QR | ldns.LDNS_AD) + try: + ret = pkt.qdcount() + if (not isinstance(ret, int)) and (not isinstance(ret, long)): + set_error() + if ret != 1: + set_error() + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".qr()" + pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_QR | ldns.LDNS_AA) + try: + ret = pkt.qr() + if not isinstance(ret, bool): + set_error() + if ret != True: + set_error() + except: + set_error() + pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_AA) + try: + ret = pkt.qr() + if not isinstance(ret, bool): + set_error() + if ret != False: + set_error() + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".querytime()" + pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_QR | ldns.LDNS_AD) + try: + ret = pkt.querytime() + if (not isinstance(ret, int)) and (not isinstance(ret, long)): + set_error() + if ret != 0: + set_error() + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".question()" + pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_QR | ldns.LDNS_AD) + try: + ret = pkt.question() + if not isinstance(ret, ldns.ldns_rr_list): + set_error() + if ret.rr_count() != 1: + set_error() + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".ra()" + pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_QR | ldns.LDNS_RA) + try: + ret = pkt.ra() + if not isinstance(ret, bool): + set_error() + if ret != True: + set_error() + except: + set_error() + pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_QR) + try: + ret = pkt.ra() + if not isinstance(ret, bool): + set_error() + if ret != False: + set_error() + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".rcode2str()" + pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_QR | ldns.LDNS_RA) + try: + ret = pkt.rcode2str() + if not isinstance(ret, str): + set_error() + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".rd()" + pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_QR | ldns.LDNS_RD) + try: + ret = pkt.rd() + if not isinstance(ret, bool): + set_error() + if ret != True: + set_error() + except: + set_error() + pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_QR) + try: + ret = pkt.rd() + if not isinstance(ret, bool): + set_error() + if ret != False: + set_error() + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".reply_type()" + pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_QR | ldns.LDNS_RD) + try: + ret = pkt.reply_type() + if ret != ldns.LDNS_PACKET_ANSWER: + set_error() + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".rr()" + pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz", ldns.LDNS_RR_TYPE_A, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_QR | ldns.LDNS_RD) + rr = ldns.ldns_rr.new_frm_str("test1 600 IN A 0.0.0.0") + pkt.push_rr(ldns.LDNS_SECTION_ANSWER, rr) + try: + ret = pkt.rr(ldns.LDNS_SECTION_ANSWER, rr) + if not isinstance(ret, bool): + set_error() + if ret != True: + set_error() + except: + set_error() + try: + ret = pkt.rr(ldns.LDNS_SECTION_QUESTION, rr) + if not isinstance(ret, bool): + set_error() + if ret != False: + set_error() + except: + set_error() + try: + ret = pkt.rr("bad argument", rr) + set_error() + except TypeError as e: + pass + except: + set_error() + try: + ret = pkt.rr(ldns.LDNS_SECTION_QUESTION, "bad argument") + set_error() + except TypeError as e: + pass + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".rr_list_by_name()" + pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz", ldns.LDNS_RR_TYPE_A, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_QR | ldns.LDNS_RD) + rr = ldns.ldns_rr.new_frm_str("test1 600 IN A 0.0.0.0") + pkt.push_rr(ldns.LDNS_SECTION_ANSWER, rr) + rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "test1") + try: + ret = pkt.rr_list_by_name(rdf, ldns.LDNS_SECTION_ANSWER) + if not isinstance(ret, ldns.ldns_rr_list): + set_error() + except: + set_error() + try: + ret = pkt.rr_list_by_name(rdf, ldns.LDNS_SECTION_QUESTION) + if ret != None: + set_error() + except: + set_error() + try: + ret = pkt.rr_list_by_name("bad argument", ldns.LDNS_SECTION_ANSWER) + set_error() + except TypeError as e: + pass + except: + set_error() + try: + ret = pkt.rr_list_by_name(rdf, "bad argument") + set_error() + except TypeError as e: + pass + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".rr_list_by_name_and_type()" + pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz.", ldns.LDNS_RR_TYPE_A, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_QR | ldns.LDNS_RD) + rr = ldns.ldns_rr.new_frm_str("test1 600 IN A 0.0.0.0") + pkt.push_rr(ldns.LDNS_SECTION_ANSWER, rr) + rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "test1") + try: + ret = pkt.rr_list_by_name_and_type(rdf, ldns.LDNS_RR_TYPE_A, ldns.LDNS_SECTION_ANSWER) + if not isinstance(ret, ldns.ldns_rr_list): + set_error() + except: + set_error() + try: + ret = pkt.rr_list_by_name_and_type(rdf, ldns.LDNS_RR_TYPE_AAAA, ldns.LDNS_SECTION_ANSWER) + if ret != None: + set_error() + except: + set_error() + #try: + # ret = pkt.rr_list_by_name_and_type("bad argument", ldns.LDNS_RR_TYPE_A, ldns.LDNS_SECTION_ANSWER) + # set_error() + #except TypeError as e: + # pass + #except: + # set_error() + try: + ret = pkt.rr_list_by_name_and_type(rdf, "bad argument", ldns.LDNS_SECTION_ANSWER) + set_error() + except TypeError as e: + pass + except: + set_error() + try: + ret = pkt.rr_list_by_name_and_type(rdf, ldns.LDNS_RR_TYPE_A, "bad argument") + set_error() + except TypeError as e: + pass + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".rr_list_by_type()" + pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz.", ldns.LDNS_RR_TYPE_A, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_QR | ldns.LDNS_RD) + rr = ldns.ldns_rr.new_frm_str("test1 600 IN A 0.0.0.0") + pkt.push_rr(ldns.LDNS_SECTION_ANSWER, rr) + try: + ret = pkt.rr_list_by_type(ldns.LDNS_RR_TYPE_A, ldns.LDNS_SECTION_ANSWER) + if not isinstance(ret, ldns.ldns_rr_list): + set_error() + except: + set_error() + try: + ret = pkt.rr_list_by_type(ldns.LDNS_RR_TYPE_AAAA, ldns.LDNS_SECTION_ANSWER) + if ret != None: + set_error() + except: + set_error() + try: + ret = pkt.rr_list_by_type("bad argument", ldns.LDNS_SECTION_ANSWER) + set_error() + except TypeError as e: + pass + except: + set_error() + try: + ret = pkt.rr_list_by_type(ldns.LDNS_RR_TYPE_A, "bad argument") + set_error() + except TypeError as e: + pass + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".safe_push_rr()" + pkt = ldns.ldns_pkt.new() + rr = ldns.ldns_rr.new_frm_str("test1 600 IN A 0.0.0.0") + try: + ret = pkt.safe_push_rr(ldns.LDNS_SECTION_ANSWER, rr) + if not isinstance(ret, bool): + set_error() + if ret != True: + set_error() + except: + set_error() + try: + ret = pkt.safe_push_rr(ldns.LDNS_SECTION_ANSWER, rr) + if not isinstance(ret, bool): + set_error() + if ret != False: + set_error() + except: + set_error() + try: + ret = pkt.safe_push_rr("bad argument", rr) + set_error() + except TypeError as e: + pass + except: + set_error() + try: + ret = pkt.safe_push_rr(ldns.LDNS_SECTION_ANSWER, "bad argument") + set_error() + except TypeError as e: + pass + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".safe_push_rr_list()" + pkt = ldns.ldns_pkt.new() + rrl = ldns.ldns_rr_list.new() + rr = ldns.ldns_rr.new_frm_str("test1 600 IN A 0.0.0.0") + rrl.push_rr(rr) + try: + ret = pkt.safe_push_rr_list(ldns.LDNS_SECTION_ANSWER, rrl) + if not isinstance(ret, bool): + set_error() + if ret != True: + set_error() + except: + set_error() + try: + ret = pkt.safe_push_rr_list(ldns.LDNS_SECTION_ANSWER, rrl) + if not isinstance(ret, bool): + set_error() + if ret != False: + set_error() + except: + set_error() + try: + ret = pkt.safe_push_rr_list("bad argument", rrl) + set_error() + except TypeError as e: + pass + except: + set_error() + try: + ret = pkt.safe_push_rr_list(ldns.LDNS_SECTION_ANSWER, "bad argument") + set_error() + except TypeError as e: + pass + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".set_aa()" + pkt = ldns.ldns_pkt.new() + try: + pkt.set_aa(True) + if pkt.aa() != True: + set_error() + except: + set_error() + try: + pkt.set_aa(False) + if pkt.aa() != False: + set_error() + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".set_ad()" + pkt = ldns.ldns_pkt.new() + try: + pkt.set_ad(True) + if pkt.ad() != True: + set_error() + except: + set_error() + try: + pkt.set_ad(False) + if pkt.ad() != False: + set_error() + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".set_additional()" + pkt = ldns.ldns_pkt.new() + rrl = ldns.ldns_rr_list.new() + rr = ldns.ldns_rr.new_frm_str("test1 600 IN A 0.0.0.0") + rrl.push_rr(rr) + try: + pkt.set_additional(rrl) + if not isinstance(pkt.additional() , ldns.ldns_rr_list): + set_error() + if pkt.additional() != rrl: + set_error() + except: + set_error() + try: + pkt.set_additional("bad argument") + set_error() + except TypeError as e: + pass + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".set_ancount()" + pkt = ldns.ldns_pkt.new() + try: + pkt.set_ancount(1) + ret = pkt.ancount() + if ret != 1: + set_error() + except: + set_error() + try: + pkt.set_ancount("bad argument") + set_error() + except TypeError as e: + pass + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".set_answer()" + pkt = ldns.ldns_pkt.new() + rrl = ldns.ldns_rr_list.new() + rr = ldns.ldns_rr.new_frm_str("test1 600 IN A 0.0.0.0") + rrl.push_rr(rr) + try: + pkt.set_answer(rrl) + if not isinstance(pkt.additional() , ldns.ldns_rr_list): + set_error() + if pkt.answer() != rrl: + set_error() + except: + set_error() + try: + pkt.set_answer("bad argument") + set_error() + except TypeError as e: + pass + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".set_answerfrom()" + pkt = ldns.ldns_pkt.new() + rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_A, "127.0.0.1") + try: + pkt.set_answerfrom(rdf) + ret = pkt.answerfrom() + if ret != rdf: + set_error() + except: + set_error() + try: + pkt.set_answerfrom("bad argument") + set_error() + except TypeError as e: + pass + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".set_arcount()" + pkt = ldns.ldns_pkt.new() + try: + pkt.set_arcount(1) + ret = pkt.arcount() + if ret != 1: + set_error() + except: + set_error() + try: + pkt.set_arcount("bad argument") + set_error() + except TypeError as e: + pass + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".set_authority()" + pkt = ldns.ldns_pkt.new() + rrl = ldns.ldns_rr_list.new() + rr = ldns.ldns_rr.new_frm_str("test1 600 IN A 0.0.0.0") + rrl.push_rr(rr) + try: + pkt.set_authority(rrl) + if not isinstance(pkt.additional() , ldns.ldns_rr_list): + set_error() + if pkt.authority() != rrl: + set_error() + except: + set_error() + try: + pkt.set_authority("bad argument") + set_error() + except TypeError as e: + pass + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".set_cd()" + pkt = ldns.ldns_pkt.new() + try: + pkt.set_cd(True) + if pkt.cd() != True: + set_error() + except: + set_error() + try: + pkt.set_cd(False) + if pkt.cd() != False: + set_error() + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".set_edns_data()" + pkt = ldns.ldns_pkt.new() + rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_A, "127.0.0.1") + try: + pkt.set_edns_data(rdf) + ret = pkt.edns_data() + if ret != rdf: + set_error() + except: + set_error() + try: + pkt.set_edns_data("bad argument") + set_error() + except TypeError as e: + pass + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".set_edns_do()" + pkt = ldns.ldns_pkt.new() + try: + pkt.set_edns_do(True) + if pkt.edns_do() != True: + set_error() + except: + set_error() + try: + pkt.set_edns_do(False) + if pkt.edns_do() != False: + set_error() + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".set_edns_extended_rcode()" + pkt = ldns.ldns_pkt.new() + try: + pkt.set_edns_extended_rcode(8) + ret = pkt.edns_extended_rcode() + if ret != 8: + set_error() + except: + set_error() + try: + pkt.set_edns_extended_rcode("bad argument") + set_error() + except TypeError as e: + pass + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".set_edns_udp_size()" + pkt = ldns.ldns_pkt.new() + try: + pkt.set_edns_udp_size(4096) + ret = pkt.edns_udp_size() + if ret != 4096: + set_error() + except: + set_error() + try: + pkt.set_edns_udp_size("bad argument") + set_error() + except TypeError as e: + pass + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".set_edns_version()" + pkt = ldns.ldns_pkt.new() + try: + pkt.set_edns_version(8) + ret = pkt.edns_version() + if ret != 8: + set_error() + except: + set_error() + try: + pkt.set_edns_version("bad argument") + set_error() + except TypeError as e: + pass + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".set_edns_z()" + pkt = ldns.ldns_pkt.new() + try: + pkt.set_edns_z(4096) + ret = pkt.edns_z() + if ret != 4096: + set_error() + except: + set_error() + try: + pkt.set_edns_z("bad argument") + set_error() + except TypeError as e: + pass + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".set_flags()" + pkt = ldns.ldns_pkt.new() + try: + ret = pkt.set_flags(ldns.LDNS_AA | ldns.LDNS_AD) + if not isinstance(ret, bool): + set_error() + if ret != True: + set_error() + except: + set_error() + try: + pkt.set_flags("bad argument") + set_error() + except TypeError as e: + pass + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".set_id()" + pkt = ldns.ldns_pkt.new() + try: + pkt.set_id(4096) + ret = pkt.id() + if ret != 4096: + set_error() + except: + set_error() + try: + pkt.set_id("bad argument") + set_error() + except TypeError as e: + pass + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".set_nscount()" + pkt = ldns.ldns_pkt.new() + try: + pkt.set_nscount(1) + ret = pkt.nscount() + if ret != 1: + set_error() + except: + set_error() + try: + pkt.set_nscount("bad argument") + set_error() + except TypeError as e: + pass + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".set_opcode()" + pkt = ldns.ldns_pkt.new() + try: + pkt.set_opcode(ldns.LDNS_PACKET_QUERY) + ret = pkt.get_opcode() + if ret != ldns.LDNS_PACKET_QUERY: + set_error() + except: + set_error() + try: + pkt.set_opcode("bad argument") + set_error() + except TypeError as e: + pass + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".set_qdcount()" + pkt = ldns.ldns_pkt.new() + try: + pkt.set_qdcount(10) + ret = pkt.qdcount() + if ret != 10: + set_error() + except: + set_error() + try: + pkt.set_qdcount("bad argument") + set_error() + except TypeError as e: + pass + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".set_qr()" + pkt = ldns.ldns_pkt.new() + try: + pkt.set_qr(True) + if pkt.qr() != True: + set_error() + except: + set_error() + try: + pkt.set_qr(False) + if pkt.qr() != False: + set_error() + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".set_querytime()" + pkt = ldns.ldns_pkt.new() + try: + pkt.set_querytime(65536) + ret = pkt.querytime() + if ret != 65536: + set_error() + except: + set_error() + try: + pkt.set_querytime("bad argument") + set_error() + except TypeError as e: + pass + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".set_question()" + pkt = ldns.ldns_pkt.new() + rrl = ldns.ldns_rr_list.new() + rr = ldns.ldns_rr.new_frm_str("test1 600 IN A 0.0.0.0") + rrl.push_rr(rr) + try: + pkt.set_question(rrl) + if not isinstance(pkt.additional() , ldns.ldns_rr_list): + set_error() + if pkt.question() != rrl: + set_error() + except: + set_error() + try: + pkt.set_question("bad argument") + set_error() + except TypeError as e: + pass + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".set_ra()" + pkt = ldns.ldns_pkt.new() + try: + pkt.set_ra(True) + if pkt.ra() != True: + set_error() + except: + set_error() + try: + pkt.set_ra(False) + if pkt.ra() != False: + set_error() + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".set_random_id()" + pkt = ldns.ldns_pkt.new() + try: + pkt.set_random_id() + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".set_rcode()" + pkt = ldns.ldns_pkt.new() + try: + pkt.set_rcode(127) + ret = pkt.get_rcode() + if ret != 127: + set_error() + except: + set_error() + try: + pkt.set_rcode("bad argument") + set_error() + except TypeError as e: + pass + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".set_rd()" + pkt = ldns.ldns_pkt.new() + try: + pkt.set_rd(True) + if pkt.rd() != True: + set_error() + except: + set_error() + try: + pkt.set_rd(False) + if pkt.rd() != False: + set_error() + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".set_section_count()" + pkt = ldns.ldns_pkt.new() + try: + pkt.set_section_count(ldns.LDNS_PACKET_QUESTION, 4096) + ret = pkt.qdcount() + if ret != 4096: + set_error() + except: + set_error() + try: + pkt.set_section_count("bad argument", 4096) + set_error() + except TypeError as e: + pass + except: + set_error() + try: + pkt.set_section_count(ldns.LDNS_PACKET_QUESTION, "bad argument") + set_error() + except TypeError as e: + pass + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".set_size()" + pkt = ldns.ldns_pkt.new() + try: + pkt.set_size(512) + ret = pkt.size() + if ret != 512: + set_error() + except: + set_error() + try: + pkt.set_size("bad argument") + set_error() + except TypeError as e: + pass + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".set_tc()" + pkt = ldns.ldns_pkt.new() + try: + pkt.set_tc(True) + if pkt.tc() != True: + set_error() + except: + set_error() + try: + pkt.set_tc(False) + if pkt.tc() != False: + set_error() + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".set_timestamp()" + sys.stderr.write("%s not tested.\n" % (method_name)) + + +#if not error_detected: +if True: + method_name = class_name + ".set_tsig()" + pkt = ldns.ldns_pkt.new() + rr = ldns.ldns_rr.new_frm_str("test1 600 IN A 0.0.0.0") + try: + pkt.set_tsig(rr) + ret = pkt.tsig() + if ret != rr: + set_error() + except: + set_error() + try: + pkt.set_tsig("bad argument") + set_error() + except TypeError as e: + pass + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".size()" + pkt = ldns.ldns_pkt.new() + pkt.set_size(512) + try: + ret = pkt.size() + if (not isinstance(ret, int)) and (not isinstance(ret, long)): + set_error() + if ret != 512: + set_error() + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".tc()" + pkt = ldns.ldns_pkt.new() + pkt.set_tc(True) + try: + ret = pkt.tc() + if not isinstance(ret, bool): + set_error() + if ret != True: + set_error() + except: + set_error() + pkt.set_tc(False) + try: + ret = pkt.tc() + if not isinstance(ret, bool): + set_error() + if ret != False: + set_error() + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".timestamp()" + sys.stderr.write("%s not tested.\n" % (method_name)) + + +#if not error_detected: +if True: + method_name = class_name + ".tsig()" + pkt = ldns.ldns_pkt.new() + try: + ret = pkt.tsig() + if ret != None: + set_error() + except: + set_error() + rr = ldns.ldns_rr.new_frm_str("test1 600 IN A 0.0.0.0") + pkt.set_tsig(rr) + try: + ret = pkt.tsig() + if not isinstance(ret, ldns.ldns_rr): + set_error() + if ret != rr: + set_error() + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".update_pkt_tsig_add()" + pkt = ldns.ldns_pkt.new() + resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") + try: + ret = pkt.update_pkt_tsig_add(resolver) + if ret != ldns.LDNS_STATUS_OK: + set_error() + except: + set_error() + try: + ret = pkt.update_pkt_tsig_add("bad argument") + set_error() + except TypeError as e: + pass + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".update_prcount()" + pkt = ldns.ldns_pkt.new() + try: + ret = pkt.update_prcount() + if (not isinstance(ret, int)) and (not isinstance(ret, long)): + set_error() + if ret != 0: + set_error() + except: + set_error() + pkt.update_set_prcount(127) + try: + ret = pkt.update_prcount() + if (not isinstance(ret, int)) and (not isinstance(ret, long)): + set_error() + if ret != 127: + set_error() + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".update_set_adcount()" + pkt = ldns.ldns_pkt.new() + try: + pkt.update_set_adcount(4096) + ret = pkt.update_ad() + if ret != 4096: + set_error() + except: + set_error() + try: + pkt.update_set_adcount("bad argument") + set_error() + except TypeError as e: + pass + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".update_set_prcount()" + pkt = ldns.ldns_pkt.new() + try: + pkt.update_set_prcount(4096) + ret = pkt.update_prcount() + if ret != 4096: + set_error() + except: + set_error() + try: + pkt.update_set_prcount("bad argument") + set_error() + except TypeError as e: + pass + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".update_set_upcount()" + pkt = ldns.ldns_pkt.new() + try: + pkt.update_set_upcount(4096) + ret = pkt.update_upcount() + if ret != 4096: + set_error() + except: + set_error() + try: + pkt.update_set_upcount("bad argument") + set_error() + except TypeError as e: + pass + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".update_set_zo()" + pkt = ldns.ldns_pkt.new() + try: + pkt.update_set_zo(4096) + ret = pkt.update_zocount() + if ret != 4096: + set_error() + except: + set_error() + try: + pkt.update_set_zo("bad argument") + set_error() + except TypeError as e: + pass + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".update_upcount()" + pkt = ldns.ldns_pkt.new() + try: + ret = pkt.update_upcount() + if (not isinstance(ret, int)) and (not isinstance(ret, long)): + set_error() + if ret != 0: + set_error() + except: + set_error() + pkt.update_set_upcount(127) + try: + ret = pkt.update_upcount() + if (not isinstance(ret, int)) and (not isinstance(ret, long)): + set_error() + if ret != 127: + set_error() + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".update_zocount()" + pkt = ldns.ldns_pkt.new() + try: + ret = pkt.update_zocount() + if (not isinstance(ret, int)) and (not isinstance(ret, long)): + set_error() + if ret != 0: + set_error() + except: + set_error() + pkt.update_set_zo(127) + try: + ret = pkt.update_zocount() + if (not isinstance(ret, int)) and (not isinstance(ret, long)): + set_error() + if ret != 127: + set_error() + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".write_to_buffer()" + pkt = pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_QR | ldns.LDNS_AA) + buf = buf = ldns.ldns_buffer(4096) + try: + ret = pkt.write_to_buffer(buf) + if ret != ldns.LDNS_STATUS_OK: + set_error() + except: + set_error() + + +if not error_detected: + sys.stdout.write("%s: passed.\n" % (os.path.basename(__file__))) +else: + sys.stdout.write("%s: errors detected.\n" % (os.path.basename(__file__))) + sys.exit(1) diff --git a/contrib/python/examples/test_rdf.py b/contrib/python/examples/test_rdf.py index 4991288c83f25..2e2b73b6b751e 100755 --- a/contrib/python/examples/test_rdf.py +++ b/contrib/python/examples/test_rdf.py @@ -408,6 +408,20 @@ if True: #if not error_detected: if True: + method_name = "ldns_rdf.data_as_bytearray()" + rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "www.nic.cz.") + try: + ret = rdf.data_as_bytearray() + if not isinstance(ret, bytearray): + set_error() + if len(ret) != 12: + set_error() + except: + set_error() + + +#if not error_detected: +if True: method_name = "ldns_rdf.dname_compare()" rdf1 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "www.nic.cz.") rdf2 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "nic.cz.") @@ -602,7 +616,7 @@ if True: rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "www.nic.cz.") try: ret = rdf.label_count() - if not isinstance(ret, int): + if (not isinstance(ret, int)) and (not isinstance(ret, long)): set_error() if ret != 3: set_error() @@ -611,7 +625,7 @@ if True: rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_A, "127.0.0.1") try: ret = rdf.label_count() - if not isinstance(ret, int): + if (not isinstance(ret, int)) and (not isinstance(ret, long)): set_error() if ret != 0: set_error() @@ -720,8 +734,9 @@ if True: rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_A, "127.0.0.1") try: ret = rdf.reverse() - if not isinstance(ret, ldns.ldns_rdf): - set_error() + set_error() + except Exception: + pass except: set_error() diff --git a/contrib/python/examples/test_resolver.py b/contrib/python/examples/test_resolver.py new file mode 100755 index 0000000000000..274a4d87364f2 --- /dev/null +++ b/contrib/python/examples/test_resolver.py @@ -0,0 +1,1751 @@ +#!/usr/bin/env python + +# +# ldns_resolver testing script. +# +# Do not use constructs that differ between Python 2 and 3. +# Use write on stdout or stderr. +# + + +import ldns +import sys +import os +import inspect + + +class_name = "ldns_resolver" +method_name = None +error_detected = False +temp_fname = "tmp_resolver.txt" + + +def set_error(): + """ + Writes an error message and sets error flag. + """ + global class_name + global method_name + global error_detected + error_detected = True + sys.stderr.write("(line %d): malfunctioning method %s.\n" % \ + (inspect.currentframe().f_back.f_lineno, method_name)) + + +#if not error_detected: +if True: + method_name = class_name + ".axfr_complete()" + sys.stderr.write("%s not tested.\n" % (method_name)) + + +#if not error_detected: +if True: + method_name = class_name + ".axfr_last_pkt()" + sys.stderr.write("%s not tested.\n" % (method_name)) + + +#if not error_detected: +if True: + method_name = class_name + ".axfr_next()" + sys.stderr.write("%s not tested.\n" % (method_name)) + + +#if not error_detected: +if True: + method_name = class_name + ".axfr_start()" + sys.stderr.write("%s not tested.\n" % (method_name)) + + +#if not error_detected: +if True: + method_name = class_name + ".debug()" + resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") + resolver.set_debug(False) + try: + ret = resolver.debug() + if not isinstance(ret, bool): + set_error() + if ret != False: + set_error() + except: + set_error() + resolver.set_debug(True) + try: + ret = resolver.debug() + if not isinstance(ret, bool): + set_error() + if ret != True: + set_error() + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".dec_nameserver_count()" + resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") + cnt = resolver.nameserver_count() + try: + resolver.dec_nameserver_count() + except: + set_error() + if cnt != (resolver.nameserver_count() + 1): + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".defnames()" + resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") + resolver.set_defnames(False) + try: + ret = resolver.defnames() + if not isinstance(ret, bool): + set_error() + if ret != False: + set_error() + except: + set_error() + resolver.set_defnames(True) + try: + ret = resolver.defnames() + if not isinstance(ret, bool): + set_error() + if ret != True: + set_error() + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".dnsrch()" + resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") + resolver.set_dnsrch(False) + try: + ret = resolver.dnsrch() + if not isinstance(ret, bool): + set_error() + if ret != False: + set_error() + except: + set_error() + resolver.set_dnsrch(True) + try: + ret = resolver.dnsrch() + if not isinstance(ret, bool): + set_error() + if ret != True: + set_error() + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".dnssec()" + resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") + resolver.set_dnssec(False) + try: + ret = resolver.dnssec() + if not isinstance(ret, bool): + set_error() + if ret != False: + set_error() + except: + set_error() + resolver.set_dnssec(True) + try: + ret = resolver.dnssec() + if not isinstance(ret, bool): + set_error() + if ret != True: + set_error() + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".dnssec_anchors()" + resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") + rrl = ldns.ldns_rr_list.new() + try: + ret = resolver.dnssec_anchors() + if ret != None: + set_error() + except: + set_error() + resolver.set_dnssec_anchors(rrl) + try: + ret = resolver.dnssec_anchors() + if not isinstance(ret, ldns.ldns_rr_list): + set_error() + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".dnssec_cd()" + resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") + resolver.set_dnssec_cd(False) + try: + ret = resolver.dnssec_cd() + if not isinstance(ret, bool): + set_error() + if ret != False: + set_error() + except: + set_error() + resolver.set_dnssec_cd(True) + try: + ret = resolver.dnssec_cd() + if not isinstance(ret, bool): + set_error() + if ret != True: + set_error() + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".domain()" + resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") + resolver.set_domain(None) + try: + ret = resolver.domain() + if ret != None: + set_error() + except: + set_error() + dname = ldns.ldns_dname("example.com.") + resolver.set_domain(dname) + try: + ret = resolver.domain() + if not isinstance(ret, ldns.ldns_dname): + set_error() + if ret != dname: + set_error() + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".edns_udp_size()" + try: + resolver = ldns.ldns_resolver.new() + if not isinstance(resolver, ldns.ldns_resolver): + set_error() + except: + set_error() + + + +#if not error_detected: +if True: + method_name = class_name + ".edns_udp_size()" + resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") + resolver.set_edns_udp_size(4096) + try: + ret = resolver.edns_udp_size() + if (not isinstance(ret, int)) and (not isinstance(ret, long)): + set_error() + if ret != 4096: + set_error() + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".fail()" + resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") + resolver.set_fail(False) + try: + ret = resolver.fail() + if not isinstance(ret, bool): + set_error() + if ret != False: + set_error() + except: + set_error() + resolver.set_fail(True) + try: + ret = resolver.fail() + if not isinstance(ret, bool): + set_error() + if ret != True: + set_error() + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".fallback()" + resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") + resolver.set_fallback(False) + try: + ret = resolver.fallback() + if not isinstance(ret, bool): + set_error() + if ret != False: + set_error() + except: + set_error() + resolver.set_fallback(True) + try: + ret = resolver.fallback() + if not isinstance(ret, bool): + set_error() + if ret != True: + set_error() + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".get_addr_by_name()" + resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") + try: + ret = resolver.get_addr_by_name("www.google.com", ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD) + if not isinstance(ret, ldns.ldns_rr_list): + set_error() + except: + set_error() + try: + ret = resolver.get_addr_by_name(1, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD) + set_error() + except TypeError as e: + pass + except: + set_error() + try: + ret = resolver.get_addr_by_name("www.google.com", "bad argument", ldns.LDNS_RD) + set_error() + except TypeError as e: + pass + except: + set_error() + try: + ret = resolver.get_addr_by_name("www.google.com", ldns.LDNS_RR_CLASS_IN, "bad argument") + set_error() + except TypeError as e: + pass + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".get_name_by_addr()" + resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") + try: + addr = resolver.get_name_by_addr("8.8.8.8", ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD) + if not isinstance(addr, ldns.ldns_rr_list): + set_error() + except: + set_error() + try: + addr = resolver.get_name_by_addr(1, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD) + set_error() + except TypeError as e: + pass + except: + set_error() + try: + addr = resolver.get_name_by_addr("8.8.8.8", "bad argument", ldns.LDNS_RD) + set_error() + except TypeError as e: + pass + except: + set_error() + try: + addr = resolver.get_name_by_addr("8.8.8.8", ldns.LDNS_RR_CLASS_IN, "bad argument") + set_error() + except TypeError as e: + pass + except: + set_error() + + + +#if not error_detected: +if True: + method_name = class_name + ".igntc()" + resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") + resolver.set_igntc(False) + try: + ret = resolver.igntc() + if not isinstance(ret, bool): + set_error() + if ret != False: + set_error() + except: + set_error() + resolver.set_igntc(True) + try: + ret = resolver.igntc() + if not isinstance(ret, bool): + set_error() + if ret != True: + set_error() + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".incr_nameserver_count()" + resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") + cnt = resolver.nameserver_count() + try: + resolver.incr_nameserver_count() + except: + set_error() + if (cnt + 1) != resolver.nameserver_count(): + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".ip6()" + resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") + resolver.set_ip6(0) + try: + ret = resolver.ip6() + if (not isinstance(ret, int)) and (not isinstance(ret, long)): + set_error() + if ret != 0: + set_error() + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".nameserver_count()" + resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") + resolver.set_nameserver_count(1) + try: + ret = resolver.nameserver_count() + if (not isinstance(ret, int)) and (not isinstance(ret, long)): + set_error() + if ret != 1: + set_error() + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".nameserver_rtt()" + resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") + num = resolver.nameserver_count() + for i in range(0, num): + resolver.set_nameserver_rtt(i, i + 1) + try: + for i in range(0, num): + ret = resolver.nameserver_rtt(i) + if (not isinstance(ret, int)) and (not isinstance(ret, long)): + set_error() + if (i + 1) != ret: + set_error() + except: + set_error() + try: + ret = resolver.nameserver_rtt("bad argument") + set_error() + except TypeError as e: + pass + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".nameservers()" + sys.stderr.write("%s not tested.\n" % (method_name)) + + +#if not error_detected: +if True: + method_name = class_name + ".nameservers_randomize()" + resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") + try: + resolver.nameservers_randomize() + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".new_frm_file()" + try: + ret = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf", raiseException=True) + if not isinstance(ret, ldns.ldns_resolver): + set_error() + except: + set_error() + try: + ret = ldns.ldns_resolver.new_frm_file(1, raiseException=True) + set_error() + except TypeError as e: + pass + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".new_frm_fp()" + fi = open("/etc/resolv.conf") + try: + ret = ldns.ldns_resolver.new_frm_fp(fi, raiseException=True) + if not isinstance(ret, ldns.ldns_resolver): + set_error() + except: + set_error() + fi.close() + try: + ret = ldns.ldns_resolver.new_frm_fp(1, raiseException=True) + set_error() + except TypeError as e: + pass + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".new_frm_fp_l()" + fi = open("/etc/resolv.conf") + try: + ret, line = ldns.ldns_resolver.new_frm_fp_l(fi, raiseException=True) + if not isinstance(ret, ldns.ldns_resolver): + set_error() + if (not isinstance(line, int)) and (not isinstance(line, long)): + set_error() + except: + set_error() + fi.close() + try: + ret, line = ldns.ldns_resolver.new_frm_fp_l(1, raiseException=True) + set_error() + except TypeError as e: + pass + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".pop_nameserver()" + resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") + cnt = resolver.nameserver_count() + try: + for i in range(0, cnt): + ret = resolver.pop_nameserver() + if not isinstance(ret, ldns.ldns_rdf): + set_error() + except: + set_error() + try: + ret = resolver.pop_nameserver() + if ret != None: + set_error() + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".port()" + resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") + resolver.set_port(12345) + try: + ret = resolver.port() + if (not isinstance(ret, int)) and (not isinstance(ret, long)): + set_error() + if ret != 12345: + set_error() + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".prepare_query_pkt()" + resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") + try: + ret = resolver.prepare_query_pkt("example.com.", ldns.LDNS_RR_TYPE_A, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD, raiseException=True) + if not isinstance(ret, ldns.ldns_pkt): + set_error() + except: + set_error() + try: + ret = resolver.prepare_query_pkt(1, ldns.LDNS_RR_TYPE_A, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD, raiseException=True) + set_error() + except TypeError as e: + pass + except: + set_error() + try: + ret = resolver.prepare_query_pkt("example.com.", "bad argument", ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD, raiseException=True) + set_error() + except TypeError as e: + pass + except: + set_error() + try: + ret = resolver.prepare_query_pkt("example.com.", ldns.LDNS_RR_TYPE_A, "bad argument", ldns.LDNS_RD, raiseException=True) + set_error() + except TypeError as e: + pass + except: + set_error() + try: + ret = resolver.prepare_query_pkt("example.com.", ldns.LDNS_RR_TYPE_A, ldns.LDNS_RR_CLASS_IN, "bad argument", raiseException=True) + set_error() + except TypeError as e: + pass + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".push_dnssec_anchor()" + resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") + key = ldns.ldns_key.new_frm_algorithm(ldns.LDNS_SIGN_DSA, 512) + domain = ldns.ldns_dname("example.") + key.set_pubkey_owner(domain) + pubkey = key.key_to_rr() + ds = ldns.ldns_key_rr2ds(pubkey, ldns.LDNS_SHA1) + try: + ret = resolver.push_dnssec_anchor(ds) + if ret != ldns.LDNS_STATUS_OK: + set_error() + except: + set_error() + rr = ldns.ldns_rr.new_frm_str("test1 600 IN A 0.0.0.0") + try: + ret = resolver.push_dnssec_anchor(rr) + if ret == ldns.LDNS_STATUS_OK: + set_error() + except: + set_error() + try: + ret = resolver.push_dnssec_anchor("bad argument") + set_error() + except TypeError as e: + pass + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".push_nameserver()" + resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") + rdf = ldns.ldns_rdf.new_frm_str("127.0.0.1", ldns.LDNS_RDF_TYPE_A) + try: + ret = resolver.push_nameserver(rdf) + if ret != ldns.LDNS_STATUS_OK: + set_error() + except: + set_error() + rdf = ldns.ldns_rdf.new_frm_str("::1", ldns.LDNS_RDF_TYPE_AAAA) + try: + ret = resolver.push_nameserver(rdf) + if ret != ldns.LDNS_STATUS_OK: + set_error() + except: + set_error() + rdf = ldns.ldns_rdf.new_frm_str("example.com.", ldns.LDNS_RDF_TYPE_DNAME) + try: + ret = resolver.push_nameserver(rdf) + if ret == ldns.LDNS_STATUS_OK: + set_error() + except: + set_error() + try: + ret = resolver.push_nameserver("bad argument") + set_error() + except TypeError as e: + pass + except: + set_error() + +#if not error_detected: +if True: + method_name = class_name + ".push_nameserver_rr()" + resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") + rr = ldns.ldns_rr.new_frm_str("test 600 IN A 127.0.0.1") + try: + ret = resolver.push_nameserver_rr(rr) + if ret != ldns.LDNS_STATUS_OK: + set_error() + except: + set_error() + rr = ldns.ldns_rr.new_frm_str("test 600 IN AAAA ::1") + try: + ret = resolver.push_nameserver_rr(rr) + if ret != ldns.LDNS_STATUS_OK: + set_error() + except: + set_error() + rr = ldns.ldns_rr.new_frm_str("test 600 IN NS 8.8.8.8") + try: + ret = resolver.push_nameserver_rr(rr) + if ret == ldns.LDNS_STATUS_OK: + set_error() + except: + set_error() + try: + ret = resolver.push_nameserver_rr("bad argument") + set_error() + except TypeError as e: + pass + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".push_nameserver_rr_list()" + resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") + rrl = ldns.ldns_rr_list.new() + rr = ldns.ldns_rr.new_frm_str("test 600 IN A 127.0.0.1") + rrl.push_rr(rr) + try: + ret = resolver.push_nameserver_rr_list(rrl) + if ret != ldns.LDNS_STATUS_OK: + set_error() + except: + set_error() + rrl = ldns.ldns_rr_list.new() + rr = ldns.ldns_rr.new_frm_str("test 600 IN AAAA ::1") + rrl.push_rr(rr) + try: + ret = resolver.push_nameserver_rr_list(rrl) + if ret != ldns.LDNS_STATUS_OK: + set_error() + except: + set_error() + rrl = ldns.ldns_rr_list.new() + rr = ldns.ldns_rr.new_frm_str("test 600 IN NS 8.8.8.8") + rrl.push_rr(rr) + try: + ret = resolver.push_nameserver_rr_list(rrl) + if ret == ldns.LDNS_STATUS_OK: + set_error() + except: + set_error() + try: + ret = resolver.push_nameserver_rr_list("bad argument") + set_error() + except TypeError as e: + pass + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".push_searchlist()" + resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") + resolver.push_searchlist("example.com.") + try: + resolver.push_searchlist("example.com.") + except: + set_error() + try: + resolver.push_searchlist(1) + set_error() + except TypeError as e: + pass + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".query()" + resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") + try: + ret = resolver.query("www.nic.cz", ldns.LDNS_RR_TYPE_A, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD) + if not isinstance(ret, ldns.ldns_pkt): + set_error() + except: + set_error() + try: + ret = resolver.query(1, ldns.LDNS_RR_TYPE_A, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD) + set_error() + except TypeError as e: + pass + except: + set_error() + try: + ret = resolver.query("www.nic.cz", "bad argument", ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD) + set_error() + except TypeError as e: + pass + except: + set_error() + try: + ret = resolver.query("www.nic.cz", ldns.LDNS_RR_TYPE_A, "bad argument", ldns.LDNS_RD) + set_error() + except TypeError as e: + pass + except: + set_error() + try: + ret = resolver.query("www.nic.cz", ldns.LDNS_RR_TYPE_A, ldns.LDNS_RR_CLASS_IN, "bad argument") + set_error() + except TypeError as e: + pass + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".random()" + resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") + resolver.set_random(False) + try: + ret = resolver.random() + if not isinstance(ret, bool): + set_error() + if ret != False: + set_error() + except: + set_error() + resolver.set_random(True) + try: + ret = resolver.random() + if not isinstance(ret, bool): + set_error() + if ret != True: + set_error() + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".recursive()" + resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") + resolver.set_recursive(False) + try: + ret = resolver.recursive() + if not isinstance(ret, bool): + set_error() + if ret != False: + set_error() + except: + set_error() + resolver.set_recursive(True) + try: + ret = resolver.recursive() + if not isinstance(ret, bool): + set_error() + if ret != True: + set_error() + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".retrans()" + resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") + resolver.set_retrans(127) + try: + ret = resolver.retrans() + if (not isinstance(ret, int)) and (not isinstance(ret, long)): + set_error() + if ret != 127: + set_error() + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".retry()" + resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") + resolver.set_retry(4) + try: + ret = resolver.retry() + if (not isinstance(ret, int)) and (not isinstance(ret, long)): + set_error() + if ret != 4: + set_error() + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".rtt()" + sys.stderr.write("%s not tested.\n" % (method_name)) + + +#if not error_detected: +if True: + method_name = class_name + ".search()" + resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") + try: + ret = resolver.search("www.nic.cz", ldns.LDNS_RR_TYPE_A, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD) + if not isinstance(ret, ldns.ldns_pkt): + set_error() + except: + set_error() + try: + ret = resolver.search(1, ldns.LDNS_RR_TYPE_A, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD) + set_error() + except TypeError as e: + pass + except: + set_error() + try: + ret = resolver.search("www.nic.cz", "bad argument", ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD) + set_error() + except TypeError as e: + pass + except: + set_error() + try: + ret = resolver.search("www.nic.cz", ldns.LDNS_RR_TYPE_A, "bad argument", ldns.LDNS_RD) + set_error() + except TypeError as e: + pass + except: + set_error() + try: + ret = resolver.search("www.nic.cz", ldns.LDNS_RR_TYPE_A, ldns.LDNS_RR_CLASS_IN, "bad argument") + set_error() + except TypeError as e: + pass + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".searchlist()" + sys.stderr.write("%s not tested.\n" % (method_name)) + + +#if not error_detected: +if True: + method_name = class_name + ".searchlist_count()" + resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") + try: + ret = resolver.searchlist_count() + if (not isinstance(ret, int)) and (not isinstance(ret, long)): + set_error() + if ret != 0: + set_error() + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".send()" + resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") + try: + ret = resolver.send("www.nic.cz", ldns.LDNS_RR_TYPE_A, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD) + if not isinstance(ret, ldns.ldns_pkt): + set_error() + except: + set_error() + try: + ret = resolver.send(1, ldns.LDNS_RR_TYPE_A, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD) + set_error() + except TypeError as e: + pass + except: + set_error() + try: + ret = resolver.send("www.nic.cz", "bad argument", ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD) + set_error() + except TypeError as e: + pass + except: + set_error() + try: + ret = resolver.send("www.nic.cz", ldns.LDNS_RR_TYPE_A, "bad argument", ldns.LDNS_RD) + set_error() + except TypeError as e: + pass + except: + set_error() + try: + ret = resolver.send("www.nic.cz", ldns.LDNS_RR_TYPE_A, ldns.LDNS_RR_CLASS_IN, "bad argument") + set_error() + except TypeError as e: + pass + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".send_pkt()" + resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") + pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD | ldns.LDNS_AD) + try: + status, ret = resolver.send_pkt(pkt) + if status != ldns.LDNS_STATUS_OK: + ste_error() + if not isinstance(ret, ldns.ldns_pkt): + set_error() + except: + set_error() + try: + status, ret = resolver.send_pkt("bad argument") + set_error() + except TypeError as e: + pass + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".set_debug()" + resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") + try: + resolver.set_debug(False) + ret = resolver.debug() + if not isinstance(ret, bool): + set_error() + if ret != False: + set_error() + except: + set_error() + try: + resolver.set_debug(True) + ret = resolver.debug() + if not isinstance(ret, bool): + set_error() + if ret != True: + set_error() + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".set_defnames()" + resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") + try: + resolver.set_defnames(False) + ret = resolver.defnames() + if not isinstance(ret, bool): + set_error() + if ret != False: + set_error() + except: + set_error() + try: + resolver.set_defnames(True) + ret = resolver.defnames() + if not isinstance(ret, bool): + set_error() + if ret != True: + set_error() + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".set_dnsrch()" + resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") + try: + resolver.set_dnsrch(False) + ret = resolver.dnsrch() + if not isinstance(ret, bool): + set_error() + if ret != False: + set_error() + except: + set_error() + try: + resolver.set_dnsrch(True) + ret = resolver.dnsrch() + if not isinstance(ret, bool): + set_error() + if ret != True: + set_error() + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".set_dnssec()" + resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") + try: + resolver.set_dnssec(False) + ret = resolver.dnssec() + if not isinstance(ret, bool): + set_error() + if ret != False: + set_error() + except: + set_error() + try: + resolver.set_dnssec(True) + ret = resolver.dnssec() + if not isinstance(ret, bool): + set_error() + if ret != True: + set_error() + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".set_dnssec_anchors()" + resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") + rrl = ldns.ldns_rr_list.new() + try: + resolver.set_dnssec_anchors(rrl) + ret = resolver.dnssec_anchors() + if not isinstance(ret, ldns.ldns_rr_list): + set_error() + except: + set_error() + try: + resolver.set_dnssec_anchors("bad argument") + set_error() + except TypeError as e: + pass + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".set_dnssec_cd()" + resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") + try: + resolver.set_dnssec_cd(False) + ret = resolver.dnssec_cd() + if not isinstance(ret, bool): + set_error() + if ret != False: + set_error() + except: + set_error() + try: + resolver.set_dnssec_cd(True) + ret = resolver.dnssec_cd() + if not isinstance(ret, bool): + set_error() + if ret != True: + set_error() + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".set_domain()" + resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") + try: + resolver.set_domain(None) + ret = resolver.domain() + if ret != None: + set_error() + except: + set_error() + dname = ldns.ldns_dname("example.com.") + try: + resolver.set_domain(dname) + ret = resolver.domain() + if not isinstance(ret, ldns.ldns_dname): + set_error() + if ret != dname: + set_error() + except: + set_error() + rdf = ldns.ldns_rdf.new_frm_str("example.com.", ldns.LDNS_RDF_TYPE_DNAME) + try: + resolver.set_domain(rdf) + ret = resolver.domain() + if not isinstance(ret, ldns.ldns_rdf): + set_error() + if ret != dname: + set_error() + except: + set_error() + resolver.set_domain("example.com.") + try: + resolver.set_domain("example.com.") + ret = resolver.domain() + if not isinstance(ret, ldns.ldns_dname): + set_error() + if ret != dname: + set_error() + except: + set_error() + rdf = ldns.ldns_rdf.new_frm_str("127.0.0.1", ldns.LDNS_RDF_TYPE_A) + try: + resolver.set_domain(rdf) + set_error() + except Exception as e: + pass + except: + set_error() + try: + resolver.set_domain(1) + set_error() + except TypeError as e: + pass + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".set_edns_udp_size()" + resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") + try: + resolver.set_edns_udp_size(4096) + ret = resolver.edns_udp_size() + if (not isinstance(ret, int)) and (not isinstance(ret, long)): + set_error() + if ret != 4096: + set_error() + except: + set_error() + try: + resolver.set_edns_udp_size("bad argument") + set_error() + except TypeError as e: + pass + except: + ste_error() + + +#if not error_detected: +if True: + method_name = class_name + ".set_fail()" + resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") + try: + resolver.set_fail(False) + ret = resolver.fail() + if not isinstance(ret, bool): + set_error() + if ret != False: + set_error() + except: + set_error() + try: + resolver.set_fail(True) + ret = resolver.fail() + if not isinstance(ret, bool): + set_error() + if ret != True: + set_error() + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".set_fallback()" + resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") + try: + resolver.set_fallback(False) + ret = resolver.fallback() + if not isinstance(ret, bool): + set_error() + if ret != False: + set_error() + except: + set_error() + try: + resolver.set_fallback(True) + ret = resolver.fallback() + if not isinstance(ret, bool): + set_error() + if ret != True: + set_error() + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".set_igntc()" + resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") + try: + resolver.set_igntc(False) + ret = resolver.igntc() + if not isinstance(ret, bool): + set_error() + if ret != False: + set_error() + except: + set_error() + try: + resolver.set_igntc(True) + ret = resolver.igntc() + if not isinstance(ret, bool): + set_error() + if ret != True: + set_error() + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".set_ip6()" + resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") + try: + resolver.set_ip6(1) + ret = resolver.ip6() + if (not isinstance(ret, int)) and (not isinstance(ret, long)): + set_error() + if ret != 1: + set_error() + except: + set_error() + try: + resolver.set_ip6("bad argument") + set_error() + except TypeError as e: + pass + except: + ste_error() + + +#if not error_detected: +if True: + method_name = class_name + ".set_nameserver_count()" + resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") + try: + resolver.set_nameserver_count(2) + ret = resolver.nameserver_count() + if (not isinstance(ret, int)) and (not isinstance(ret, long)): + set_error() + if ret != 2: + set_error() + except: + set_error() + try: + resolver.set_nameserver_count("bad argument") + set_error() + except TypeError as e: + pass + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".set_nameserver_rtt()" + resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") + num = resolver.nameserver_count() + try: + for i in range(0, num): + resolver.set_nameserver_rtt(i, i + 1) + ret = resolver.nameserver_rtt(i) + if (not isinstance(ret, int)) and (not isinstance(ret, long)): + set_error() + if (i + 1) != ret: + set_error() + except: + set_error() + try: + ret = resolver.set_nameserver_rtt("bad argument", 0) + set_error() + except TypeError as e: + pass + except: + set_error() + try: + ret = resolver.set_nameserver_rtt(0, "bad argument") + set_error() + except TypeError as e: + pass + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".set_nameservers()" + sys.stderr.write("%s not tested.\n" % (method_name)) + + +#if not error_detected: +if True: + method_name = class_name + ".set_port()" + resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") + try: + resolver.set_port(12345) + ret = resolver.port() + if (not isinstance(ret, int)) and (not isinstance(ret, long)): + set_error() + if ret != 12345: + set_error() + except: + set_error() + try: + resolver.set_port("bad argument") + set_error() + except TypeError as e: + pass + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".set_random()" + resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") + try: + resolver.set_random(False) + ret = resolver.random() + if not isinstance(ret, bool): + set_error() + if ret != False: + set_error() + except: + set_error() + try: + resolver.set_random(True) + ret = resolver.random() + if not isinstance(ret, bool): + set_error() + if ret != True: + set_error() + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".set_recursive()" + resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") + try: + resolver.set_recursive(False) + ret = resolver.recursive() + if not isinstance(ret, bool): + set_error() + if ret != False: + set_error() + except: + set_error() + try: + resolver.set_recursive(True) + ret = resolver.recursive() + if not isinstance(ret, bool): + set_error() + if ret != True: + set_error() + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".set_retrans()" + resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") + try: + resolver.set_retrans(127) + ret = resolver.retrans() + if (not isinstance(ret, int)) and (not isinstance(ret, long)): + set_error() + if ret != 127: + set_error() + except: + set_error() + try: + resolver.set_retrans("bad argument") + set_error() + except TypeError as e: + pass + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".set_retry()" + resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") + try: + resolver.set_retry(4) + ret = resolver.retry() + if (not isinstance(ret, int)) and (not isinstance(ret, long)): + set_error() + if ret != 4: + set_error() + except: + set_error() + try: + resolver.set_retry("bad argument") + set_error() + except TypeError as e: + pass + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".set_rtt()" + sys.stderr.write("%s not tested.\n" % (method_name)) + + +#if not error_detected: +if True: + method_name = class_name + ".set_timeout()" + sys.stderr.write("%s not tested.\n" % (method_name)) + + +#if not error_detected: +if True: + method_name = class_name + ".set_tsig_algorithm()" + resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") + tsigstr = "hmac-md5.sig-alg.reg.int." + try: + resolver.set_tsig_algorithm(tsigstr) + ret = resolver.tsig_algorithm() + if not isinstance(ret, str): + set_error() + if ret != tsigstr: + set_error() + except: + set_error() + try: + resolver.set_tsig_algorithm(1) + set_error() + except TypeError as e: + pass + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".set_tsig_keydata()" + resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") + tkdstr = "Humpty Dumpty sat on a wall, Humpty Dumpty had a great fall, All the King's horses and all the King's men, Couldn't put Humpty together again." + try: + resolver.set_tsig_keydata(tkdstr) + ret = resolver.tsig_keydata() + if not isinstance(ret, str): + set_error() + if ret != tkdstr: + set_error() + except: + set_error() + try: + resolver.set_tsig_keydata(1) + set_error() + except TypeError as e: + pass + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".set_tsig_keyname()" + resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") + tknstr = "key 1" + try: + resolver.set_tsig_keyname(tknstr) + ret = resolver.tsig_keyname() + if not isinstance(ret, str): + set_error() + if ret != tknstr: + set_error() + except: + set_error() + try: + resolver.set_tsig_keyname(1) + set_error() + except TypeError as e: + pass + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".set_usevc()" + resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") + try: + resolver.set_usevc(False) + ret = resolver.usevc() + if not isinstance(ret, bool): + set_error() + if ret != False: + set_error() + except: + set_error() + try: + resolver.set_usevc(True) + ret = resolver.usevc() + if not isinstance(ret, bool): + set_error() + if ret != True: + set_error() + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".timeout()" + sys.stderr.write("%s not tested.\n" % (method_name)) + + +#if not error_detected: +if True: + method_name = class_name + ".trusted_key()" + resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") + key = ldns.ldns_key.new_frm_algorithm(ldns.LDNS_SIGN_DSA, 512) + domain = ldns.ldns_dname("example.") + key.set_pubkey_owner(domain) + pubkey = key.key_to_rr() + ds = ldns.ldns_key_rr2ds(pubkey, ldns.LDNS_SHA1) + resolver.push_dnssec_anchor(ds) + rrl = ldns.ldns_rr_list.new() + try: + ret = resolver.trusted_key(rrl) + if ret != None: + set_error() + except: + set_error() + rrl.push_rr(ds) + ret = resolver.trusted_key(rrl) + try: + ret = resolver.trusted_key(rrl) + if not isinstance(ret, ldns.ldns_rr_list): + set_error() + if ret.rr_count() != 1: + set_error() + except: + set_error() + try: + ret = resolver.trusted_key("bad argument") + set_error() + except TypeError as e: + pass + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".tsig_algorithm()" + resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") + try: + ret = resolver.tsig_algorithm() + if ret != None: + set_error() + except: + set_error() + tsigstr = "hmac-md5.sig-alg.reg.int." + resolver.set_tsig_algorithm(tsigstr) + try: + ret = resolver.tsig_algorithm() + if not isinstance(ret, str): + set_error() + if ret != tsigstr: + set_error() + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".tsig_keydata()" + resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") + try: + ret = resolver.tsig_keydata() + if ret != None: + set_error() + except: + set_error() + tkdstr = "Twas brillig, and the slithy toves Did gyre and gimble in the wabe; All mimsy were the borogoves, And the mome raths outgrabe." + resolver.set_tsig_keydata(tkdstr) + try: + ret = resolver.tsig_keydata() + if not isinstance(ret, str): + set_error() + if ret != tkdstr: + set_error() + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".tsig_keyname()" + resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") + try: + ret = resolver.tsig_keyname() + if ret != None: + set_error() + except: + set_error() + tknstr = "key 2" + resolver.set_tsig_keyname(tknstr) + try: + ret = resolver.tsig_keyname() + if not isinstance(ret, str): + set_error() + if ret != tknstr: + set_error() + except: + set_error() + + +#if not error_detected: +if True: + method_name = class_name + ".usevc()" + resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") + resolver.set_usevc(False) + try: + ret = resolver.usevc() + if not isinstance(ret, bool): + set_error() + if ret != False: + set_error() + except: + set_error() + resolver.set_usevc(True) + try: + ret = resolver.usevc() + if not isinstance(ret, bool): + set_error() + if ret != True: + set_error() + except: + set_error() + + +if not error_detected: + sys.stdout.write("%s: passed.\n" % (os.path.basename(__file__))) +else: + sys.stdout.write("%s: errors detected.\n" % (os.path.basename(__file__))) + sys.exit(1) diff --git a/contrib/python/examples/test_rr.py b/contrib/python/examples/test_rr.py index b7bc1e0d9717f..07ba0e743073c 100644 --- a/contrib/python/examples/test_rr.py +++ b/contrib/python/examples/test_rr.py @@ -385,7 +385,7 @@ if True: pubkey = ldns.ldns_rr.new_frm_str("example1. 3600 IN DNSKEY 256 3 3 APw7tG8Nf7MYXjt2Y6DmyWUVxVy73bRKvKbKoGXhAXJx2vbcGGxfXsScT0i4FIC2wsJ/8zy/otB5vymm3JHBf2+7cQvRdp12UMLAnzlfrbgZUpvV36D+q6ch7kbmFzaBfwRjOKhnZkRLCcMYPAdX1SrgKVNXaOzAl9KytbzGQs5MKEHU+a0PAwKfIvEsS/+pW6gKgBnL0uy4Gr5cYJ5rk48iwFXOlZ/B30gUS5dD+rNRJuR0ZgEkxtVIPVxxhQPtEI53JhlJ2nEy0CqNW88nYLmX402b ;{id = 34898 (zsk), size = 512b}") try: ret = pubkey.dnskey_key_size() - if not isinstance(ret, int): + if (not isinstance(ret, int)) and (not isinstance(ret, long)): set_error() if ret != 512: set_error() @@ -394,7 +394,7 @@ if True: rr = ldns.ldns_rr.new_frm_str("test 600 IN A 0.0.0.0") try: ret = rr.dnskey_key_size() - if not isinstance(ret, int): + if (not isinstance(ret, int)) and (not isinstance(ret, long)): set_error() if ret != 0: set_error() @@ -638,7 +638,7 @@ if True: rr = ldns.ldns_rr.new_frm_str("test.dom. IN A 0.0.0.0", 600) try: ret = rr.label_count() - if not isinstance(ret, int): + if (not isinstance(ret, int)) and (not isinstance(ret, long)): set_error() if ret != 2: set_error() @@ -647,7 +647,7 @@ if True: rr = ldns.ldns_rr.new_frm_str(". IN A 0.0.0.0", 600) try: ret = rr.label_count() - if not isinstance(ret, int): + if (not isinstance(ret, int)) and (not isinstance(ret, long)): set_error(string) if ret != 0: set_error() @@ -951,7 +951,7 @@ if True: rr = ldns.ldns_rr.new_frm_str("test 600 IN A 0.0.0.0") try: ret = rr.rd_count() - if not isinstance(ret, int): + if (not isinstance(ret, int)) and (not isinstance(ret, long)): set_error() if ret != 1: set_error() @@ -1643,7 +1643,7 @@ if True: rr = ldns.ldns_rr.new_frm_str("test 600 IN A 0.0.0.0") try: ret = rr.uncompressed_size() - if not isinstance(ret, int): + if (not isinstance(ret, int)) and (not isinstance(ret, long)): set_error() if ret != 20: set_error() @@ -1723,7 +1723,7 @@ if True: desc_a = ldns.ldns_rr_descriptor.ldns_rr_descriptor(ldns.LDNS_RR_TYPE_A) try: ret = desc_a.maximum() - if not isinstance(ret, int): + if (not isinstance(ret, int)) and (not isinstance(ret, long)): set_error() if ret != 1: set_error() @@ -1737,7 +1737,7 @@ if True: desc_a = ldns.ldns_rr_descriptor.ldns_rr_descriptor(ldns.LDNS_RR_TYPE_A) try: ret = desc_a.minimum() - if not isinstance(ret, int): + if (not isinstance(ret, int)) and (not isinstance(ret, long)): set_error() if ret != 1: set_error() @@ -2203,7 +2203,7 @@ if True: rrl = ldns.ldns_rr_list.new() try: ret = rrl.rr_count() - if not isinstance(ret, int): + if (not isinstance(ret, int)) and (not isinstance(ret, long)): set_error() if ret != 0: set_error() @@ -2213,7 +2213,7 @@ if True: rrl.push_rr(rr) try: ret = rrl.rr_count() - if not isinstance(ret, int): + if (not isinstance(ret, int)) and (not isinstance(ret, long)): set_error() if ret != 1: set_error() diff --git a/contrib/python/ldns_packet.i b/contrib/python/ldns_packet.i index 9316479f13b3a..eeff4aa2359a3 100644 --- a/contrib/python/ldns_packet.i +++ b/contrib/python/ldns_packet.i @@ -14,8 +14,8 @@ * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * Neither the name of the organization nor the names of its - * contributors may be used to endorse or promote products derived from this - * software without specific prior written permission. + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE @@ -28,17 +28,26 @@ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. - ******************************************************************************/ + *****************************************************************************/ + + +/* ========================================================================= */ +/* SWIG setting and definitions. */ +/* ========================================================================= */ + +/* Creates a temporary instance of (ldns_pkt *). */ %typemap(in,numinputs=0,noblock=1) (ldns_pkt **) { - ldns_pkt *$1_pkt; - $1 = &$1_pkt; + ldns_pkt *$1_pkt; + $1 = &$1_pkt; } -/* result generation */ +/* Result generation, appends (ldns_pkt *) after the result. */ %typemap(argout,noblock=1) (ldns_pkt **) { - $result = SWIG_Python_AppendOutput($result, SWIG_NewPointerObj(SWIG_as_voidptr($1_pkt), SWIGTYPE_p_ldns_struct_pkt, SWIG_POINTER_OWN | 0 )); + $result = SWIG_Python_AppendOutput($result, + SWIG_NewPointerObj(SWIG_as_voidptr($1_pkt), + SWIGTYPE_p_ldns_struct_pkt, SWIG_POINTER_OWN | 0 )); } %newobject ldns_pkt_new; @@ -49,83 +58,322 @@ %newobject ldns_update_pkt_new; -%nodefaultctor ldns_struct_pkt; //no default constructor & destructor -%nodefaultdtor ldns_struct_pkt; +%nodefaultctor ldns_struct_pkt; /* No default constructor. */ +%nodefaultdtor ldns_struct_pkt; /* No default destructor. */ %rename(ldns_pkt) 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 %newobject ldns_pkt2str; %newobject ldns_pkt_opcode2str; %newobject ldns_pkt_rcode2str; %newobject ldns_pkt_algorithm2str; %newobject ldns_pkt_cert_algorithm2str; +%newobject ldns_pkt_get_section_clone; -/* cloning of packet_lists to make them independent of the original packet */ +/* Clone data on pull. */ -%newobject _ldns_pkt_additional; -%newobject _ldns_pkt_answer; -%newobject _ldns_pkt_authority; -%newobject _ldns_pkt_question; +%newobject _ldns_pkt_additional; %rename(__ldns_pkt_additional) ldns_pkt_additional; -%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_additional(ldns_pkt *p) + { + return ldns_rr_list_clone(ldns_pkt_additional(p)); + } %} +%newobject _ldns_pkt_answer; %rename(__ldns_pkt_answer) ldns_pkt_answer; -%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_answer(ldns_pkt *p) + { + return ldns_rr_list_clone(ldns_pkt_answer(p)); + } %} +%newobject _ldns_pkt_answerfrom; +%rename(__ldns_pkt_answerfrom) ldns_pkt_answerfrom; +%inline +%{ + ldns_rdf * _ldns_pkt_answerfrom(ldns_pkt *p) + { + ldns_rdf *rdf; + + rdf = ldns_pkt_answerfrom(p); + if (rdf != NULL) { + rdf = ldns_rdf_clone(rdf); + } + return rdf; + } +%} + +%newobject _ldns_pkt_authority; %rename(__ldns_pkt_authority) ldns_pkt_authority; -%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_authority(ldns_pkt *p) + { + return ldns_rr_list_clone(ldns_pkt_authority(p)); + } +%} + +%newobject _ldns_pkt_edns_data; +%rename(__ldns_pkt_edns_data) ldns_pkt_edns_data; +%inline +%{ + ldns_rdf * _ldns_pkt_edns_data(ldns_pkt *p) + { + ldns_rdf *rdf; + + rdf = ldns_pkt_edns_data(p); + if (rdf != NULL) { + rdf = ldns_rdf_clone(rdf); + } + return rdf; + } %} +%newobject _ldns_pkt_tsig; +%rename(__ldns_pkt_tsig) ldns_pkt_tsig; +%inline +%{ + ldns_rr * _ldns_pkt_tsig(const ldns_pkt *pkt) + { + return ldns_rr_clone(ldns_pkt_tsig(pkt)); + } +%} + +%newobject _ldns_pkt_question; %rename(__ldns_pkt_question) ldns_pkt_question; -%inline %{ -ldns_rr_list* _ldns_pkt_question(ldns_pkt* p) { - return ldns_rr_list_clone(ldns_pkt_question(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 */ +/* End of pull cloning. */ + +/* Clone data on push. */ + +%newobject _ldns_pkt_query_new; +%rename(__ldns_pkt_query_new) ldns_pkt_query_new; +%inline +%{ + ldns_pkt * _ldns_pkt_query_new(ldns_rdf *rr_name, ldns_rr_type rr_type, + ldns_rr_class rr_class, uint16_t flags) + { + return ldns_pkt_query_new(ldns_rdf_clone(rr_name), rr_type, rr_class, + flags); + } +%} %rename(__ldns_pkt_push_rr) ldns_pkt_push_rr; -%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(ldns_pkt *p, ldns_pkt_section sec, ldns_rr *rr) + { + return ldns_pkt_push_rr(p, sec, ldns_rr_clone(rr)); + } +%} + +%rename(__ldns_pkt_safe_push_rr) ldns_pkt_safe_push_rr; +%inline +%{ + bool _ldns_pkt_safe_push_rr(ldns_pkt *pkt, ldns_pkt_section sec, + ldns_rr *rr) + { + /* Prevents memory leaks when fails. */ + ldns_rr *rr_clone = NULL; + bool ret; + + if (rr != NULL) { + rr_clone = ldns_rr_clone(rr); + } + ret = ldns_pkt_safe_push_rr(pkt, sec, rr_clone); + if (!ret) { + ldns_rr_free(rr_clone); + } + + return ret; + } %} %rename(__ldns_pkt_push_rr_list) ldns_pkt_push_rr_list; -%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)); -} +%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)); + } +%} + +%rename(__ldns_pkt_safe_push_rr_list) ldns_pkt_safe_push_rr_list; +%inline +%{ + bool _ldns_pkt_safe_push_rr_list(ldns_pkt *p, ldns_pkt_section s, + ldns_rr_list *rrl) + { + /* Prevents memory leaks when fails. */ + ldns_rr_list *rrl_clone = NULL; + bool ret; + + if (rrl != NULL) { + rrl_clone = ldns_rr_list_clone(rrl); + } + ret = ldns_pkt_safe_push_rr_list(p, s, rrl_clone); + if (!ret) { + ldns_rr_list_free(rrl_clone); + } + + return ret; + } +%} + +%rename(__ldns_pkt_set_additional) ldns_pkt_set_additional; +%inline +%{ + void _ldns_pkt_set_additional(ldns_pkt *p, ldns_rr_list *rrl) + { + ldns_rr_list *rrl_clone = NULL; + if (rrl != NULL) { + rrl_clone = ldns_rr_list_clone(rrl); + } + /* May leak memory, when overwriting pointer value. */ + ldns_pkt_set_additional(p, rrl_clone); + } +%} + +%rename(__ldns_pkt_set_answer) ldns_pkt_set_answer; +%inline +%{ + void _ldns_pkt_set_answer(ldns_pkt *p, ldns_rr_list *rrl) + { + ldns_rr_list *rrl_clone = NULL; + if (rrl != NULL) { + rrl_clone = ldns_rr_list_clone(rrl); + } + /* May leak memory, when overwriting pointer value. */ + ldns_pkt_set_answer(p, rrl_clone); + } +%} + +%rename (__ldns_pkt_set_answerfrom) ldns_pkt_set_answerfrom; +%inline +%{ + void _ldns_pkt_set_answerfrom(ldns_pkt *packet, ldns_rdf *rdf) + { + ldns_rdf *rdf_clone = NULL; + if (rdf != NULL) { + rdf_clone = ldns_rdf_clone(rdf); + } + /* May leak memory, when overwriting pointer value. */ + ldns_pkt_set_answerfrom(packet, rdf_clone); + } +%} + +%rename(__ldns_pkt_set_authority) ldns_pkt_set_authority; +%inline +%{ + void _ldns_pkt_set_authority(ldns_pkt *p, ldns_rr_list *rrl) + { + ldns_rr_list *rrl_clone = NULL; + if (rrl != NULL) { + rrl_clone = ldns_rr_list_clone(rrl); + } + /* May leak memory, when overwriting pointer value. */ + ldns_pkt_set_authority(p, rrl_clone); + } +%} + +%rename(__ldns_pkt_set_edns_data) ldns_pkt_set_edns_data; +%inline +%{ + void _ldns_pkt_set_edns_data(ldns_pkt *packet, ldns_rdf *rdf) + { + ldns_rdf *rdf_clone = NULL; + if (rdf != NULL) { + rdf_clone = ldns_rdf_clone(rdf); + } + /* May leak memory, when overwriting pointer value. */ + ldns_pkt_set_edns_data(packet, rdf_clone); + } +%} + +%rename(__ldns_pkt_set_question) ldns_pkt_set_question; +%inline +%{ + void _ldns_pkt_set_question(ldns_pkt *p, ldns_rr_list *rrl) + { + ldns_rr_list *rrl_clone = NULL; + if (rrl != NULL) { + rrl_clone = ldns_rr_list_clone(rrl); + } + /* May leak memory, when overwriting pointer value. */ + ldns_pkt_set_question(p, rrl_clone); + } +%} + +%rename(__ldns_pkt_set_tsig) ldns_pkt_set_tsig; +%inline +%{ + void _ldns_pkt_set_tsig(ldns_pkt *pkt, ldns_rr *rr) + { + ldns_rr *rr_clone = NULL; + if (rr != NULL) { + rr_clone = ldns_rr_clone(rr); + } + /* May leak memory, when overwriting pointer value. */ + ldns_pkt_set_tsig(pkt, rr_clone); + } +%} + +/* End of push cloning. */ + + +/* ========================================================================= */ +/* Debugging related code. */ +/* ========================================================================= */ + +#ifdef LDNS_DEBUG +%rename(__ldns_pkt_free) ldns_pkt_free; +%inline +%{ + /*! + * @brief Prints information about deallocated pkt and deallocates. + */ + void _ldns_pkt_free (ldns_pkt* p) { + printf("******** LDNS_PKT free 0x%lX ************\n", + (long unsigned int) p); + ldns_pkt_free(p); + } %} +#else /* !LDNS_DEBUG */ +%rename(_ldns_pkt_free) ldns_pkt_free; +#endif /* LDNS_DEBUG */ + + +/* ========================================================================= */ +/* Added C code. */ +/* ========================================================================= */ + +/* None. */ + + +/* ========================================================================= */ +/* Encapsulating Python code. */ +/* ========================================================================= */ %feature("docstring") ldns_struct_pkt "LDNS packet object. -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`). +The :class:`ldns_pkt` object contains DNS packed (either a query or an answer). +It is the complete representation of what you actually send to a name server, +and what you get back (see :class:`ldns.ldns_resolver`). **Usage** @@ -148,40 +396,91 @@ nic.cz. 758 IN NS e.ns.nic.cz. ;; WHEN: Thu Jan 11 12:54:33 2009 ;; MSG SIZE rcvd: 75 -This simple example instances a resolver in order to resolve NS for nic.cz. -" +This simple example instances a resolver in order to resolve NS for nic.cz." %extend ldns_struct_pkt { - %pythoncode %{ + %pythoncode + %{ def __init__(self): - 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()") + """ + Cannot be created directly from Python. + """ + 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") __swig_destroy__ = _ldns._ldns_pkt_free - #LDNS_PKT_CONSTRUCTORS_# + # + # LDNS_PKT_CONSTRUCTORS_ + # + + @staticmethod + def new(): + """ + Creates new empty packet structure. + + :return: (:class:`ldns_pkt` ) New empty packet. + """ + return _ldns.ldns_pkt_new() + @staticmethod def new_query(rr_name, rr_type, rr_class, flags): - """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 packet with a query in it for the given name, + type and class. + + :param rr_name: The name to query for. + :type rr_name: :class:`ldns_dname` + :param rr_type: The type to query for. + :type rr_type: ldns_rr_type + :param rr_class: The class to query for. + :type rr_class: ldns_rr_class + :param flags: Packet flags. + :type flags: uint16_t + :throws TypeError: When arguments of inappropriate types. + :return: (:class:`ldns_pkt`) New object. + + .. note:: + The type checking of parameter `rr_name` is benevolent. + It allows also to pass a dname :class:`ldns_rdf` object. + This will probably change in future. + """ + if (not isinstance(rr_name, ldns_dname)) and \ + isinstance(rr_name, ldns_rdf) and \ + rr_name.get_type() == _ldns.LDNS_RDF_TYPE_DNAME: + warnings.warn("The ldns_pkt.new_query() method will" + + " drop the possibility to accept ldns_rdf." + + " Convert argument to ldns_dname.", + PendingDeprecationWarning, stacklevel=2) + if not isinstance(rr_name, ldns_rdf): + raise TypeError("Parameter must be derived from ldns_rdf.") + if (rr_name.get_type() != _ldns.LDNS_RDF_TYPE_DNAME): + raise Exception("Operands must be ldns_dname.") + return _ldns._ldns_pkt_query_new(rr_name, rr_type, rr_class, flags) @staticmethod def new_query_frm_str(rr_name, rr_type, rr_class, flags, raiseException = True): - """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. + """ + Creates a query packet for the given name, type, class. + + :param rr_name: The name to query for. + :type rr_name: str + :param rr_type: The type to query for. + :type rr_type: ldns_rr_type + :param rr_class: The class to query for. + :type rr_class: ldns_rr_class + :param flags: Packet flags. + :type flags: uint16_t + :param raiseException: If True, an exception occurs in case a + packet object can't be created. + :throws TypeError: When arguments of inappropriate types. + :throws Exception: When raiseException set and packet couldn't + be created. + :return: (:class:`ldns_pkt`) Query packet object or None. + If the object can't be created and raiseException is True, + an exception occurs. **Usage** @@ -209,30 +508,57 @@ This simple example instances a resolver in order to resolve NS for nic.cz. if (raiseException): raise Exception("Can't create query packet, error: %d" % status) return None return pkt - #_LDNS_PKT_CONSTRUCTORS# + + # + # _LDNS_PKT_CONSTRUCTORS + # def __str__(self): - """Converts the data in the DNS packet to presentation format""" + """ + Converts the data in the DNS packet to presentation format. + + :return: (str) + """ return _ldns.ldns_pkt2str(self) def opcode2str(self): - """Converts a packet opcode to its mnemonic and returns that as an allocated null-terminated string.""" + """ + Converts a packet opcode to its mnemonic and returns that as an + allocated null-terminated string. + + :return: (str) + """ return _ldns.ldns_pkt_opcode2str(self.get_opcode()) def rcode2str(self): - """Converts a packet rcode 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. + + :return: (str) + """ return _ldns.ldns_pkt_rcode2str(self.get_rcode()) - 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) + def print_to_file(self, output): + """ + Prints the data in the DNS packet to the given file stream + (in presentation format). + + :param output: Opened file to write to. + :type output: file + :throws TypeError: When arguments of inappropriate types. + """ + _ldns.ldns_pkt_print(output, self) #parameters: FILE *,const ldns_pkt *, def write_to_buffer(self, buffer): - """Copies the packet data to the buffer in wire format. + """ + Copies the packet data to the buffer in wire format. - :param buffer: buffer to append the result to - :returns: (ldns_status) ldns_status + :param buffer: Buffer to append the result to. + :type buffer: :class:`ldns_buffer` + :throws TypeError: When arguments of inappropriate types. + :return: (ldns_status) ldns_status """ return _ldns.ldns_pkt2buffer_wire(buffer, self) #parameters: ldns_buffer *,const ldns_pkt *, @@ -240,847 +566,1023 @@ This simple example instances a resolver in order to resolve NS for nic.cz. @staticmethod def algorithm2str(alg): - """Converts a signing algorithms to its mnemonic and returns that as an allocated null-terminated string.""" + """ + Converts a signing algorithms to its mnemonic and returns that + as an allocated null-terminated string. + + :param alg: The algorithm to convert to text. + :type alg: ldns_algorithm + :return: (str) + """ return _ldns.ldns_pkt_algorithm2str(alg) #parameters: ldns_algorithm, @staticmethod def cert_algorithm2str(alg): - """Converts a cert algorithm 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. + + :param alg: Cert algorithm to convert to text. + :type alg: ldns_cert_algorithm + :return: (str) + """ return _ldns.ldns_pkt_cert_algorithm2str(alg) #parameters: ldns_algorithm, - #LDNS_PKT_METHODS_# + # + # LDNS_PKT_METHODS_ + # + def aa(self): - """Read the packet's aa bit. + """ + Read the packet's aa bit. - :returns: (bool) value of the bit + :return: (bool) Value of the bit. """ return _ldns.ldns_pkt_aa(self) #parameters: const ldns_pkt *, #retvals: bool def ad(self): - """Read the packet's ad bit. + """ + Read the packet's ad bit. - :returns: (bool) value of the bit + :return: (bool) Value of the bit. """ return _ldns.ldns_pkt_ad(self) #parameters: const ldns_pkt *, #retvals: bool def additional(self): - """Return the packet's additional section. + """ + Return the packet's additional section. - :returns: (ldns_rr_list \*) the section + :return: (:class:`ldns_rr_list`) The additional section. """ return _ldns._ldns_pkt_additional(self) #parameters: const ldns_pkt *, #retvals: ldns_rr_list * def all(self): + """ + Return the packet's question, answer, authority and additional + sections concatenated. + + :return: (:class:`ldns_rr_list`) Concatenated sections. + """ return _ldns.ldns_pkt_all(self) #parameters: const ldns_pkt *, #retvals: ldns_rr_list * def all_noquestion(self): + """ + Return the packet's answer, authority and additional sections + concatenated. + Like :meth:`all` but without the questions. + + :return: (:class:`ldns_rr_list`) Concatenated sections except + questions. + """ return _ldns.ldns_pkt_all_noquestion(self) #parameters: const ldns_pkt *, #retvals: ldns_rr_list * def ancount(self): - """Return the packet's an count. + """ + Return the packet's an count. - :returns: (uint16_t) the an count + :return: (int) The an count. """ return _ldns.ldns_pkt_ancount(self) #parameters: const ldns_pkt *, #retvals: uint16_t def answer(self): - """Return the packet's answer section. + """ + Return the packet's answer section. - :returns: (ldns_rr_list \*) the section + :return: (:class:`ldns_rr_list`) The answer section. """ return _ldns._ldns_pkt_answer(self) #parameters: const ldns_pkt *, #retvals: ldns_rr_list * def answerfrom(self): - """Return the packet's answerfrom. + """ + Return the packet's answerfrom. - :returns: (ldns_rdf \*) the name of the server + :return: (:class:`ldns_rdf`) The name of the server. """ - return _ldns.ldns_pkt_answerfrom(self) + return _ldns._ldns_pkt_answerfrom(self) #parameters: const ldns_pkt *, #retvals: ldns_rdf * def arcount(self): - """Return the packet's ar count. + """ + Return the packet's ar count. - :returns: (uint16_t) the ar count + :return: (int) The ar count. """ return _ldns.ldns_pkt_arcount(self) #parameters: const ldns_pkt *, #retvals: uint16_t def authority(self): - """Return the packet's authority section. + """ + Return the packet's authority section. - :returns: (ldns_rr_list \*) the section + :return: (:class:`ldns_rr_list`) The authority section. """ return _ldns._ldns_pkt_authority(self) #parameters: const ldns_pkt *, #retvals: ldns_rr_list * def cd(self): - """Read the packet's cd bit. + """ + Read the packet's cd bit. - :returns: (bool) value of the bit + :return: (bool) Value of the bit. """ return _ldns.ldns_pkt_cd(self) #parameters: const ldns_pkt *, #retvals: bool def clone(self): - """clones the given packet, creating a fully allocated copy + """ + Clones the packet, creating a fully allocated copy. - :returns: (ldns_pkt \*) ldns_pkt* pointer to the new packet + :return: (:class:`ldns_pkt`) New packet clone. """ return _ldns.ldns_pkt_clone(self) #parameters: ldns_pkt *, #retvals: ldns_pkt * def edns(self): - """returns true if this packet needs and EDNS rr to be sent. + """ + 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. + 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: (bool) True if packet needs EDNS rr. """ return _ldns.ldns_pkt_edns(self) #parameters: const ldns_pkt *, #retvals: bool def edns_data(self): - """return the packet's edns data + """ + Return the packet's edns data. - :returns: (ldns_rdf \*) the data + :return: (:class:`ldns_rdf`) The ensd data. """ - return _ldns.ldns_pkt_edns_data(self) + return _ldns._ldns_pkt_edns_data(self) #parameters: const ldns_pkt *, #retvals: ldns_rdf * def edns_do(self): - """return the packet's edns do bit + """ + Return the packet's edns do bit - :returns: (bool) the bit's value + :return: (bool) The bit's value. """ return _ldns.ldns_pkt_edns_do(self) #parameters: const ldns_pkt *, #retvals: bool def edns_extended_rcode(self): - """return the packet's edns extended rcode + """ + Return the packet's edns extended rcode. - :returns: (uint8_t) the rcode + :return: (uint8_t) The rcode. """ return _ldns.ldns_pkt_edns_extended_rcode(self) #parameters: const ldns_pkt *, #retvals: uint8_t def edns_udp_size(self): - """return the packet's edns udp size + """ + Return the packet's edns udp size. - :returns: (uint16_t) the size + :return: (uint16_t) The udp size. """ return _ldns.ldns_pkt_edns_udp_size(self) #parameters: const ldns_pkt *, #retvals: uint16_t def edns_version(self): - """return the packet's edns version + """ + Return the packet's edns version. - :returns: (uint8_t) the version + :return: (uint8_t) The edns version. """ return _ldns.ldns_pkt_edns_version(self) #parameters: const ldns_pkt *, #retvals: uint8_t def edns_z(self): - """return the packet's edns z value + """ + Return the packet's edns z value. - :returns: (uint16_t) the z value + :return: (uint16_t) The z value. """ return _ldns.ldns_pkt_edns_z(self) #parameters: const ldns_pkt *, #retvals: uint16_t def empty(self): - """check if a packet is empty + """ + Check if a packet is empty. - :returns: (bool) true: empty, false: empty + :return: (bool) True: empty, False: not empty """ return _ldns.ldns_pkt_empty(self) #parameters: ldns_pkt *, #retvals: bool def get_opcode(self): - """Read the packet's code. + """ + Read the packet's code. - :returns: (ldns_pkt_opcode) the opcode + :return: (ldns_pkt_opcode) the opcode """ return _ldns.ldns_pkt_get_opcode(self) #parameters: const ldns_pkt *, #retvals: ldns_pkt_opcode def get_rcode(self): - """Return the packet's respons code. + """ + Return the packet's response code. - :returns: (ldns_pkt_rcode) the respons code + :return: (ldns_pkt_rcode) The response code. """ return _ldns.ldns_pkt_get_rcode(self) #parameters: const ldns_pkt *, #retvals: ldns_pkt_rcode - def get_section_clone(self,s): - """return all the rr_list's in the packet. - - Clone the lists, instead of returning pointers. + def get_section_clone(self, s): + """ + Return the selected rr_list's in the packet. - :param s: - what section(s) to return - :returns: (ldns_rr_list \*) ldns_rr_list with the rr's or NULL if none were found + :param s: What section(s) to return. + :type s: ldns_pkt_section + :throws TypeError: When arguments of inappropriate types. + :return: (:class:`ldns_rr_list`) RR list with the rr's or None + if none were found. """ - return _ldns.ldns_pkt_get_section_clone(self,s) + return _ldns.ldns_pkt_get_section_clone(self, s) #parameters: const ldns_pkt *,ldns_pkt_section, #retvals: ldns_rr_list * def id(self): - """Read the packet id. + """ + Read the packet id. - :returns: (uint16_t) the packet id + :return: (uint16_t) The packet id. """ return _ldns.ldns_pkt_id(self) #parameters: const ldns_pkt *, #retvals: uint16_t def nscount(self): - """Return the packet's ns count. + """ + Return the packet's ns count. - :returns: (uint16_t) the ns count + :return: (uint16_t) The ns count. """ return _ldns.ldns_pkt_nscount(self) #parameters: const ldns_pkt *, #retvals: uint16_t - def push_rr(self,section,rr): - """push an rr on a packet + 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 + :param section: Where to put it. + :type section: ldns_pkt_section + :param rr: RR to push. + :type rr: :class:`ldns_rr` + :throws TypeError: When arguments of inappropriate types. + :return: (bool) A boolean which is True when the rr was added. """ return _ldns._ldns_pkt_push_rr(self,section,rr) #parameters: ldns_pkt *,ldns_pkt_section,ldns_rr *, #retvals: bool - def push_rr_list(self,section,list): - """push a rr_list on a packet + 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 + :param section: Where to put it. + :type section: ldns_pkt_section + :param list: The rr_list to push. + :type list: :class:`ldns_rr_list` + :throws TypeError: When arguments of inappropriate types. + :return: (bool) A boolean which is True when the rr was added. """ return _ldns._ldns_pkt_push_rr_list(self,section,list) #parameters: ldns_pkt *,ldns_pkt_section,ldns_rr_list *, #retvals: bool def qdcount(self): - """Return the packet's qd count. + """ + Return the packet's qd count. - :returns: (uint16_t) the qd count + :return: (uint16_t) The qd count. """ return _ldns.ldns_pkt_qdcount(self) #parameters: const ldns_pkt *, #retvals: uint16_t def qr(self): - """Read the packet's qr bit. + """ + Read the packet's qr bit. - :returns: (bool) value of the bit + :return: (bool) value of the bit """ return _ldns.ldns_pkt_qr(self) #parameters: const ldns_pkt *, #retvals: bool def querytime(self): - """Return the packet's querytime. + """ + Return the packet's query time. - :returns: (uint32_t) the querytime + :return: (uint32_t) The query time. """ return _ldns.ldns_pkt_querytime(self) #parameters: const ldns_pkt *, #retvals: uint32_t def question(self): - """Return the packet's question section. + """ + Return the packet's question section. - :returns: (ldns_rr_list \*) the section + :return: (:class:`ldns_rr_list`) The question section. """ return _ldns._ldns_pkt_question(self) #parameters: const ldns_pkt *, #retvals: ldns_rr_list * def ra(self): - """Read the packet's ra bit. + """ + Read the packet's ra bit. - :returns: (bool) value of the bit + :return: (bool) Value of the bit. """ return _ldns.ldns_pkt_ra(self) #parameters: const ldns_pkt *, #retvals: bool def rd(self): - """Read the packet's rd bit. + """ + Read the packet's rd bit. - :returns: (bool) value of the bit + :return: (bool) Value of the bit. """ return _ldns.ldns_pkt_rd(self) #parameters: const ldns_pkt *, #retvals: bool def reply_type(self): - """looks inside the packet to determine what kind of packet it is, AUTH, NXDOMAIN, REFERRAL, etc. + """ + Looks inside the packet to determine what kind of packet it is, + AUTH, NXDOMAIN, REFERRAL, etc. - :returns: (ldns_pkt_type) the type of packet + :return: (ldns_pkt_type) The type of packet. """ return _ldns.ldns_pkt_reply_type(self) #parameters: ldns_pkt *, #retvals: ldns_pkt_type - def rr(self,sec,rr): - """check to see if an rr exist in the 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) + :param sec: In which section to look. + :type sec: ldns_pkt_section + :param rr: The rr to look for. + :type rr: :class:`ldns_rr` + :throws TypeError: When arguments of inappropriate types. + :return: (bool) Return True is exists. """ - return _ldns.ldns_pkt_rr(self,sec,rr) + return _ldns.ldns_pkt_rr(self, sec, rr) #parameters: ldns_pkt *,ldns_pkt_section,ldns_rr *, #retvals: bool - 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 + def rr_list_by_name(self, r, s): + """ + Return all the rr with a specific name from a 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 + :param r: The name. + :type r: :class:`ldns_rdf` + :param s: The packet's section. + :type s: ldns_pkt_section + :throws TypeError: When arguments of inappropriate types. + :return: (:class:`ldns_rr_list`) A list with the rr's or None + if none were found. """ return _ldns.ldns_pkt_rr_list_by_name(self,r,s) #parameters: ldns_pkt *,ldns_rdf *,ldns_pkt_section, #retvals: ldns_rr_list * - 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 + def rr_list_by_name_and_type(self, ownername, atype, sec): + """ + Return all the rr with a specific type and type from a 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 + :param ownername: The name. + :type ownername: :class:`ldns_rdf` + :param atype: The type. + :type atype: ldns_rr_type + :param sec: The packet's section. + :type sec: ldns_pkt_section + :throws TypeError: When arguments of inappropriate types. + :return: (:class:`ldns_rr_list`) A list with the rr's or None + if none were found. """ - return _ldns.ldns_pkt_rr_list_by_name_and_type(self,ownername,atype,sec) + return _ldns.ldns_pkt_rr_list_by_name_and_type(self, ownername, atype, sec) #parameters: const ldns_pkt *,const ldns_rdf *,ldns_rr_type,ldns_pkt_section, #retvals: ldns_rr_list * - 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 + def rr_list_by_type(self, t, s): + """ + Return all the rr with a specific type from a 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 + :param t: The type. + :type t: ldns_rr_type + :param s: The packet's section. + :type s: ldns_pkt_section + :throws TypeError: When arguments of inappropriate types. + :return: (:class:`ldns_rr_list`) A list with the rr's or None + if none were found. """ - return _ldns.ldns_pkt_rr_list_by_type(self,t,s) + return _ldns.ldns_pkt_rr_list_by_type(self, t, s) #parameters: const ldns_pkt *,ldns_rr_type,ldns_pkt_section, #retvals: ldns_rr_list * - def safe_push_rr(self,sec,rr): - """push an rr on a packet, provided the RR is not there. + 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 + :param sec: Where to put it. + :type sec: ldns_pkt_section + :param rr: RR to push. + :type rr: :class:`ldns_rr` + :throws TypeError: When arguments of inappropriate types. + :return: (bool) A boolean which is True when the rr was added. """ - return _ldns.ldns_pkt_safe_push_rr(self,sec,rr) + return _ldns._ldns_pkt_safe_push_rr(self,sec,rr) #parameters: ldns_pkt *,ldns_pkt_section,ldns_rr *, #retvals: bool - def safe_push_rr_list(self,sec,list): - """push an rr_list to a packet, provided the RRs are not already there. + 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 + :param sec: Where to put it. + :type sec: ldns_pkt_section + :param list: The rr_list to push. + :type list: :class:`ldns_rr_list` + :throws TypeError: When arguments of inappropriate types. + :return: (bool) A boolean which is True when the list was added. """ - return _ldns.ldns_pkt_safe_push_rr_list(self,sec,list) + return _ldns._ldns_pkt_safe_push_rr_list(self, sec, list) #parameters: ldns_pkt *,ldns_pkt_section,ldns_rr_list *, #retvals: bool - 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. + def set_aa(self, b): + """ + Set the packet's aa bit. - :param b: - the value to set (boolean) + :param b: The value to set. + :type b: bool """ - _ldns.ldns_pkt_set_aa(self,b) + _ldns.ldns_pkt_set_aa(self, b) #parameters: ldns_pkt *,bool, #retvals: - def set_ad(self,b): - """Set the packet's ad bit. + def set_ad(self, b): + """ + Set the packet's ad bit. - :param b: - the value to set (boolean) + :param b: The value to set. + :type b: bool """ - _ldns.ldns_pkt_set_ad(self,b) + _ldns.ldns_pkt_set_ad(self, b) #parameters: ldns_pkt *,bool, #retvals: - def set_additional(self,rr): - """directly set the additional section + def set_additional(self, rr): + """ + Directly set the additional section. - :param rr: - rrlist to set + :param rr: The rr list to set. + :type rr: :class:`ldns_rr_list` + :throws TypeError: When arguments of inappropriate types. """ - _ldns.ldns_pkt_set_additional(self,rr) + _ldns._ldns_pkt_set_additional(self, rr) #parameters: ldns_pkt *,ldns_rr_list *, #retvals: - def set_ancount(self,c): - """Set the packet's an count. + def set_ancount(self, c): + """ + Set the packet's an count. - :param c: - the count + :param c: The count. + :type c: int + :throws TypeError: When arguments of inappropriate types. """ - _ldns.ldns_pkt_set_ancount(self,c) + _ldns.ldns_pkt_set_ancount(self, c) #parameters: ldns_pkt *,uint16_t, #retvals: - def set_answer(self,rr): - """directly set the answer section + def set_answer(self, rr): + """ + Directly set the answer section. - :param rr: - rrlist to set + :param rr: The rr list to set. + :type rr: :class:`ldns_rr_list` + :throws TypeError: When arguments of inappropriate types. """ - _ldns.ldns_pkt_set_answer(self,rr) + _ldns._ldns_pkt_set_answer(self, rr) #parameters: ldns_pkt *,ldns_rr_list *, #retvals: - def set_answerfrom(self,r): - """Set the packet's answering server. + def set_answerfrom(self, r): + """ + Set the packet's answering server. - :param r: - the address + :param r: The address. + :type r: :class:`ldns_rdf` + :throws TypeError: When arguments of inappropriate types. """ - _ldns.ldns_pkt_set_answerfrom(self,r) + _ldns._ldns_pkt_set_answerfrom(self, r) #parameters: ldns_pkt *,ldns_rdf *, #retvals: - def set_arcount(self,c): - """Set the packet's arcount. + def set_arcount(self, c): + """ + Set the packet's arcount. - :param c: - the count + :param c: The count. + :type c: int + :throws TypeError: When arguments of inappropriate types. """ _ldns.ldns_pkt_set_arcount(self,c) #parameters: ldns_pkt *,uint16_t, #retvals: - def set_authority(self,rr): - """directly set the auhority section + def set_authority(self, rr): + """ + Directly set the authority section. - :param rr: - rrlist to set + :param rr: The rr list to set. + :type rr: :class:`ldns_rr_list` + :throws TypeError: When arguments of inappropriate types. """ - _ldns.ldns_pkt_set_authority(self,rr) + _ldns._ldns_pkt_set_authority(self, rr) #parameters: ldns_pkt *,ldns_rr_list *, #retvals: - def set_cd(self,b): - """Set the packet's cd bit. + def set_cd(self, b): + """ + Set the packet's cd bit. - :param b: - the value to set (boolean) + :param b: The value to set. + :type b: bool """ - _ldns.ldns_pkt_set_cd(self,b) + _ldns.ldns_pkt_set_cd(self, b) #parameters: ldns_pkt *,bool, #retvals: - def set_edns_data(self,data): - """Set the packet's edns data. + def set_edns_data(self, data): + """ + Set the packet's edns data. - :param data: - the data + :param data: The data. + :type data: :class:`ldns_rdf` + :throws TypeError: When arguments of inappropriate types. """ - _ldns.ldns_pkt_set_edns_data(self,data) + _ldns._ldns_pkt_set_edns_data(self, data) #parameters: ldns_pkt *,ldns_rdf *, #retvals: - def set_edns_do(self,value): - """Set the packet's edns do bit. + def set_edns_do(self, value): + """ + Set the packet's edns do bit. - :param value: - the bit's new value + :param value: The bit's new value. + :type value: bool """ - _ldns.ldns_pkt_set_edns_do(self,value) + _ldns.ldns_pkt_set_edns_do(self, value) #parameters: ldns_pkt *,bool, #retvals: - def set_edns_extended_rcode(self,c): - """Set the packet's edns extended rcode. + def set_edns_extended_rcode(self, c): + """ + Set the packet's edns extended rcode. - :param c: - the code + :param c: The code. + :type c: uint8_t + :throws TypeError: When arguments of inappropriate types. """ - _ldns.ldns_pkt_set_edns_extended_rcode(self,c) + _ldns.ldns_pkt_set_edns_extended_rcode(self, c) #parameters: ldns_pkt *,uint8_t, #retvals: - def set_edns_udp_size(self,s): - """Set the packet's edns udp size. + def set_edns_udp_size(self, s): + """ + Set the packet's edns udp size. - :param s: - the size + :param s: The size. + :type s: uint16_t + :throws TypeError: When arguments of inappropriate types. """ - _ldns.ldns_pkt_set_edns_udp_size(self,s) + _ldns.ldns_pkt_set_edns_udp_size(self, s) #parameters: ldns_pkt *,uint16_t, #retvals: - def set_edns_version(self,v): - """Set the packet's edns version. + def set_edns_version(self, v): + """ + Set the packet's edns version. - :param v: - the version + :param v: The version. + :type v: uint8_t + :throws TypeError: When arguments of inappropriate types. """ - _ldns.ldns_pkt_set_edns_version(self,v) + _ldns.ldns_pkt_set_edns_version(self, v) #parameters: ldns_pkt *,uint8_t, #retvals: - def set_edns_z(self,z): - """Set the packet's edns z value. + def set_edns_z(self, z): + """ + Set the packet's edns z value. - :param z: - the value + :param z: The value. + :type z: uint16_t + :throws TypeError: When arguments of inappropriate types. """ - _ldns.ldns_pkt_set_edns_z(self,z) + _ldns.ldns_pkt_set_edns_z(self, z) #parameters: ldns_pkt *,uint16_t, #retvals: - def set_flags(self,flags): - """sets the flags in a packet. + 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 + :param flags: ORed values: LDNS_QR| LDNS_AR for instance. + :type flags: int + :throws TypeError: When arguments of inappropriate types. + :return: (bool) True on success, False otherwise. """ - return _ldns.ldns_pkt_set_flags(self,flags) + return _ldns.ldns_pkt_set_flags(self, flags) #parameters: ldns_pkt *,uint16_t, #retvals: bool - def set_id(self,id): - """Set the packet's id. + def set_id(self, id): + """ + Set the packet's id. - :param id: - the id to set + :param id: The id to set. + :type id: uint16_t + :throws TypeError: When arguments of inappropriate types. """ - _ldns.ldns_pkt_set_id(self,id) + _ldns.ldns_pkt_set_id(self, id) #parameters: ldns_pkt *,uint16_t, #retvals: - def set_nscount(self,c): - """Set the packet's ns count. + def set_nscount(self, c): + """ + Set the packet's ns count. - :param c: - the count + :param c: The count. + :type c: int + :throws TypeError: When arguments of inappropriate types. """ - _ldns.ldns_pkt_set_nscount(self,c) + _ldns.ldns_pkt_set_nscount(self, c) #parameters: ldns_pkt *,uint16_t, #retvals: - def set_opcode(self,c): - """Set the packet's opcode. + def set_opcode(self, c): + """ + Set the packet's opcode. - :param c: - the opcode + :param c: The opcode. + :type c: ldns_pkt_opcode + :throws TypeError: When arguments of inappropriate types. """ - _ldns.ldns_pkt_set_opcode(self,c) + _ldns.ldns_pkt_set_opcode(self, c) #parameters: ldns_pkt *,ldns_pkt_opcode, #retvals: - def set_qdcount(self,c): - """Set the packet's qd count. + def set_qdcount(self, c): + """ + Set the packet's qd count. - :param c: - the count + :param c: The count. + :type c: int + :throws TypeError: When arguments of inappropriate types. """ - _ldns.ldns_pkt_set_qdcount(self,c) + _ldns.ldns_pkt_set_qdcount(self, c) #parameters: ldns_pkt *,uint16_t, #retvals: - def set_qr(self,b): - """Set the packet's qr bit. + def set_qr(self, b): + """ + Set the packet's qr bit. - :param b: - the value to set (boolean) + :param b: The value to set. + :type b: bool """ - _ldns.ldns_pkt_set_qr(self,b) + _ldns.ldns_pkt_set_qr(self, b) #parameters: ldns_pkt *,bool, #retvals: - def set_querytime(self,t): - """Set the packet's query time. + def set_querytime(self, t): + """ + Set the packet's query time. - :param t: - the querytime in msec + :param t: The query time in msec. + :type t: uint32_t + :throws TypeError: When arguments of inappropriate types. """ - _ldns.ldns_pkt_set_querytime(self,t) + _ldns.ldns_pkt_set_querytime(self, t) #parameters: ldns_pkt *,uint32_t, #retvals: - def set_question(self,rr): - """directly set the question section + def set_question(self, rr): + """ + Directly set the question section. - :param rr: - rrlist to set + :param rr: The rr list to set. + :type rr: :class:`ldns_rr_list` + :throws TypeError: When arguments of inappropriate types. """ - _ldns.ldns_pkt_set_question(self,rr) + _ldns._ldns_pkt_set_question(self, rr) #parameters: ldns_pkt *,ldns_rr_list *, #retvals: - def set_ra(self,b): - """Set the packet's ra bit. + def set_ra(self, b): + """ + Set the packet's ra bit. - :param b: - the value to set (boolean) + :param b: The value to set. + :type b: bool """ - _ldns.ldns_pkt_set_ra(self,b) + _ldns.ldns_pkt_set_ra(self, b) #parameters: ldns_pkt *,bool, #retvals: def set_random_id(self): - """Set the packet's id to a random value. + """ + Set the packet's id to a random value. """ _ldns.ldns_pkt_set_random_id(self) #parameters: ldns_pkt *, #retvals: - def set_rcode(self,c): - """Set the packet's respons code. + def set_rcode(self, c): + """ + Set the packet's respons code. - :param c: - the rcode + :param c: The rcode. + :type c: uint8_t + :throws TypeError: When arguments of inappropriate types. """ - _ldns.ldns_pkt_set_rcode(self,c) + _ldns.ldns_pkt_set_rcode(self, c) #parameters: ldns_pkt *,uint8_t, #retvals: - def set_rd(self,b): - """Set the packet's rd bit. + def set_rd(self, b): + """ + Set the packet's rd bit. - :param b: - the value to set (boolean) + :param b: The value to set. + :type b: bool """ - _ldns.ldns_pkt_set_rd(self,b) + _ldns.ldns_pkt_set_rd(self, b) #parameters: ldns_pkt *,bool, #retvals: - def set_section_count(self,s,x): - """Set a packet's section count to x. + def set_section_count(self, s, x): + """ + Set a packet's section count to x. - :param s: - the section - :param x: - the section count + :param s: The section. + :type s: ldns_pkt_section + :param x: The section count. + :type x: uint16_t + :throws TypeError: When arguments of inappropriate types. """ - _ldns.ldns_pkt_set_section_count(self,s,x) + _ldns.ldns_pkt_set_section_count(self, s, x) #parameters: ldns_pkt *,ldns_pkt_section,uint16_t, #retvals: - def set_size(self,s): - """Set the packet's size. + def set_size(self, s): + """ + Set the packet's size. - :param s: - the size + :param s: The size. + :type s: int + :throws TypeError: When arguments of inappropriate types. """ _ldns.ldns_pkt_set_size(self,s) #parameters: ldns_pkt *,size_t, #retvals: - def set_tc(self,b): - """Set the packet's tc bit. + def set_tc(self, b): + """ + Set the packet's tc bit. - :param b: - the value to set (boolean) + :param b: The value to set. + :type b: bool """ - _ldns.ldns_pkt_set_tc(self,b) + _ldns.ldns_pkt_set_tc(self, b) #parameters: ldns_pkt *,bool, #retvals: - def set_timestamp(self,timeval): - _ldns.ldns_pkt_set_timestamp(self,timeval) + def set_timestamp(self, timeval): + """ + Set the packet's time stamp. + + :param timestamp: The time stamp. + :type timestamp: struct timeval + :throws TypeError: When arguments of inappropriate types. + """ + _ldns.ldns_pkt_set_timestamp(self, timeval) #parameters: ldns_pkt *,struct timeval, #retvals: - def set_tsig(self,t): - """Set the packet's tsig rr. + def set_tsig(self, t): + """ + Set the packet's tsig rr. - :param t: - the tsig rr + :param t: The tsig rr. + :type t: :class:`ldns_rr` + :throws TypeError: When arguments of inappropriate types. """ - _ldns.ldns_pkt_set_tsig(self,t) + _ldns._ldns_pkt_set_tsig(self, t) #parameters: ldns_pkt *,ldns_rr *, #retvals: def size(self): - """Return the packet's size in bytes. + """ + Return the packet's size in bytes. - :returns: (size_t) the size + :return: (size_t) The size. """ return _ldns.ldns_pkt_size(self) #parameters: const ldns_pkt *, #retvals: size_t def tc(self): - """Read the packet's tc bit. + """ + Read the packet's tc bit. - :returns: (bool) value of the bit + :return: (bool) Value of the bit. """ return _ldns.ldns_pkt_tc(self) #parameters: const ldns_pkt *, #retvals: bool def timestamp(self): - """Return the packet's timestamp. + """ + Return the packet's time stamp. - :returns: (struct timeval) the timestamp + :return: (struct timeval) The time stamp. """ return _ldns.ldns_pkt_timestamp(self) #parameters: const ldns_pkt *, #retvals: struct timeval def tsig(self): - """Return the packet's tsig pseudo rr's. + """ + Return the packet's tsig pseudo rr's. - :returns: (ldns_rr \*) the tsig rr + :return: (:class:`ldns_rr`) The tsig rr. """ - return _ldns.ldns_pkt_tsig(self) + return _ldns._ldns_pkt_tsig(self) #parameters: const ldns_pkt *, #retvals: ldns_rr * - #_LDNS_PKT_METHODS# + # + # _LDNS_PKT_METHODS# + # + + # + # LDNS update methods + # + + # + # LDNS_METHODS_ + # - #LDNS update methods - #LDNS_METHODS_# - def update_pkt_tsig_add(self,r): - """add tsig credentials to a packet from a resolver + def update_ad(self): + """ + Get the ad count. + + :return: (uint16_t) The ad count. + """ + return _ldns.ldns_update_ad(self) + #parameters: ldns_pkt * + #retvals: uint16_t + + 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 + :param r: Resolver to copy from. + :type r: :class:`ldns_resolver` + :throws TypeError: When arguments of inappropriate types. + :return: (ldns_status) Status whether successful or not. """ - return _ldns.ldns_update_pkt_tsig_add(self,r) + return _ldns.ldns_update_pkt_tsig_add(self, r) #parameters: ldns_pkt *,ldns_resolver *, #retvals: ldns_status def update_prcount(self): - """Get the zo count. + """ + Get the pr count. - :returns: (uint16_t) the pr count + :return: (uint16_t) The pr count. """ return _ldns.ldns_update_prcount(self) #parameters: const ldns_pkt *, #retvals: uint16_t - def update_set_adcount(self,c): - """Set the ad count. + def update_set_adcount(self, c): + """ + Set the ad count. - :param c: - the ad count to set + :param c: The ad count to set. + :type c: uint16_t + :throws TypeError: When arguments of inappropriate types. """ - _ldns.ldns_update_set_adcount(self,c) + _ldns.ldns_update_set_adcount(self, c) #parameters: ldns_pkt *,uint16_t, #retvals: - def update_set_prcount(self,c): - """Set the pr count. + def update_set_prcount(self, c): + """ + Set the pr count. - :param c: - the pr count to set + :param c: The pr count to set. + :type c: uint16_t + :throws TypeError: When arguments of inappropriate types. """ - _ldns.ldns_update_set_prcount(self,c) + _ldns.ldns_update_set_prcount(self, c) #parameters: ldns_pkt *,uint16_t, #retvals: - def update_set_upcount(self,c): - """Set the up count. + def update_set_upcount(self, c): + """ + Set the up count. - :param c: - the up count to set + :param c: The up count to set. + :type c: uint16_t + :throws TypeError: When arguments of inappropriate types. """ _ldns.ldns_update_set_upcount(self,c) #parameters: ldns_pkt *,uint16_t, #retvals: - def update_set_zo(self,v): - _ldns.ldns_update_set_zo(self,v) + def update_set_zo(self, c): + """ + Set the zo count. + + :param c: The zo count to set. + :type c: uint16_t + :throws TypeError: When arguments of inappropriate types. + """ + _ldns.ldns_update_set_zo(self, c) #parameters: ldns_pkt *,uint16_t, #retvals: def update_upcount(self): - """Get the zo count. + """ + Get the up count. - :returns: (uint16_t) the up count + :return: (uint16_t) The up count. """ return _ldns.ldns_update_upcount(self) #parameters: const ldns_pkt *, #retvals: uint16_t def update_zocount(self): - """Get the zo count. + """ + Get the zo count. - :returns: (uint16_t) the zo count + :return: (uint16_t) The zo count. """ return _ldns.ldns_update_zocount(self) #parameters: const ldns_pkt *, #retvals: uint16_t - #_LDNS_METHODS# - %} + # + # _LDNS_METHODS + # + %} } diff --git a/contrib/python/ldns_rdf.i b/contrib/python/ldns_rdf.i index edff4d6249920..7b69d8b217687 100644 --- a/contrib/python/ldns_rdf.i +++ b/contrib/python/ldns_rdf.i @@ -205,7 +205,7 @@ case LDNS_RDF_TYPE_TIME: return "TIME"; case LDNS_RDF_TYPE_PERIOD: return "PERIOD"; case LDNS_RDF_TYPE_TSIGTIME: return "TSIGTIME"; - case LDNS_RDF_TYPE_TSIG: return "TSIG"; + case LDNS_RDF_TYPE_HIP: return "HIP"; case LDNS_RDF_TYPE_INT16_DATA: return "INT16_DATA"; case LDNS_RDF_TYPE_SERVICE: return "SERVICE"; case LDNS_RDF_TYPE_LOC: return "LOC"; @@ -216,6 +216,11 @@ case LDNS_RDF_TYPE_NSEC3_SALT: return "NSEC3_SALT"; case LDNS_RDF_TYPE_NSEC3_NEXT_OWNER: return "NSEC3_NEXT_OWNER"; + case LDNS_RDF_TYPE_ILNP64: return "ILNP64"; + case LDNS_RDF_TYPE_EUI48: return "EUI48"; + case LDNS_RDF_TYPE_EUI64: return "EUI64"; + case LDNS_RDF_TYPE_TAG: return "TAG"; + case LDNS_RDF_TYPE_LONG_STR: return "LONG_STR"; } } return 0; @@ -223,6 +228,26 @@ %} +%inline +%{ + /*! + * @brief Returns the rdf data organised into a list of bytes. + */ + PyObject * ldns_rdf_data_as_bytearray(const ldns_rdf *rdf) + { + Py_ssize_t len; + uint8_t *data; + + assert(rdf != NULL); + + len = ldns_rdf_size(rdf); + data = ldns_rdf_data(rdf); + + return PyByteArray_FromStringAndSize((char *) data, len); + } +%} + + /* ========================================================================= */ /* Encapsulating Python code. */ /* ========================================================================= */ @@ -463,6 +488,16 @@ specified in the (16-bit) type field with a value from ldns_rdf_type." #parameters: const ldns_rdf *, #retvals: uint8_t * + def data_as_bytearray(self): + """ + Returns the data of the rdf as a bytearray. + + :return: (bytearray) Bytearray containing the rdf data. + """ + return _ldns.ldns_rdf_data_as_bytearray(self) + #parameters: const ldns_rdf *, + #retvals: bytearray + def get_type(self): """ Returns the type of the rdf. @@ -818,7 +853,8 @@ specified in the (16-bit) type field with a value from ldns_rdf_type." Returns a clone of the given dname with the labels reversed. When reversing non-dnames a "." (root name) dname is returned. - + + :throws Exception: When used on non-dname rdfs. :return: (:class:`ldns_rdf`) Clone of the dname with the labels reversed or ".". @@ -831,6 +867,8 @@ specified in the (16-bit) type field with a value from ldns_rdf_type." " to be deprecated in future releases." + " Convert the ldns_rdf to ldsn_dname and the use its" + " methods.", PendingDeprecationWarning, stacklevel=2) + if self.get_type() != _ldns.LDNS_RDF_TYPE_DNAME: + raise Exception("Operand must be a dname rdf.") return _ldns.ldns_dname_reverse(self) #parameters: const ldns_rdf *, #retvals: ldns_rdf * diff --git a/contrib/python/ldns_resolver.i b/contrib/python/ldns_resolver.i index b9640674b5a03..b926e65a81e75 100644 --- a/contrib/python/ldns_resolver.i +++ b/contrib/python/ldns_resolver.i @@ -14,8 +14,8 @@ * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * Neither the name of the organization nor the names of its - * contributors may be used to endorse or promote products derived from this - * software without specific prior written permission. + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE @@ -28,30 +28,41 @@ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. - ******************************************************************************/ + *****************************************************************************/ + +/* ========================================================================= */ +/* SWIG setting and definitions. */ +/* ========================================================================= */ + +/* Creates temporary instance of (ldns_rersolver *). */ %typemap(in,numinputs=0,noblock=1) (ldns_resolver **r) { - ldns_resolver *$1_res; - $1 = &$1_res; + ldns_resolver *$1_res; + $1 = &$1_res; } -/* result generation */ +/* Result generation, appends (ldns_resolver *) after the result. */ %typemap(argout,noblock=1) (ldns_resolver **r) { - $result = SWIG_Python_AppendOutput($result, SWIG_NewPointerObj(SWIG_as_voidptr($1_res), SWIGTYPE_p_ldns_struct_resolver, SWIG_POINTER_OWN | 0 )); + $result = SWIG_Python_AppendOutput($result, + SWIG_NewPointerObj(SWIG_as_voidptr($1_res), + SWIGTYPE_p_ldns_struct_resolver, SWIG_POINTER_OWN | 0 )); } -//TODO: pop_nameserver a podobne funkce musi predat objekt do spravy PYTHONU!! +%newobject ldns_resolver_new; %newobject ldns_resolver_pop_nameserver; %newobject ldns_resolver_query; +%newobject ldns_resolver_search; %newobject ldns_axfr_next; +%newobject ldns_get_rr_list_addr_by_name; +%newobject ldns_get_rr_list_name_by_addr; %delobject ldns_resolver_deep_free; %delobject ldns_resolver_free; -%nodefaultctor ldns_struct_resolver; //no default constructor & destructor -%nodefaultdtor ldns_struct_resolver; +%nodefaultctor ldns_struct_resolver; /* No default constructor. */ +%nodefaultdtor ldns_struct_resolver; /* No default destructor. */ %ignore ldns_struct_resolver::_searchlist; %ignore ldns_struct_resolver::_nameservers; @@ -59,23 +70,225 @@ %rename(ldns_resolver) ldns_struct_resolver; + +/* Clone data on pull. */ + +%newobject _ldns_axfr_last_pkt; +%rename(__ldns_axfr_last_pkt) ldns_axfr_last_pkt; +%inline +%{ + ldns_pkt * _ldns_axfr_last_pkt(const ldns_resolver *res) + { + return ldns_pkt_clone(ldns_axfr_last_pkt(res)); + } +%} + +%newobject _ldns_resolver_dnssec_anchors; +%rename(__ldns_resolver_dnssec_anchors) ldns_resolver_dnssec_anchors; +%inline +%{ + ldns_rr_list * _ldns_resolver_dnssec_anchors(const ldns_resolver *res) + { + return ldns_rr_list_clone(ldns_resolver_dnssec_anchors(res)); + } +%} + +%newobject _ldns_resolver_domain; +%rename(__ldns_resolver_domain) ldns_resolver_domain; +%inline +%{ + ldns_rdf * _ldns_resolver_domain(const ldns_resolver *res) + { + /* Prevents assertion failures. */ + ldns_rdf *rdf; + rdf = ldns_resolver_domain(res); + if (rdf != NULL) { + rdf = ldns_rdf_clone(rdf); + } + return rdf; + } +%} + +%newobject _ldns_resolver_tsig_algorithm; +%rename(__ldns_resolver_tsig_algorithm) ldns_resolver_tsig_algorithm; +%inline +%{ + char * _ldns_resolver_tsig_algorithm(const ldns_resolver *res) + { + char *str; + str = ldns_resolver_tsig_algorithm(res); + if (str != NULL) { + str = strdup(str); + } + return str; + } +%} + +%newobject _ldns_resolver_tsig_keydata; +%rename(__ldns_resolver_tsig_keydata) ldns_resolver_tsig_keydata; +%inline +%{ + char * _ldns_resolver_tsig_keydata(const ldns_resolver *res) + { + char *str; + str = ldns_resolver_tsig_keydata(res); + if (str != NULL) { + str = strdup(str); + } + return str; + } +%} + +%newobject _ldns_resolver_tsig_keyname; +%rename(__ldns_resolver_tsig_keyname) ldns_resolver_tsig_keyname; +%inline +%{ + char * _ldns_resolver_tsig_keyname(const ldns_resolver *res) + { + char *str; + str = ldns_resolver_tsig_keyname(res); + if (str != NULL) { + str = strdup(str); + } + return str; + } +%} + +/* End of pull cloning. */ + +/* Clone data on push. */ + +%rename(__ldns_resolver_set_dnssec_anchors) ldns_resolver_set_dnssec_anchors; +%inline +%{ + void _ldns_resolver_set_dnssec_anchors(ldns_resolver *res, + ldns_rr_list * rrl) + { + ldns_rr_list *rrl_clone = NULL; + if (rrl != NULL) { + rrl_clone = ldns_rr_list_clone(rrl); + } + /* May leak memory, when overwriting pointer value. */ + ldns_resolver_set_dnssec_anchors(res, rrl_clone); + } +%} + +%rename(__ldns_resolver_set_domain) ldns_resolver_set_domain; +%inline +%{ + void _ldns_resolver_set_domain(ldns_resolver *res, ldns_rdf *rdf) + { + ldns_rdf *rdf_clone = NULL; + if (rdf != NULL) { + rdf_clone = ldns_rdf_clone(rdf); + } + /* May leak memory, when overwriting pointer value. */ + ldns_resolver_set_domain(res, rdf_clone); + } +%} + +/* End of push cloning. */ + + +/* ========================================================================= */ +/* Debugging related code. */ +/* ========================================================================= */ + #ifdef LDNS_DEBUG %rename(__ldns_resolver_deep_free) ldns_resolver_deep_free; %rename(__ldns_resolver_free) ldns_resolver_free; -%inline %{ -void _ldns_resolver_free (ldns_resolver* r) { - printf("******** LDNS_RESOLVER deep free 0x%lX ************\n", (long unsigned int)r); - ldns_resolver_deep_free(r); -} +%inline +%{ + /*! + * @brief Prints information about deallocated resolver and deallocates. + */ + void _ldns_resolver_deep_free(ldns_resolver *r) + { + printf("******** LDNS_RESOLVER deep free 0x%lX ************\n", + (long unsigned int) r); + ldns_resolver_deep_free(r); + } + + /*! + * @brief Prints information about deallocated resolver and deallocates. + * + * @note There should be no need to use this function in the wrapper code, as + * it is likely to leak memory. + */ + void _ldns_resolver_free(ldns_resolver *r) + { + printf("******** LDNS_RESOLVER free 0x%lX ************\n", + (long unsigned int) r); + ldns_resolver_free(r); + } %} -#else +#else /* !LDNS_DEBUG */ %rename(_ldns_resolver_deep_free) ldns_resolver_deep_free; %rename(_ldns_resolver_free) ldns_resolver_free; -#endif +#endif /* LDNS_DEBUG */ + + +/* ========================================================================= */ +/* Added C code. */ +/* ========================================================================= */ + +%newobject _replacement_ldns_resolver_trusted_key; +%inline +%{ + /*! + * @brief Replaces the rrs in the list with their clones. + * + * Prevents memory corruption when automatically deallocating list content. + */ + void _rr_list_replace_content_with_clones(ldns_rr_list *rrl) + { + size_t count; + unsigned int i; + + if (rrl == NULL) { + return; + } + + count = ldns_rr_list_rr_count(rrl); + for (i = 0; i < count; ++i) { + ldns_rr_list_set_rr(rrl, + ldns_rr_clone(ldns_rr_list_rr(rrl, i)), + i); + } + } + + /* + * @brief Behaves similarly to ldns_resolver_trusted_key(). + * + * Prevents memory leakage by controlling the usage of content cloning. + * + * @return Newly allocated list of trusted key clones if any found, + * NULL else. + */ + ldns_rr_list * _replacement_ldns_resolver_trusted_key( + const ldns_resolver *res, ldns_rr_list *keys) + { + ldns_rr_list *trusted_keys = ldns_rr_list_new(); + + if (ldns_resolver_trusted_key(res, keys, trusted_keys)) { + _rr_list_replace_content_with_clones(trusted_keys); + } else { + ldns_rr_list_deep_free(trusted_keys); trusted_keys = NULL; + } + + return trusted_keys; + } +%} + + +/* ========================================================================= */ +/* Encapsulating Python code. */ +/* ========================================================================= */ %feature("docstring") ldns_struct_resolver "LDNS resolver object. -The ldns_resolver object keeps a list of nameservers and can perform queries. +The :class:`ldns_resolver` object keeps a list of name servers and can perform +queries. **Usage** @@ -86,74 +299,146 @@ The ldns_resolver object keeps a list of nameservers and can perform queries. >>> print pkt.answer() www.nic.cz. 1757 IN A 217.31.205.50 -This simple example instances a resolver in order to resolve www.nic.cz record of A type. -" +This simple example instances a resolver in order to resolve www.nic.cz A type +record." %extend ldns_struct_resolver { - %pythoncode %{ + %pythoncode + %{ def __init__(self): - raise Exception("This class can't be created directly. Please use: new_frm_file(filename), new_frm_fp(file) or new_frm_fp_l(file,line)") + """ + Cannot be created directly from Python. + """ + raise Exception("This class can't be created directly. " + + "Please use: new_frm_file(filename), new_frm_fp(file) " + + "or new_frm_fp_l(file, line)") - __swig_destroy__ = _ldns._ldns_resolver_free + __swig_destroy__ = _ldns._ldns_resolver_deep_free + + # + # LDNS_RESOLVER_CONSTRUCTORS_ + # + + @staticmethod + def new(): + """ + Creates a new resolver object. + + :return: (:class:`ldns_resolver`) New resolver object or None. + + .. note:: + The returned resolver object is unusable unless some + name servers are added. + + **Usage** + >>> resolver = ldns.ldns_resolver.new() + >>> ns_addr = ldns.ldns_rdf.new_frm_str("8.8.8.8", ldns.LDNS_RDF_TYPE_A) + >>> if not ns_addr: raise Exception("Can't create resolver address.") + >>> status = resolver.push_nameserver(ns_addr) + >>> if status != ldns.LDNS_STATUS_OK: raise Exception("Can't push resolver address.") + >>> pkt = resolver.query("www.nic.cz.", ldns.LDNS_RR_TYPE_A, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD) + >>> if (pkt) and (pkt.answer()): + >>> print pkt.answer() + www.nic.cz. 1265 IN A 217.31.205.50 + """ + return _ldns.ldns_resolver_new() - #LDNS_RESOLVER_CONSTRUCTORS_# @staticmethod def new_frm_file(filename = "/etc/resolv.conf", raiseException=True): - """Creates a resolver object from given filename - - :param filename: name of file which contains informations (usually /etc/resolv.conf) - :param raiseException: if True, an exception occurs in case a resolver object can't be created - :returns: resolver object or None. If the object can't be created and raiseException is True, an exception occurs. + """ + Creates a resolver object from given file name + + :param filename: Name of file which contains resolver + informations (usually /etc/resolv.conf). + :type filename: str + :param raiseException: If True, an exception occurs in case a + resolver object can't be created. + :type raiseException: bool + :throws TypeError: When arguments of inappropriate types. + :throws Exception: When `raiseException` set and resolver + couldn't be created. + :return: (:class:`ldns_resolver`) Resolver object or None. + An exception occurs if the object can't be created and + 'raiseException' is True. """ status, resolver = _ldns.ldns_resolver_new_frm_file(filename) if status != LDNS_STATUS_OK: - if (raiseException): raise Exception("Can't create resolver, error: %d" % status) + if (raiseException): + raise Exception("Can't create resolver, error: %d" % status) return None return resolver @staticmethod def new_frm_fp(file, raiseException=True): - """Creates a resolver object from file + """ + Creates a resolver object from file - :param file: a file object - :param raiseException: if True, an exception occurs in case a resolver object can't be created - :returns: resolver object or None. If the object can't be created and raiseException is True, an exception occurs. + :param file: A file object. + :type file: file + :param raiseException: If True, an exception occurs in case a + resolver object can't be created. + :type raiseException: bool + :throws TypeError: When arguments of inappropriate types. + :throws Exception: When `raiseException` set and resolver + couldn't be created. + :return: (:class:`ldns_resolver`) Resolver object or None. + An exception occurs if the object can't be created and + `raiseException` is True. """ status, resolver = _ldns.ldns_resolver_new_frm_fp(file) if status != LDNS_STATUS_OK: - if (raiseException): raise Exception("Can't create resolver, error: %d" % status) + if (raiseException): + raise Exception("Can't create resolver, error: %d" % status) return None return resolver @staticmethod def new_frm_fp_l(file, raiseException=True): - """Creates a resolver object from file + """ + Creates a resolver object from file - :param file: a file object - :param raiseException: if True, an exception occurs in case a resolver instance can't be created - :returns: - * resolver - resolver instance or None. If an instance can't be created and raiseException is True, an exception occurs. + :param file: A file object. + :type file: file + :param raiseException: If True, an exception occurs in case a + resolver instance can't be created. + :type raiseException: bool + :throws TypeError: When arguments of inappropriate types. + :throws Exception: When `raiseException` set and resolver + couldn't be created. + :return: + * (:class:`ldns_resolver`) Resolver instance or None. + An exception occurs if an instance can't be created and + `raiseException` is True. - * line - the line number (for debugging) + * (int) - The line number. (e.g., for debugging) """ status, resolver, line = _ldns.ldns_resolver_new_frm_fp_l(file) if status != LDNS_STATUS_OK: - if (raiseException): raise Exception("Can't create resolver, error: %d" % status) + if (raiseException): + raise Exception("Can't create resolver, error: %d" % status) return None return resolver, line - #_LDNS_RESOLVER_CONSTRUCTORS# + # + # _LDNS_RESOLVER_CONSTRUCTORS + # # High level functions - def get_addr_by_name(self, name, aclass = _ldns.LDNS_RR_CLASS_IN, flags = _ldns.LDNS_RD): - """Ask the resolver about name and return all address records - :param name: (ldns_rdf) the name to look for - :param aclass: the class to use - :param flags: give some optional flags to the query + def get_addr_by_name(self, name, aclass = _ldns.LDNS_RR_CLASS_IN, flags = _ldns.LDNS_RD): + """ + Ask the resolver about name and return all address records. - :returns: RR List object or None + :param name: The name to look for. String is automatically + converrted to dname. + :type name: :class:`ldns_dname` or str + :param aclass: The class to use. + :type aclass: ldns_rr_class + :param flags: Give some optional flags to the query. + :type flags: uint16_t + :throws TypeError: When arguments of inappropriate types. + :return: (:class:`ldns_rr_list`) RR List object or None. **Usage** >>> addr = resolver.get_addr_by_name("www.google.com", ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD) @@ -164,7 +449,6 @@ This simple example instances a resolver in order to resolve www.nic.cz record o www.l.google.com. 300 IN A 74.125.43.103 www.l.google.com. 300 IN A 74.125.43.104 www.l.google.com. 300 IN A 74.125.43.147 - """ rdf = name if isinstance(name, str): @@ -172,13 +456,19 @@ This simple example instances a resolver in order to resolve www.nic.cz record o return _ldns.ldns_get_rr_list_addr_by_name(self, rdf, aclass, flags) def get_name_by_addr(self, addr, aclass = _ldns.LDNS_RR_CLASS_IN, flags = _ldns.LDNS_RD): - """Ask the resolver about the address and return the name - - :param name: (ldns_rdf of A or AAAA type) the addr to look for. If a string is given, A or AAAA type is identified automatically - :param aclass: the class to use - :param flags: give some optional flags to the query + """ + Ask the resolver about the address and return the name. - :returns: RR List object or None + :param name: (ldns_rdf of A or AAAA type) the addr to look for. + If a string is given, A or AAAA type is identified + automatically. + :type name: :class:`ldns_rdf` of A or AAAA type + :param aclass: The class to use. + :type aclass: ldns_rr_class + :param flags: Give some optional flags to the query. + :type flags: uint16_t + :throws TypeError: When arguments of inappropriate types. + :return: (:class:`ldns_rr_list`) RR List object or None. **Usage** >>> addr = resolver.get_name_by_addr("74.125.43.99", ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD) @@ -191,23 +481,70 @@ This simple example instances a resolver in order to resolve www.nic.cz record o rdf = addr if isinstance(addr, str): if (addr.find("::") >= 0): #IPv6 - rdf = _ldns.ldns_rdf_new_frm_str(_ldns.LDNS_RDF_TYPE_AAAA, addr) + rdf = _ldns.ldns_rdf_new_frm_str(_ldns.LDNS_RDF_TYPE_AAAA, addr) else: - rdf = _ldns.ldns_rdf_new_frm_str(_ldns.LDNS_RDF_TYPE_A, addr) + rdf = _ldns.ldns_rdf_new_frm_str(_ldns.LDNS_RDF_TYPE_A, addr) return _ldns.ldns_get_rr_list_name_by_addr(self, rdf, aclass, flags) def print_to_file(self,output): - """Print a resolver (in sofar that is possible) state to output.""" + """Print a resolver (in so far that is possible) state to output.""" _ldns.ldns_resolver_print(output,self) + def axfr_complete(self): + """ + Returns True if the axfr transfer has completed + (i.e., 2 SOA RRs and no errors were encountered). + + :return: (bool) + """ + return _ldns.ldns_axfr_complete(self) + #parameters: const ldns_resolver *, + #retvals: bool + + def axfr_last_pkt(self): + """ + Returns a last packet that was sent by the server in the AXFR + transfer (usable for instance to get the error code on failure). + + :return: (:class:`ldns_pkt`) Last packet of the AXFR transfer. + """ + return _ldns._ldns_axfr_last_pkt(self) + #parameters: const ldns_resolver *, + #retvals: ldns_pkt * + + def axfr_next(self): + """ + Get the next stream of RRs in a AXFR. + + :return: (:class:`ldns_rr`) The next RR from the AXFR stream. + """ + return _ldns.ldns_axfr_next(self) + #parameters: ldns_resolver *, + #retvals: ldns_rr * + def axfr_start(self, domain, aclass): - """Prepares the resolver for an axfr query. The query is sent and the answers can be read with axfr_next + """ + Prepares the resolver for an axfr query. The query is sent and + the answers can be read with :meth:`axfr_next`. + + :param domain: Domain to axfr. + :type domain: :class:`dlsn_dname` + :param aclass: The class to use. + :type aclass: ldns_rr_class + :throws TypeError: When arguments of inappropriate types. + :return: (ldns_status) The status of the transfer. + + .. note:: + The type checking of parameter `domain` is benevolent. + It allows also to pass a dname :class:`ldns_rdf` object. + This will probably change in future. **Usage** :: status = resolver.axfr_start("nic.cz", ldns.LDNS_RR_CLASS_IN) - if (status != ldns.LDNS_STATUS_OK): raise Exception("Can't start AXFR, error: %s" % ldns.ldns_get_errorstr_by_id(status)) + if (status != ldns.LDNS_STATUS_OK): + raise Exception("Can't start AXFR, error: %s" % ldns.ldns_get_errorstr_by_id(status)) #Print the results while True: rr = resolver.axfr_next() @@ -215,8 +552,8 @@ This simple example instances a resolver in order to resolve www.nic.cz record o break print rr - """ + # TODO -- Add checking for ldns_rdf and ldns_dname. rdf = domain if isinstance(domain, str): rdf = _ldns.ldns_dname_new_frm_str(domain) @@ -224,723 +561,894 @@ This simple example instances a resolver in order to resolve www.nic.cz record o #parameters: ldns_resolver *resolver, ldns_rdf *domain, ldns_rr_class c #retvals: int - def axfr_complete(self): - """returns true if the axfr transfer has completed (i.e. 2 SOA RRs and no errors were encountered)""" - return _ldns.ldns_axfr_complete(self) - #parameters: const ldns_resolver *, - #retvals: bool + # + # LDNS_RESOLVER_METHODS_ + # - def axfr_last_pkt(self): - """returns a pointer to the last ldns_pkt that was sent by the server in the AXFR transfer uasable for instance to get the error code on failure""" - return _ldns.ldns_axfr_last_pkt(self) - #parameters: const ldns_resolver *, - #retvals: ldns_pkt * - - def axfr_next(self): - """get the next stream of RRs in a AXFR""" - return _ldns.ldns_axfr_next(self) - #parameters: ldns_resolver *, - #retvals: ldns_rr * - - #LDNS_RESOLVER_METHODS_# def debug(self): - """Get the debug status of the resolver. + """ + Get the debug status of the resolver. - :returns: (bool) true if so, otherwise false + :return: (bool) True if so, otherwise False. """ return _ldns.ldns_resolver_debug(self) #parameters: const ldns_resolver *, #retvals: bool def dec_nameserver_count(self): - """Decrement the resolver's nameserver count. + """ + Decrement the resolver's name server count. """ _ldns.ldns_resolver_dec_nameserver_count(self) #parameters: ldns_resolver *, #retvals: def defnames(self): + """ + Does the resolver apply default domain name. + + :return: (bool) + """ return _ldns.ldns_resolver_defnames(self) #parameters: const ldns_resolver *, #retvals: bool def dnsrch(self): + """ + Does the resolver apply search list. + + :return: (bool) + """ return _ldns.ldns_resolver_dnsrch(self) #parameters: const ldns_resolver *, #retvals: bool def dnssec(self): - """Does the resolver do DNSSEC. + """ + Does the resolver do DNSSEC. - :returns: (bool) true: yes, false: no + :return: (bool) True: yes, False: no. """ return _ldns.ldns_resolver_dnssec(self) #parameters: const ldns_resolver *, #retvals: bool def dnssec_anchors(self): - """Get the resolver's DNSSEC anchors. + """ + Get the resolver's DNSSEC anchors. - :returns: (ldns_rr_list \*) an rr_list containg trusted DNSSEC anchors + :return: (:class:`ldns_rr_list`) An rr list containing trusted + DNSSEC anchors. """ - return _ldns.ldns_resolver_dnssec_anchors(self) + return _ldns._ldns_resolver_dnssec_anchors(self) #parameters: const ldns_resolver *, #retvals: ldns_rr_list * def dnssec_cd(self): - """Does the resolver set the CD bit. + """ + Does the resolver set the CD bit. - :returns: (bool) true: yes, false: no + :return: (bool) True: yes, False: no. """ return _ldns.ldns_resolver_dnssec_cd(self) #parameters: const ldns_resolver *, #retvals: bool def domain(self): - """What is the default dname to add to relative queries. + """ + What is the default dname to add to relative queries. - :returns: (ldns_rdf \*) the dname which is added + :return: (:class:`ldns_dname`) The dname which is added. """ - return _ldns.ldns_resolver_domain(self) + dname = _ldns._ldns_resolver_domain(self) + if dname != None: + return ldns_dname(_ldns._ldns_resolver_domain(self), clone=False) + else: + return dname #parameters: const ldns_resolver *, #retvals: ldns_rdf * def edns_udp_size(self): - """Get the resolver's udp size. + """ + Get the resolver's udp size. - :returns: (uint16_t) the udp mesg size + :return: (uint16_t) The udp mesg size. """ return _ldns.ldns_resolver_edns_udp_size(self) #parameters: const ldns_resolver *, #retvals: uint16_t def fail(self): - """Does the resolver only try the first nameserver. + """ + Does the resolver only try the first name server. - :returns: (bool) true: yes, fail, false: no, try the others + :return: (bool) True: yes, fail, False: no, try the others. """ return _ldns.ldns_resolver_fail(self) #parameters: const ldns_resolver *, #retvals: bool def fallback(self): - """Get the truncation fallback status. + """ + Get the truncation fall-back status. - :returns: (bool) whether the truncation fallback mechanism is used + :return: (bool) Whether the truncation fall*back mechanism + is used. """ return _ldns.ldns_resolver_fallback(self) #parameters: const ldns_resolver *, #retvals: bool def igntc(self): - """Does the resolver ignore the TC bit (truncated). + """ + Does the resolver ignore the TC bit (truncated). - :returns: (bool) true: yes, false: no + :return: (bool) True: yes, False: no. """ return _ldns.ldns_resolver_igntc(self) #parameters: const ldns_resolver *, #retvals: bool def incr_nameserver_count(self): - """Incremental the resolver's nameserver count. + """ + Increment the resolver's name server count. """ _ldns.ldns_resolver_incr_nameserver_count(self) #parameters: ldns_resolver *, #retvals: def ip6(self): - """Does the resolver use ip6 or ip4. + """ + Does the resolver use ip6 or ip4. - :returns: (uint8_t) 0: both, 1: ip4, 2:ip6 + :return: (uint8_t) 0: both, 1: ip4, 2:ip6 """ return _ldns.ldns_resolver_ip6(self) #parameters: const ldns_resolver *, #retvals: uint8_t def nameserver_count(self): - """How many nameserver are configured in the resolver. + """ + How many name server are configured in the resolver. - :returns: (size_t) number of nameservers + :return: (size_t) Number of name servers. """ return _ldns.ldns_resolver_nameserver_count(self) #parameters: const ldns_resolver *, #retvals: size_t - def nameserver_rtt(self,pos): - """Return the used round trip time for a specific nameserver. + def nameserver_rtt(self, pos): + """ + Return the used round trip time for a specific name server. - :param pos: - the index to the nameserver - :returns: (size_t) the rrt, 0: infinite, >0: undefined (as of * yet) + :param pos: The index to the name server. + :type pos: size_t + :throws TypeError: When arguments of inappropriate types. + :return: (size_t) The rrt, 0: infinite, + >0: undefined (as of * yet). """ - return _ldns.ldns_resolver_nameserver_rtt(self,pos) + return _ldns.ldns_resolver_nameserver_rtt(self, pos) #parameters: const ldns_resolver *,size_t, #retvals: size_t def nameservers(self): - """Return the configured nameserver ip address. + """ + Return the configured name server ip address. - :returns: (ldns_rdf \*\*) a ldns_rdf pointer to a list of the addresses + :return: (ldns_rdf \*\*) A ldns_rdf pointer to a list of the + addresses. """ + # TODO -- Convert to list of ldns_rdf. return _ldns.ldns_resolver_nameservers(self) #parameters: const ldns_resolver *, #retvals: ldns_rdf ** def nameservers_randomize(self): - """randomize the nameserver list in the resolver + """ + Randomize the name server list in the resolver. """ _ldns.ldns_resolver_nameservers_randomize(self) #parameters: ldns_resolver *, #retvals: def pop_nameserver(self): - """pop the last nameserver from the resolver. + """ + Pop the last name server from the resolver. - :returns: (ldns_rdf \*) the popped address or NULL if empty + :return: (:class:`ldns_rdf`) The popped address or None if empty. """ return _ldns.ldns_resolver_pop_nameserver(self) #parameters: ldns_resolver *, #retvals: ldns_rdf * def port(self): - """Get the port the resolver should use. + """ + Get the port the resolver should use. - :returns: (uint16_t) the port number + :return: (uint16_t) The port number. """ return _ldns.ldns_resolver_port(self) #parameters: const ldns_resolver *, #retvals: uint16_t - def prepare_query_pkt(self,name,t,c,f): - """Form a query packet from a resolver and name/type/class combo. - - :param name: - :param t: - query for this type (may be 0, defaults to A) - :param c: - query for this class (may be 0, default to IN) - :param f: - the query flags - :returns: * (ldns_status) ldns_pkt* a packet with the reply from the nameserver - * (ldns_pkt \*\*) query packet class + def prepare_query_pkt(self, name, t, c, f, raiseException=True): + """ + Form a query packet from a resolver and name/type/class combo. + + :param name: Query for this name. + :type name: :class:`ldns_dname` or str + :param t: Query for this type (may be 0, defaults to A). + :type t: ldns_rr_type + :param c: Query for this class (may be 0, default to IN). + :type c: ldns_rr_class + :param f: The query flags. + :type f: uint16_t + :throws TypeError: When arguments of inappropriate types. + :throws Exception: When `raiseException` set and answer + couldn't be resolved. + :return: (:class:`ldns_pkt`) Query packet or None. + An exception occurs if the object can't be created and + 'raiseException' is True. """ - return _ldns.ldns_resolver_prepare_query_pkt(self,name,t,c,f) + rdf = name + if isinstance(name, str): + rdf = _ldns.ldns_dname_new_frm_str(name) + status, pkt = _ldns.ldns_resolver_prepare_query_pkt(self, rdf, t, c, f) + if status != LDNS_STATUS_OK: + if (raiseException): + raise Exception("Can't create resolver, error: %d" % status) + return None + return pkt #parameters: ldns_resolver *,const ldns_rdf *,ldns_rr_type,ldns_rr_class,uint16_t, #retvals: ldns_status,ldns_pkt ** - def push_dnssec_anchor(self,rr): - """Push a new trust anchor to the resolver. - - It must be a DS or DNSKEY rr + def push_dnssec_anchor(self, rr): + """ + Push a new trust anchor to the resolver. + It must be a DS or DNSKEY rr. - :param rr: - the RR to add as a trust anchor. - :returns: (ldns_status) a status + :param rr: The RR to add as a trust anchor. + :type rr: DS of DNSKEY :class:`ldns_rr` + :throws TypeError: When arguments of inappropriate types. + :return: (ldns_status) A status. """ - return _ldns.ldns_resolver_push_dnssec_anchor(self,rr) + return _ldns.ldns_resolver_push_dnssec_anchor(self, rr) #parameters: ldns_resolver *,ldns_rr *, #retvals: ldns_status - def push_nameserver(self,n): - """push a new nameserver to the resolver. - + def push_nameserver(self, n): + """ + Push a new name server to the resolver. It must be an IP address v4 or v6. - :param n: - the ip address - :returns: (ldns_status) ldns_status a status + :param n: The ip address. + :type n: :class:`ldns_rdf` of A or AAAA type. + :throws TypeError: When arguments of inappropriate types. + :return: (ldns_status) A status. """ - return _ldns.ldns_resolver_push_nameserver(self,n) + return _ldns.ldns_resolver_push_nameserver(self, n) #parameters: ldns_resolver *,ldns_rdf *, #retvals: ldns_status - def push_nameserver_rr(self,rr): - """push a new nameserver to the resolver. - - It must be an A or AAAA RR record type + def push_nameserver_rr(self, rr): + """ + Push a new name server to the resolver. + It must be an A or AAAA RR record type. - :param rr: - the resource record - :returns: (ldns_status) ldns_status a status + :param rr: The resource record. + :type rr: :class:`ldns_rr` of A or AAAA type. + :throws TypeError: When arguments of inappropriate types. + :return: (ldns_status) A status. """ - return _ldns.ldns_resolver_push_nameserver_rr(self,rr) + return _ldns.ldns_resolver_push_nameserver_rr(self, rr) #parameters: ldns_resolver *,ldns_rr *, #retvals: ldns_status - def push_nameserver_rr_list(self,rrlist): - """push a new nameserver rr_list to the resolver. + def push_nameserver_rr_list(self, rrlist): + """ + Push a new name server rr_list to the resolver. - :param rrlist: - the rr_list to push - :returns: (ldns_status) ldns_status a status + :param rrlist: The rr list to push. + :type rrlist: :class:`ldns_rr_list` + :throws TypeError: When arguments of inappropriate types. + :return: (ldns_status) A status. """ - return _ldns.ldns_resolver_push_nameserver_rr_list(self,rrlist) + return _ldns.ldns_resolver_push_nameserver_rr_list(self, rrlist) #parameters: ldns_resolver *,ldns_rr_list *, #retvals: ldns_status - def push_searchlist(self,rd): - """Push a new rd to the resolver's searchlist. + def push_searchlist(self, rd): + """ + Push a new rd to the resolver's search-list. - :param rd: - to push + :param rd: To push. + :param rd: :class:`ldns_dname` or str + :throws TypeError: When arguments of inappropriate types. + + .. note: + The function does not return any return status, + so the caller must ensure the correctness of the passed + values. """ - _ldns.ldns_resolver_push_searchlist(self,rd) + rdf = rd + if isinstance(rd, str): + rdf = _ldns.ldns_dname_new_frm_str(rd) + _ldns.ldns_resolver_push_searchlist(self, rdf) #parameters: ldns_resolver *,ldns_rdf *, #retvals: def query(self,name,atype=_ldns.LDNS_RR_TYPE_A,aclass=_ldns.LDNS_RR_CLASS_IN,flags=_ldns.LDNS_RD): - """Send a query to a nameserver. - - :param name: (ldns_rdf) the name to look for - :param atype: the RR type to use - :param aclass: the RR class to use - :param flags: give some optional flags to the query - :returns: (ldns_pkt) a packet with the reply from the nameserver if _defnames is true the default domain will be added """ - return _ldns.ldns_resolver_query(self,name,atype,aclass,flags) + Send a query to a name server. + + :param name: The name to look for. + :type name: :class:`ldns_dname` or str + :param atype: The RR type to use. + :type atype: ldns_rr_type + :param aclass: The RR class to use. + :type aclass: ldns_rr_class + :param flags: Give some optional flags to the query. + :type flags: uint16_t + :throws TypeError: When arguments of inappropriate types. + :return: (:class:`ldns_pkt`) A packet with the reply from the + name server if _defnames is true the default domain will + be added. + """ + # Explicit conversion from string to ldns_rdf prevents memory leaks. + # TODO -- Find out why. + dname = name + if isinstance(name, str): + dname = _ldns.ldns_dname_new_frm_str(name) + return _ldns.ldns_resolver_query(self, dname, atype, aclass, flags) #parameters: const ldns_resolver *,const ldns_rdf *,ldns_rr_type,ldns_rr_class,uint16_t, #retvals: ldns_pkt * def random(self): - """Does the resolver randomize the nameserver before usage. + """ + Does the resolver randomize the name server before usage? - :returns: (bool) true: yes, false: no + :return: (bool) True: yes, False: no. """ return _ldns.ldns_resolver_random(self) #parameters: const ldns_resolver *, #retvals: bool def recursive(self): - """Is the resolver set to recurse. + """ + Is the resolver set to recurse? - :returns: (bool) true if so, otherwise false + :return: (bool) True if so, otherwise False. """ return _ldns.ldns_resolver_recursive(self) #parameters: const ldns_resolver *, #retvals: bool def retrans(self): - """Get the retransmit interval. + """ + Get the retransmit interval. - :returns: (uint8_t) the retransmit interval + :return: (uint8_t) The retransmit interval. """ return _ldns.ldns_resolver_retrans(self) #parameters: const ldns_resolver *, #retvals: uint8_t def retry(self): - """Get the number of retries. + """ + Get the number of retries. - :returns: (uint8_t) the number of retries + :return: (uint8_t) The number of retries. """ return _ldns.ldns_resolver_retry(self) #parameters: const ldns_resolver *, #retvals: uint8_t def rtt(self): - """Return the used round trip times for the nameservers. + """ + Return the used round trip times for the name servers. - :returns: (size_t \*) a size_t* pointer to the list. yet) + :return: (size_t \*) a size_t* pointer to the list. yet) """ return _ldns.ldns_resolver_rtt(self) #parameters: const ldns_resolver *, #retvals: size_t * - def search(self,rdf,t,c,flags): - """Send the query for using the resolver and take the search list into account The search algorithm is as follows: If the name is absolute, try it as-is, otherwise apply the search list. - - :param rdf: - :param t: - query for this type (may be 0, defaults to A) - :param c: - query for this class (may be 0, default to IN) - :param flags: - the query flags - :returns: (ldns_pkt \*) ldns_pkt* a packet with the reply from the nameserver - """ - return _ldns.ldns_resolver_search(self,rdf,t,c,flags) + def search(self, name, atype=_ldns.LDNS_RR_TYPE_A, aclass=_ldns.LDNS_RR_CLASS_IN, flags=_ldns.LDNS_RD): + """ + Send the query for using the resolver and take the search list + into account The search algorithm is as follows: If the name is + absolute, try it as-is, otherwise apply the search list. + + :param name: The name to look for. + :type name: :class:`ldns_dname` or str + :param atype: The RR type to use. + :type atype: ldns_rr_type + :param aclass: The RR class to use. + :type aclass: ldns_rr_class + :param flags: Give some optional flags to the query. + :type flags: uint16_t + :throws TypeError: When arguments of inappropriate types. + :return: (:class:`ldns_pkt`) A packet with the reply from the + name server. + """ + # Explicit conversion from string to ldns_rdf prevents memory leaks. + # TODO -- Find out why. + dname = name + if isinstance(name, str): + dname = _ldns.ldns_dname_new_frm_str(name) + return _ldns.ldns_resolver_search(self, dname, atype, aclass, flags) #parameters: const ldns_resolver *,const ldns_rdf *,ldns_rr_type,ldns_rr_class,uint16_t, #retvals: ldns_pkt * def searchlist(self): - """What is the searchlist as used by the resolver. + """ + What is the search-list as used by the resolver. - :returns: (ldns_rdf \*\*) a ldns_rdf pointer to a list of the addresses + :return: (ldns_rdf \*\*) A ldns_rdf pointer to a list of the addresses. """ return _ldns.ldns_resolver_searchlist(self) #parameters: const ldns_resolver *, #retvals: ldns_rdf \*\* def searchlist_count(self): - """Return the resolver's searchlist count. + """ + Return the resolver's search-list count. - :returns: (size_t) the searchlist count + :return: (size_t) The search-list count. """ return _ldns.ldns_resolver_searchlist_count(self) #parameters: const ldns_resolver *, #retvals: size_t - def send(self,name,t,c,flags): - """Send the query for name as-is. - - :param name: - :param t: - query for this type (may be 0, defaults to A) - :param c: - query for this class (may be 0, default to IN) - :param flags: - the query flags - :returns: * (ldns_status) ldns_pkt* a packet with the reply from the nameserver - * (ldns_pkt \*\*) - """ - return _ldns.ldns_resolver_send(self,name,t,c,flags) + def send(self, name, atype, aclass, flags, raiseException=True): + """ + Send the query for name as-is. + + :param name: The name to look for. + :type name: :class:`ldns_dname` or str + :param atype: The RR type to use. + :type atype: ldns_rr_type + :param aclass: The RR class to use. + :type aclass: ldns_rr_class + :param flags: Give some optional flags to the query. + :type flags: uint16_t + :throws TypeError: When arguments of inappropriate types. + :throws Exception: When `raiseException` set and answer + couldn't be resolved. + :return: (:class:`ldns_pkt`) A packet with the reply from the + name server. + """ + # Explicit conversion from string to ldns_rdf prevents memory leaks. + # TODO -- Find out why. + dname = name + if isinstance(name, str): + dname = _ldns.ldns_dname_new_frm_str(name) + status, pkt = _ldns.ldns_resolver_send(self, dname, atype, aclass, flags) + if status != LDNS_STATUS_OK: + if (raiseException): + raise Exception("Can't create resolver, error: %d" % status) + return None + return pkt #parameters: ldns_resolver *,const ldns_rdf *,ldns_rr_type,ldns_rr_class,uint16_t, #retvals: ldns_status,ldns_pkt ** - def send_pkt(self,query_pkt): - """Send the given packet to a nameserver. + def send_pkt(self, query_pkt): + """ + Send the given packet to a name server. - :param query_pkt: - :returns: * (ldns_status) - * (ldns_pkt \*\*) + :param query_pkt: Query packet. + :type query_pkt: :class:`ldns_pkt` + :throws TypeError: When arguments of inappropriate types. + :return: * (ldns_status) Return status. + * (:class:`ldns_pkt`) Response packet if returns status ok. """ + status, answer = _ldns.ldns_resolver_send_pkt(self, query_pkt) return _ldns.ldns_resolver_send_pkt(self,query_pkt) #parameters: ldns_resolver *,ldns_pkt *, #retvals: ldns_status,ldns_pkt ** - def set_debug(self,b): - """Set the resolver debugging. + def set_debug(self, b): + """ + Set the resolver debugging. - :param b: - true: debug on: false debug off + :param b: True: debug on, False: debug off. + :type b: bool """ - _ldns.ldns_resolver_set_debug(self,b) + _ldns.ldns_resolver_set_debug(self, b) #parameters: ldns_resolver *,bool, #retvals: - def set_defnames(self,b): - """Whether the resolver uses the name set with _set_domain. + def set_defnames(self, b): + """ + Whether the resolver uses the name set with _set_domain. - :param b: - true: use the defaults, false: don't use them + :param b: True: use the defaults, False: don't use them. + :type b: bool """ - _ldns.ldns_resolver_set_defnames(self,b) + _ldns.ldns_resolver_set_defnames(self, b) #parameters: ldns_resolver *,bool, #retvals: - def set_dnsrch(self,b): - """Whether the resolver uses the searchlist. + def set_dnsrch(self, b): + """ + Whether the resolver uses the search list. - :param b: - true: use the list, false: don't use the list + :param b: True: use the list, False: don't use the list. + :type b: bool """ - _ldns.ldns_resolver_set_dnsrch(self,b) + _ldns.ldns_resolver_set_dnsrch(self, b) #parameters: ldns_resolver *,bool, #retvals: - def set_dnssec(self,b): - """Whether the resolver uses DNSSEC. + def set_dnssec(self, b): + """ + Whether the resolver uses DNSSEC. - :param b: - true: use DNSSEC, false: don't use DNSSEC + :param b: True: use DNSSEC, False: don't use DNSSEC. + :type b: bool """ - _ldns.ldns_resolver_set_dnssec(self,b) + _ldns.ldns_resolver_set_dnssec(self, b) #parameters: ldns_resolver *,bool, #retvals: - def set_dnssec_anchors(self,l): - """Set the resolver's DNSSEC anchor list directly. - + def set_dnssec_anchors(self, l): + """ + Set the resolver's DNSSEC anchor list directly. RRs should be of type DS or DNSKEY. - :param l: - the list of RRs to use as trust anchors + :param l: The list of RRs to use as trust anchors. + :type l: :class:`ldns_rr_list` + :throws TypeError: When arguments of inappropriate types. """ - _ldns.ldns_resolver_set_dnssec_anchors(self,l) + _ldns._ldns_resolver_set_dnssec_anchors(self, l) #parameters: ldns_resolver *,ldns_rr_list *, #retvals: - def set_dnssec_cd(self,b): - """Whether the resolver uses the checking disable bit. + def set_dnssec_cd(self, b): + """ + Whether the resolver uses the checking disable bit. - :param b: - true: enable , false: don't use TCP + :param b: True: enable, False: disable. + :type b: bool """ - _ldns.ldns_resolver_set_dnssec_cd(self,b) + _ldns.ldns_resolver_set_dnssec_cd(self, b) #parameters: ldns_resolver *,bool, #retvals: - def set_domain(self,rd): - """Set the resolver's default domain. - - This gets appended when no absolute name is given - - :param rd: - the name to append - """ - _ldns.ldns_resolver_set_domain(self,rd) + def set_domain(self, rd): + """ + Set the resolver's default domain. + This gets appended when no absolute name is given. + + :param rd: The name to append. + :type rd: :class:`ldns_dname` or str + :throws TypeError: When arguments of inappropriate types. + :throws Exception: When `rd` a non dname rdf. + + .. note:: + The type checking of parameter `rd` is benevolent. + It allows also to pass a dname :class:`ldns_rdf` object. + This will probably change in future. + """ + # Also has to be able to pass None or dame string. + if isinstance(rd, str): + dname = _ldns.ldns_dname_new_frm_str(rd) + elif (not isinstance(rd, ldns_dname)) and \ + isinstance(rd, ldns_rdf) and \ + rd.get_type() == _ldns.LDNS_RDF_TYPE_DNAME: + warnings.warn("The ldns_resolver.set_domain() method" + + " will drop the possibility to accept ldns_rdf." + + " Convert argument to ldns_dname.", + PendingDeprecationWarning, stacklevel=2) + dname = rd + else: + dname = rd + if (not isinstance(dname, ldns_rdf)) and (dname != None): + raise TypeError("Parameter must be derived from ldns_rdf.") + if (isinstance(dname, ldns_rdf)) and \ + (dname.get_type() != _ldns.LDNS_RDF_TYPE_DNAME): + raise Exception("Operands must be ldns_dname.") + _ldns._ldns_resolver_set_domain(self, dname) #parameters: ldns_resolver *,ldns_rdf *, #retvals: - def set_edns_udp_size(self,s): - """Set maximum udp size. + def set_edns_udp_size(self, s): + """ + Set maximum udp size. - :param s: - the udp max size + :param s: The udp max size. + :type s: uint16_t + :throws TypeError: When arguments of inappropriate types. """ _ldns.ldns_resolver_set_edns_udp_size(self,s) #parameters: ldns_resolver *,uint16_t, #retvals: - def set_fail(self,b): - """Whether or not to fail after one failed query. + def set_fail(self, b): + """ + Whether or not to fail after one failed query. - :param b: - true: yes fail, false: continue with next nameserver + :param b: True: yes fail, False: continue with next name server. + :type b: bool """ - _ldns.ldns_resolver_set_fail(self,b) + _ldns.ldns_resolver_set_fail(self, b) #parameters: ldns_resolver *,bool, #retvals: - def set_fallback(self,fallback): - """Set whether the resolvers truncation fallback mechanism is used when ldns_resolver_query() is called. + def set_fallback(self, fallback): + """ + Set whether the resolvers truncation fall-back mechanism is used + when :meth:`query` is called. - :param fallback: - whether to use the fallback mechanism + :param fallback: Whether to use the fall-back mechanism. + :type fallback: bool """ - _ldns.ldns_resolver_set_fallback(self,fallback) + _ldns.ldns_resolver_set_fallback(self, fallback) #parameters: ldns_resolver *,bool, #retvals: - def set_igntc(self,b): - """Whether or not to ignore the TC bit. + def set_igntc(self, b): + """ + Whether or not to ignore the TC bit. - :param b: - true: yes ignore, false: don't ignore + :param b: True: yes ignore, False: don't ignore. + :type b: bool """ - _ldns.ldns_resolver_set_igntc(self,b) + _ldns.ldns_resolver_set_igntc(self, b) #parameters: ldns_resolver *,bool, #retvals: - def set_ip6(self,i): - """Whether the resolver uses ip6. + def set_ip6(self, i): + """ + Whether the resolver uses ip6. - :param i: - 0: no pref, 1: ip4, 2: ip6 + :param i: 0: no pref, 1: ip4, 2: ip6 + :type i: uint8_t + :throws TypeError: When arguments of inappropriate types. """ - _ldns.ldns_resolver_set_ip6(self,i) + _ldns.ldns_resolver_set_ip6(self, i) #parameters: ldns_resolver *,uint8_t, #retvals: - def set_nameserver_count(self,c): - """Set the resolver's nameserver count directly. + def set_nameserver_count(self, c): + """ + Set the resolver's name server count directly. - :param c: - the nameserver count + :param c: The name server count. + :type c: size_t + :throws TypeError: When arguments of inappropriate types. """ - _ldns.ldns_resolver_set_nameserver_count(self,c) + _ldns.ldns_resolver_set_nameserver_count(self, c) #parameters: ldns_resolver *,size_t, #retvals: - def set_nameserver_rtt(self,pos,value): - """Set round trip time for a specific nameserver. - - Note this currently differentiates between: unreachable and reachable. + def set_nameserver_rtt(self, pos, value): + """ + Set round trip time for a specific name server. + Note this currently differentiates between: unreachable and + reachable. - :param pos: - the nameserver position - :param value: - the rtt + :param pos: The name server position. + :type pos: size_t + :param value: The rtt. + :type value: size_t + :throws TypeError: When arguments of inappropriate types. """ - _ldns.ldns_resolver_set_nameserver_rtt(self,pos,value) + _ldns.ldns_resolver_set_nameserver_rtt(self, pos, value) #parameters: ldns_resolver *,size_t,size_t, #retvals: - def set_nameservers(self,rd): - """Set the resolver's nameserver count directly by using an rdf list. + def set_nameservers(self, rd): + """ + Set the resolver's name server count directly by using an + rdf list. - :param rd: - the resolver addresses + :param rd: The resolver addresses. + :type rd: ldns_rdf \*\* + :throws TypeError: When arguments of inappropriate types. """ - _ldns.ldns_resolver_set_nameservers(self,rd) + _ldns.ldns_resolver_set_nameservers(self, rd) #parameters: ldns_resolver *,ldns_rdf **, #retvals: - def set_port(self,p): - """Set the port the resolver should use. + def set_port(self, p): + """ + Set the port the resolver should use. - :param p: - the port number + :param p: The port number. + :type p: uint16_t + :throws TypeError: When arguments of inappropriate types. """ - _ldns.ldns_resolver_set_port(self,p) + _ldns.ldns_resolver_set_port(self, p) #parameters: ldns_resolver *,uint16_t, #retvals: - def set_random(self,b): - """Should the nameserver list be randomized before each use. + def set_random(self, b): + """ + Should the name server list be randomized before each use. - :param b: - true: randomize, false: don't + :param b: True: randomize, False: don't. + :type b: bool """ - _ldns.ldns_resolver_set_random(self,b) + _ldns.ldns_resolver_set_random(self, b) #parameters: ldns_resolver *,bool, #retvals: - def set_recursive(self,b): - """Set the resolver recursion. + def set_recursive(self, b): + """ + Set the resolver recursion. - :param b: - true: set to recurse, false: unset + :param b: True: set to recurse, False: unset. + :type b: bool """ - _ldns.ldns_resolver_set_recursive(self,b) + _ldns.ldns_resolver_set_recursive(self, b) #parameters: ldns_resolver *,bool, #retvals: - def set_retrans(self,re): - """Set the resolver retrans timeout (in seconds). + def set_retrans(self, re): + """ + Set the resolver retrans time-out (in seconds). - :param re: - the retransmission interval in seconds + :param re: The retransmission interval in seconds. + :type re: uint8_t + :throws TypeError: When arguments of inappropriate types. """ - _ldns.ldns_resolver_set_retrans(self,re) + _ldns.ldns_resolver_set_retrans(self, re) #parameters: ldns_resolver *,uint8_t, #retvals: - def set_retry(self,re): - """Set the resolver retry interval (in seconds). + def set_retry(self, re): + """ + Set the resolver retry interval (in seconds). - :param re: - the retry interval + :param re: The retry interval. + :type re: uint8_t + :throws TypeError: When arguments of inappropriate types. """ _ldns.ldns_resolver_set_retry(self,re) #parameters: ldns_resolver *,uint8_t, #retvals: - def set_rtt(self,rtt): - """Set round trip time for all nameservers. - + def set_rtt(self, rtt): + """ + Set round trip time for all name servers. Note this currently differentiates between: unreachable and reachable. - :param rtt: - a list with the times + :param rtt: A list with the times. + :type rtt: size \* + :throws TypeError: When arguments of inappropriate types. """ - _ldns.ldns_resolver_set_rtt(self,rtt) + _ldns.ldns_resolver_set_rtt(self, rtt) #parameters: ldns_resolver *,size_t *, #retvals: - def set_searchlist_count(self,c): - _ldns.ldns_resolver_set_searchlist_count(self,c) - #parameters: ldns_resolver *,size_t, - #retvals: - - def set_timeout(self,timeout): - """Set the resolver's socket time out when talking to remote hosts. + def set_timeout(self, timeout): + """ + Set the resolver's socket time out when talking to remote hosts. - :param timeout: - the timeout to use + :param timeout: The time-out to use. + :param timeout: struct timeval + :throws TypeError: When arguments of inappropriate types. """ _ldns.ldns_resolver_set_timeout(self,timeout) #parameters: ldns_resolver *,struct timeval, #retvals: - def set_tsig_algorithm(self,tsig_algorithm): - """Set the tsig algorithm. + def set_tsig_algorithm(self, tsig_algorithm): + """ + Set the tsig algorithm. - :param tsig_algorithm: - the tsig algorithm + :param tsig_algorithm: The tsig algorithm. + :param tsig_algorithm: str + :throws TypeError: When arguments of inappropriate types. """ - _ldns.ldns_resolver_set_tsig_algorithm(self,tsig_algorithm) + _ldns.ldns_resolver_set_tsig_algorithm(self, tsig_algorithm) #parameters: ldns_resolver *,char *, #retvals: - def set_tsig_keydata(self,tsig_keydata): - """Set the tsig key data. + def set_tsig_keydata(self, tsig_keydata): + """ + Set the tsig key data. - :param tsig_keydata: - the key data + :param tsig_keydata: The key data. + :type tsig_keydata: str + :throws TypeError: When arguments of inappropriate types. """ - _ldns.ldns_resolver_set_tsig_keydata(self,tsig_keydata) + _ldns.ldns_resolver_set_tsig_keydata(self, tsig_keydata) #parameters: ldns_resolver *,char *, #retvals: - def set_tsig_keyname(self,tsig_keyname): - """Set the tsig key name. + def set_tsig_keyname(self, tsig_keyname): + """ + Set the tsig key name. - :param tsig_keyname: - the tsig key name + :param tsig_keyname: The tsig key name. + :type tsig_keyname: str + :throws TypeError: When arguments of inappropriate types. """ - _ldns.ldns_resolver_set_tsig_keyname(self,tsig_keyname) + _ldns.ldns_resolver_set_tsig_keyname(self, tsig_keyname) #parameters: ldns_resolver *,char *, #retvals: - def set_usevc(self,b): - """Whether the resolver uses a virtual circuit (TCP). + def set_usevc(self, b): + """ + Whether the resolver uses a virtual circuit (TCP). - :param b: - true: use TCP, false: don't use TCP + :param b: True: use TCP, False: don't use TCP. + :type b: bool """ - _ldns.ldns_resolver_set_usevc(self,b) + _ldns.ldns_resolver_set_usevc(self, b) #parameters: ldns_resolver *,bool, #retvals: def timeout(self): - """What is the timeout on socket connections. + """ + What is the time-out on socket connections. - :returns: (struct timeval) the timeout as struct timeval + :return: (struct timeval) The time-out. """ return _ldns.ldns_resolver_timeout(self) #parameters: const ldns_resolver *, #retvals: struct timeval - def trusted_key(self,keys,trusted_keys): - """Returns true if at least one of the provided keys is a trust anchor. + def trusted_key(self, keys): + """ + Returns true if at least one of the provided keys is a trust + anchor. - :param keys: - the keyset to check - :param trusted_keys: - the subset of trusted keys in the 'keys' rrset - :returns: (bool) true if at least one of the provided keys is a configured trust anchor + :param keys: The key set to check. + :type keys: :class:`ldns_rr_list` + :throws TypeError: When arguments of inappropriate types. + :return: (:class:`ldns_rr_list`) List of trusted keys if at + least one of the provided keys is a configured trust anchor, + None else. """ - return _ldns.ldns_resolver_trusted_key(self,keys,trusted_keys) + return _ldns._replacement_ldns_resolver_trusted_key(self, keys) #parameters: const ldns_resolver *,ldns_rr_list *,ldns_rr_list *, #retvals: bool def tsig_algorithm(self): - """Return the tsig algorithm as used by the nameserver. + """ + Return the tsig algorithm as used by the name server. - :returns: (char \*) the algorithm used. + :return: (str) The algorithm used. """ - return _ldns.ldns_resolver_tsig_algorithm(self) + return _ldns._ldns_resolver_tsig_algorithm(self) #parameters: const ldns_resolver *, #retvals: char * def tsig_keydata(self): - """Return the tsig keydata as used by the nameserver. + """ + Return the tsig key data as used by the name server. - :returns: (char \*) the keydata used. + :return: (str) The key data used. """ - return _ldns.ldns_resolver_tsig_keydata(self) + return _ldns._ldns_resolver_tsig_keydata(self) #parameters: const ldns_resolver *, #retvals: char * def tsig_keyname(self): - """Return the tsig keyname as used by the nameserver. + """ + Return the tsig key name as used by the name server. - :returns: (char \*) the name used. + :return: (str) The name used. """ - return _ldns.ldns_resolver_tsig_keyname(self) + return _ldns._ldns_resolver_tsig_keyname(self) #parameters: const ldns_resolver *, #retvals: char * def usevc(self): - """Does the resolver use tcp or udp. + """ + Does the resolver use tcp or udp. - :returns: (bool) true: tcp, false: udp + :return: (bool) True: tcp, False: udp. """ return _ldns.ldns_resolver_usevc(self) #parameters: const ldns_resolver *, #retvals: bool - #_LDNS_RESOLVER_METHODS# - %} + # + # _LDNS_RESOLVER_METHODS + # + %} } |