CloudHost/zonemaster.es
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix: populate ldns submodule and add autotools to LDNS build stage

Browse Source 
- Re-cloned zonemaster-ldns with --recurse-submodules so the bundled
  ldns C library source (including Changelog and configure.ac) is present
- Added autoconf, automake, libtool to Dockerfile.backend ldns-build stage
  so libtoolize + autoreconf can generate ldns/configure during make

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
This commit is contained in:
Malin
2026-04-21 08:33:38 +02:00
parent 8d4eaa1489
commit eaaa8f6a11
541 changed files with 138189 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

56
zonemaster-ldns/ldns/contrib/python/examples/ldns-axfr.py Executable file
View File

@@ -0,0 +1,56 @@
#!/usr/bin/python
# vim:fileencoding=utf-8
#
# AXFR client with IDN (Internationalized Domain Names) support
#
import ldns
import encodings.idna
def utf2name(name):
return '.'.join([encodings.idna.ToASCII(a) for a in name.split('.')])
def name2utf(name):
return '.'.join([encodings.idna.ToUnicode(a) for a in name.split('.')])
resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf")
#addr = ldns.ldns_get_rr_list_addr_by_name(resolver, "zone.nic.cz", ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD);
addr = resolver.get_addr_by_name("zone.nic.cz", ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD);
if (not addr):
raise Exception("Can't retrieve server address")
print "Addr_by_name:",str(addr).replace("\n","; ")
#remove all nameservers
while resolver.pop_nameserver():
pass
#insert server addr
for rr in addr.rrs():
resolver.push_nameserver_rr(rr)
#AXFR transfer
status = resolver.axfr_start(utf2name(u"háčkyčárky.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))
#Print results
while True:
rr = resolver.axfr_next()
if not rr:
break
rdf = rr.owner()
if (rdf.get_type() == ldns.LDNS_RDF_TYPE_DNAME):
print "RDF owner: type=",rdf.get_type_str(),"data=",name2utf(str(rdf))
else:
print "RDF owner: type=",rdf.get_type_str(),"data=",str(rdf)
print " RR type=", rr.get_type_str()," ttl=",rr.ttl()
for rdf in rr.rdfs():
if (rdf.get_type() == ldns.LDNS_RDF_TYPE_DNAME):
print " RDF: type=",rdf.get_type_str(),"data=",name2utf(str(rdf))
else:
print " RDF: type=",rdf.get_type_str(),"data=",str(rdf)
print

8
zonemaster-ldns/ldns/contrib/python/examples/ldns-buf.py Executable file
View File

@@ -0,0 +1,8 @@
#!/usr/bin/python
import ldns
buf = ldns.ldns_buffer(1024)
buf.printf("Test buffer")
print buf

45
zonemaster-ldns/ldns/contrib/python/examples/ldns-dnssec.py Executable file
View File

@@ -0,0 +1,45 @@
#!/usr/bin/python
# -*- coding: utf-8 -*-
import ldns
import sys
debug = True
# Check args
argc = len(sys.argv)
name = "www.nic.cz"
if argc < 2:
print "Usage:", sys.argv[0], "domain [resolver_addr]"
sys.exit(1)
else:
name = sys.argv[1]
# Create resolver
resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf")
resolver.set_dnssec(True)
# Custom resolver
if argc > 2:
# Clear previous nameservers
ns = resolver.pop_nameserver()
while ns != None:
ns = resolver.pop_nameserver()
ip = ldns.ldns_rdf.new_frm_str(sys.argv[2], ldns.LDNS_RDF_TYPE_A)
resolver.push_nameserver(ip)
# Resolve DNS name
pkt = resolver.query(name, ldns.LDNS_RR_TYPE_A, ldns.LDNS_RR_CLASS_IN)
if pkt and pkt.answer():
# Debug
if debug:
print "NS returned:", pkt.get_rcode(), "(AA: %d AD: %d)" % ( pkt.ad(), pkt.ad() )
# SERVFAIL indicated bogus name
if pkt.get_rcode() is ldns.LDNS_RCODE_SERVFAIL:
print name, "is bogus"
# Check AD (Authenticated) bit
if pkt.get_rcode() is ldns.LDNS_RCODE_NOERROR:
if pkt.ad(): print name, "is secure"
else: print name, "is insecure"

36
zonemaster-ldns/ldns/contrib/python/examples/ldns-higher.py Executable file
View File

@@ -0,0 +1,36 @@
#!/usr/bin/python
import ldns
resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf")
dnn = ldns.ldns_dname("www.google.com")
print dnn.get_type_str(), dnn
dna = ldns.ldns_rdf.new_frm_str("74.125.43.99",ldns.LDNS_RDF_TYPE_A)
print dna.get_type_str(), dna
name = resolver.get_name_by_addr(dna)
if (not name): raise Exception("Can't retrieve server name")
for rr in name.rrs():
print rr
name = resolver.get_name_by_addr("74.125.43.99")
if (not name): raise Exception("Can't retrieve server name")
for rr in name.rrs():
print rr
addr = resolver.get_addr_by_name(dnn)
if (not addr): raise Exception("Can't retrieve server address")
for rr in addr.rrs():
print rr
addr = resolver.get_addr_by_name("www.google.com")
if (not addr): raise Exception("Can't retrieve server address")
for rr in addr.rrs():
print rr
hosts = ldns.ldns_rr_list.new_frm_file("/etc/hosts")
if (not hosts): raise Exception("Can't retrieve the content of file")
for rr in hosts.rrs():
print rr

46
zonemaster-ldns/ldns/contrib/python/examples/ldns-keygen.py Executable file
View File

@@ -0,0 +1,46 @@
#!/usr/bin/python
#
# This example shows how to generate public/private key pair
#
import ldns
algorithm = ldns.LDNS_SIGN_DSA
bits = 512
ldns.ldns_init_random(open("/dev/urandom","rb"), (bits+7)//8)
domain = ldns.ldns_dname("example.")
#generate a new key
key = ldns.ldns_key.new_frm_algorithm(algorithm, bits);
print key
#set owner
key.set_pubkey_owner(domain)
#create the public from the ldns_key
pubkey = key.key_to_rr()
#previous command is equivalent to
# pubkey = ldns.ldns_key2rr(key)
print pubkey
#calculate and set the keytag
key.set_keytag(ldns.ldns_calc_keytag(pubkey))
#build the DS record
ds = ldns.ldns_key_rr2ds(pubkey, ldns.LDNS_SHA1)
print ds
owner, tag = pubkey.owner(), key.keytag()
#write public key to .key file
fw = open("key-%s-%d.key" % (owner,tag), "wb")
pubkey.print_to_file(fw)
#write private key to .priv file
fw = open("key-%s-%d.private" % (owner,tag), "wb")
key.print_to_file(fw)
#write DS to .ds file
fw = open("key-%s-%d.ds" % (owner,tag), "wb")
ds.print_to_file(fw)

15
zonemaster-ldns/ldns/contrib/python/examples/ldns-mx.py Executable file
View File

@@ -0,0 +1,15 @@
#!/usr/bin/python
#
# MX is a small program that prints out the mx records for a particular domain
#
import ldns
resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf")
pkt = resolver.query("nic.cz", ldns.LDNS_RR_TYPE_MX,ldns.LDNS_RR_CLASS_IN)
if (pkt):
mx = pkt.rr_list_by_type(ldns.LDNS_RR_TYPE_MX, ldns.LDNS_SECTION_ANSWER)
if (mx):
mx.sort()
print mx

18
zonemaster-ldns/ldns/contrib/python/examples/ldns-mx1.py Executable file
View File

@@ -0,0 +1,18 @@
#!/usr/bin/python
#
# MX is a small program that prints out the mx records for a particular domain
#
import ldns
dname = ldns.ldns_dname("nic.cz")
print dname
resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf")
pkt = resolver.query(dname, ldns.LDNS_RR_TYPE_MX,ldns.LDNS_RR_CLASS_IN)
if (pkt):
mx = pkt.rr_list_by_type(ldns.LDNS_RR_TYPE_MX, ldns.LDNS_SECTION_ANSWER)
if (mx):
mx.sort()
print mx

19
zonemaster-ldns/ldns/contrib/python/examples/ldns-mx2.py Executable file
View File

@@ -0,0 +1,19 @@
#!/usr/bin/python
#
# MX is a small program that prints out the mx records for a particular domain
#
import ldns
resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf")
pkt = resolver.query("nic.cz", ldns.LDNS_RR_TYPE_MX,ldns.LDNS_RR_CLASS_IN)
if (pkt) and (pkt.answer()):
for rr in pkt.answer().rrs():
if (rr.get_type() != ldns.LDNS_RR_TYPE_MX):
continue
rdf = rr.owner()
print rdf," ",rr.ttl()," ",rr.get_class_str()," ",rr.get_type_str()," ",
print " ".join(str(rdf) for rdf in rr.rdfs())

17
zonemaster-ldns/ldns/contrib/python/examples/ldns-newpkt.py Executable file
View File

@@ -0,0 +1,17 @@
#!/usr/bin/python
import ldns
pkt = ldns.ldns_pkt.new_query_frm_str("www.google.com",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_QR | ldns.LDNS_AA)
rra = ldns.ldns_rr.new_frm_str("www.google.com. IN A 192.168.1.1",300)
rrb = ldns.ldns_rr.new_frm_str("www.google.com. IN TXT Some\ Description",300)
list = ldns.ldns_rr_list()
if (rra): list.push_rr(rra)
if (rrb): list.push_rr(rrb)
pkt.push_rr_list(ldns.LDNS_SECTION_ANSWER, list)
print "Packet:"
print pkt

65
zonemaster-ldns/ldns/contrib/python/examples/ldns-signzone.py Executable file
View File

@@ -0,0 +1,65 @@
#!/usr/bin/python
# This example shows how to sign a given zone file with private key
import ldns
import sys, os, time
#private key TAG which identifies the private key
#use ldns-keygen.py in order to obtain private key
keytag = 30761
# Read zone file
#-------------------------------------------------------------
zone = ldns.ldns_zone.new_frm_fp(open("zone.txt","r"), None, 0, ldns.LDNS_RR_CLASS_IN)
soa = zone.soa()
origin = soa.owner()
# Prepare keys
#-------------------------------------------------------------
#Read private key from file
keyfile = open("key-%s-%d.private" % (origin, keytag), "r");
key = ldns.ldns_key.new_frm_fp(keyfile)
#Read public key from file
pubfname = "key-%s-%d.key" % (origin, keytag)
pubkey = None
if os.path.isfile(pubfname):
pubkeyfile = open(pubfname, "r");
pubkey,_,_,_ = ldns.ldns_rr.new_frm_fp(pubkeyfile)
if not pubkey:
#Create new public key
pubkey = key.key_to_rr()
#Set key expiration
key.set_expiration(int(time.time()) + 365*60*60*24) #365 days
#Set key owner (important step)
key.set_pubkey_owner(origin)
#Insert DNSKEY RR
zone.push_rr(pubkey)
# Sign zone
#-------------------------------------------------------------
#Create keylist and push private key
keys = ldns.ldns_key_list()
keys.push_key(key)
#Add SOA
signed_zone = ldns.ldns_dnssec_zone()
signed_zone.add_rr(soa)
#Add RRs
for rr in zone.rrs().rrs():
print "RR:",str(rr),
signed_zone.add_rr(rr)
added_rrs = ldns.ldns_rr_list()
status = signed_zone.sign(added_rrs, keys)
if (status == ldns.LDNS_STATUS_OK):
signed_zone.print_to_file(open("zone_signed.txt","w"))

15
zonemaster-ldns/ldns/contrib/python/examples/ldns-zone.py Executable file
View File

@@ -0,0 +1,15 @@
#!/usr/bin/python
import ldns
#Read zone from file
zone = ldns.ldns_zone.new_frm_fp(open("zone.txt","r"), None, 0, ldns.LDNS_RR_CLASS_IN)
print zone
print "SOA:", zone.soa()
for r in zone.rrs().rrs():
print "RR:", r
zone = ldns.ldns_zone()
#print zone

15
zonemaster-ldns/ldns/contrib/python/examples/ldns_rr_iter_frm_fp_l.demo.py Normal file
View File

@@ -0,0 +1,15 @@
import ldns
import sys
if len(sys.argv) <= 1:
print "Usage: %s zone_file" % sys.argv[0]
sys.exit()
inp = open(sys.argv[1],"r");
for rr in ldns.ldns_rr_iter_frm_fp_l(inp):
print rr
inp.close()

43
zonemaster-ldns/ldns/contrib/python/examples/ldns_rr_new_frm_fp_l.demo.py Normal file
View File

@@ -0,0 +1,43 @@
import ldns
import sys
if len(sys.argv) <= 1:
print "Usage: %s zone_file" % sys.argv[0]
sys.exit()
inp = open(sys.argv[1],"r");
# variables that preserve the parsers state
my_ttl = 3600;
my_origin = None
my_prev = None
# additional state variables
last_pos = 0
line_nr = 0
while True:
ret = ldns.ldns_rr_new_frm_fp_l_(inp, my_ttl, my_origin, my_prev)
s, rr, line_inc, new_ttl, new_origin, new_prev = ret # unpack the result
line_nr += line_inc # increase number of parsed lines
my_prev = new_prev # update ref to previous owner
if s == ldns.LDNS_STATUS_SYNTAX_TTL:
my_ttl = new_ttl # update default TTL
print "$TTL:", my_ttl
elif s == ldns.LDNS_STATUS_SYNTAX_ORIGIN:
my_origin = new_origin # update reference to origin
print "$ORIGIN:", my_origin
elif s == ldns.LDNS_STATUS_SYNTAX_EMPTY:
if last_pos == inp.tell():
break # no advance since last read - EOF
last_pos = inp.tell()
elif s != ldns.LDNS_STATUS_OK:
print "! parse error in line", line_nr
else:
# we are sure to have LDNS_STATUS_OK
print rr
inp.close()
print "--------------------"
print "Read %d lines" % line_nr

56
zonemaster-ldns/ldns/contrib/python/examples/python3/ldns-axfr.py Executable file
View File

@@ -0,0 +1,56 @@
#!/usr/bin/python
# vim:fileencoding=utf-8
#
# AXFR client with IDN (Internationalized Domain Names) support
#
import ldns
import encodings.idna
def utf2name(name):
return '.'.join([encodings.idna.ToASCII(a).decode("utf-8") for a in name.split('.')])
def name2utf(name):
return '.'.join([encodings.idna.ToUnicode(a) for a in name.split('.')])
resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf")
#addr = ldns.ldns_get_rr_list_addr_by_name(resolver, "zone.nic.cz", ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD);
addr = resolver.get_addr_by_name("zone.nic.cz", ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD);
if (not addr):
raise Exception("Can't retrieve server address")
print("Addr_by_name:",str(addr).replace("\n","; "))
#remove all nameservers
while resolver.pop_nameserver():
pass
#insert server addr
for rr in addr.rrs():
resolver.push_nameserver_rr(rr)
#AXFR transfer
status = resolver.axfr_start(utf2name("háčkyčárky.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))
#Print results
while True:
rr = resolver.axfr_next()
if not rr:
break
rdf = rr.owner()
if (rdf.get_type() == ldns.LDNS_RDF_TYPE_DNAME):
print("RDF owner: type=",rdf.get_type_str(),"data=",name2utf(str(rdf)))
else:
print("RDF owner: type=",rdf.get_type_str(),"data=",str(rdf))
print(" RR type=", rr.get_type_str()," ttl=",rr.ttl())
for rdf in rr.rdfs():
if (rdf.get_type() == ldns.LDNS_RDF_TYPE_DNAME):
print(" RDF: type=",rdf.get_type_str(),"data=",name2utf(str(rdf)))
else:
print(" RDF: type=",rdf.get_type_str(),"data=",str(rdf))
print()

8
zonemaster-ldns/ldns/contrib/python/examples/python3/ldns-buf.py Executable file
View File

@@ -0,0 +1,8 @@
#!/usr/bin/python
import ldns
buf = ldns.ldns_buffer(1024)
buf.printf("Test buffer")
print(buf)

45
zonemaster-ldns/ldns/contrib/python/examples/python3/ldns-dnssec.py Executable file
View File

@@ -0,0 +1,45 @@
#!/usr/bin/python
# -*- coding: utf-8 -*-
import ldns
import sys
debug = True
# Check args
argc = len(sys.argv)
name = "www.nic.cz"
if argc < 2:
print("Usage:", sys.argv[0], "domain [resolver_addr]")
sys.exit(1)
else:
name = sys.argv[1]
# Create resolver
resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf")
resolver.set_dnssec(True)
# Custom resolver
if argc > 2:
# Clear previous nameservers
ns = resolver.pop_nameserver()
while ns != None:
ns = resolver.pop_nameserver()
ip = ldns.ldns_rdf.new_frm_str(sys.argv[2], ldns.LDNS_RDF_TYPE_A)
resolver.push_nameserver(ip)
# Resolve DNS name
pkt = resolver.query(name, ldns.LDNS_RR_TYPE_A, ldns.LDNS_RR_CLASS_IN)
if pkt and pkt.answer():
# Debug
if debug:
print("NS returned:", pkt.get_rcode(), "(AA: %d AD: %d)" % ( pkt.ad(), pkt.ad() ))
# SERVFAIL indicated bogus name
if pkt.get_rcode() is ldns.LDNS_RCODE_SERVFAIL:
print(name, "is bogus")
# Check AD (Authenticated) bit
if pkt.get_rcode() is ldns.LDNS_RCODE_NOERROR:
if pkt.ad(): print(name, "is secure")
else: print(name, "is insecure")

36
zonemaster-ldns/ldns/contrib/python/examples/python3/ldns-higher.py Executable file
View File

@@ -0,0 +1,36 @@
#!/usr/bin/python
import ldns
resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf")
dnn = ldns.ldns_dname("www.google.com")
print(dnn.get_type_str(), dnn)
dna = ldns.ldns_rdf.new_frm_str("74.125.43.99",ldns.LDNS_RDF_TYPE_A)
print(dna.get_type_str(), dna)
name = resolver.get_name_by_addr(dna)
if (not name): raise Exception("Can't retrieve server name")
for rr in name.rrs():
print(rr)
name = resolver.get_name_by_addr("74.125.43.99")
if (not name): raise Exception("Can't retrieve server name")
for rr in name.rrs():
print(rr)
addr = resolver.get_addr_by_name(dnn)
if (not addr): raise Exception("Can't retrieve server address")
for rr in addr.rrs():
print(rr)
addr = resolver.get_addr_by_name("www.google.com")
if (not addr): raise Exception("Can't retrieve server address")
for rr in addr.rrs():
print(rr)
hosts = ldns.ldns_rr_list.new_frm_file("/etc/hosts")
if (not hosts): raise Exception("Can't retrieve the content of file")
for rr in hosts.rrs():
print(rr)

46
zonemaster-ldns/ldns/contrib/python/examples/python3/ldns-keygen.py Executable file
View File

@@ -0,0 +1,46 @@
#!/usr/bin/python
#
# This example shows how to generate public/private key pair
#
import ldns
algorithm = ldns.LDNS_SIGN_DSA
bits = 512
ldns.ldns_init_random(open("/dev/random","rb"), (bits+7)//8)
domain = ldns.ldns_dname("example.")
#generate a new key
key = ldns.ldns_key.new_frm_algorithm(algorithm, bits);
print(key)
#set owner
key.set_pubkey_owner(domain)
#create the public from the ldns_key
pubkey = key.key_to_rr()
#previous command is equivalent to
# pubkey = ldns.ldns_key2rr(key)
print(pubkey)
#calculate and set the keytag
key.set_keytag(ldns.ldns_calc_keytag(pubkey))
#build the DS record
ds = ldns.ldns_key_rr2ds(pubkey, ldns.LDNS_SHA1)
print(ds)
owner, tag = pubkey.owner(), key.keytag()
#write public key to .key file
fw = open("key-%s-%d.key" % (owner,tag), "wb")
pubkey.print_to_file(fw)
#write private key to .priv file
fw = open("key-%s-%d.private" % (owner,tag), "wb")
key.print_to_file(fw)
#write DS to .ds file
fw = open("key-%s-%d.ds" % (owner,tag), "wb")
ds.print_to_file(fw)

15
zonemaster-ldns/ldns/contrib/python/examples/python3/ldns-mx.py Executable file
View File

@@ -0,0 +1,15 @@
#!/usr/bin/python
#
# MX is a small program that prints out the mx records for a particular domain
#
import ldns
resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf")
pkt = resolver.query("nic.cz", ldns.LDNS_RR_TYPE_MX,ldns.LDNS_RR_CLASS_IN)
if (pkt):
mx = pkt.rr_list_by_type(ldns.LDNS_RR_TYPE_MX, ldns.LDNS_SECTION_ANSWER)
if (mx):
mx.sort()
print(mx)

18
zonemaster-ldns/ldns/contrib/python/examples/python3/ldns-mx1.py Executable file
View File

@@ -0,0 +1,18 @@
#!/usr/bin/python
#
# MX is a small program that prints out the mx records for a particular domain
#
import ldns
dname = ldns.ldns_dname("nic.cz")
print(dname)
resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf")
pkt = resolver.query(dname, ldns.LDNS_RR_TYPE_MX,ldns.LDNS_RR_CLASS_IN)
if (pkt):
mx = pkt.rr_list_by_type(ldns.LDNS_RR_TYPE_MX, ldns.LDNS_SECTION_ANSWER)
if (mx):
mx.sort()
print(mx)

19
zonemaster-ldns/ldns/contrib/python/examples/python3/ldns-mx2.py Executable file
View File

@@ -0,0 +1,19 @@
#!/usr/bin/python
#
# MX is a small program that prints out the mx records for a particular domain
#
import ldns
resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf")
pkt = resolver.query("nic.cz", ldns.LDNS_RR_TYPE_MX,ldns.LDNS_RR_CLASS_IN)
if (pkt) and (pkt.answer()):
for rr in pkt.answer().rrs():
if (rr.get_type() != ldns.LDNS_RR_TYPE_MX):
continue
rdf = rr.owner()
print(rdf," ",rr.ttl()," ",rr.get_class_str()," ",rr.get_type_str()," ", end=" ")
print(" ".join(str(rdf) for rdf in rr.rdfs()))

17
zonemaster-ldns/ldns/contrib/python/examples/python3/ldns-newpkt.py Executable file
View File

@@ -0,0 +1,17 @@
#!/usr/bin/python
import ldns
pkt = ldns.ldns_pkt.new_query_frm_str("www.google.com",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_QR | ldns.LDNS_AA)
rra = ldns.ldns_rr.new_frm_str("www.google.com. IN A 192.168.1.1",300)
rrb = ldns.ldns_rr.new_frm_str("www.google.com. IN TXT Some\ Description",300)
list = ldns.ldns_rr_list()
if (rra): list.push_rr(rra)
if (rrb): list.push_rr(rrb)
pkt.push_rr_list(ldns.LDNS_SECTION_ANSWER, list)
print("Packet:")
print(pkt)

65
zonemaster-ldns/ldns/contrib/python/examples/python3/ldns-signzone.py Executable file
View File

@@ -0,0 +1,65 @@
#!/usr/bin/python
# This example shows how to sign a given zone file with private key
import ldns
import sys, os, time
#private key TAG which identifies the private key
#use ldns-keygen.py in order to obtain private key
keytag = 30761
# Read zone file
#-------------------------------------------------------------
zone = ldns.ldns_zone.new_frm_fp(open("zone.txt","r"), None, 0, ldns.LDNS_RR_CLASS_IN)
soa = zone.soa()
origin = soa.owner()
# Prepare keys
#-------------------------------------------------------------
#Read private key from file
keyfile = open("key-%s-%d.private" % (origin, keytag), "r");
key = ldns.ldns_key.new_frm_fp(keyfile)
#Read public key from file
pubfname = "key-%s-%d.key" % (origin, keytag)
pubkey = None
if os.path.isfile(pubfname):
pubkeyfile = open(pubfname, "r");
pubkey,_,_,_ = ldns.ldns_rr.new_frm_fp(pubkeyfile)
if not pubkey:
#Create new public key
pubkey = key.key_to_rr()
#Set key expiration
key.set_expiration(int(time.time()) + 365*60*60*24) #365 days
#Set key owner (important step)
key.set_pubkey_owner(origin)
#Insert DNSKEY RR
zone.push_rr(pubkey)
# Sign zone
#-------------------------------------------------------------
#Create keylist and push private key
keys = ldns.ldns_key_list()
keys.push_key(key)
#Add SOA
signed_zone = ldns.ldns_dnssec_zone()
signed_zone.add_rr(soa)
#Add RRs
for rr in zone.rrs().rrs():
print("RR:", str(rr), end=" ")
signed_zone.add_rr(rr)
added_rrs = ldns.ldns_rr_list()
status = signed_zone.sign(added_rrs, keys)
if (status == ldns.LDNS_STATUS_OK):
signed_zone.print_to_file(open("zone_signed.txt","w"))

15
zonemaster-ldns/ldns/contrib/python/examples/python3/ldns-zone.py Executable file
View File

@@ -0,0 +1,15 @@
#!/usr/bin/python
import ldns
#Read zone from file
zone = ldns.ldns_zone.new_frm_fp(open("../zone.txt","r"), None, 0, ldns.LDNS_RR_CLASS_IN)
print(zone)
print("SOA:", zone.soa())
for r in zone.rrs().rrs():
print("RR:", r)
zone = ldns.ldns_zone()
#print zone

12
zonemaster-ldns/ldns/contrib/python/examples/python3/ldns_rr_iter_frm_fp_l.demo.py Normal file
View File

@@ -0,0 +1,12 @@
import ldns
import sys
if len(sys.argv) <= 1:
print("Usage: %s zone_file" % sys.argv[0])
sys.exit()
inp = open(sys.argv[1],"r");
for rr in ldns.ldns_rr_iter_frm_fp_l(inp):
print(rr)
inp.close()

43
zonemaster-ldns/ldns/contrib/python/examples/python3/ldns_rr_new_frm_fp_l.demo.py Normal file
View File

@@ -0,0 +1,43 @@
import ldns
import sys
if len(sys.argv) <= 1:
print("Usage: %s zone_file" % sys.argv[0])
sys.exit()
inp = open(sys.argv[1],"r");
# variables that preserve the parsers state
my_ttl = 3600;
my_origin = None
my_prev = None
# additional state variables
last_pos = 0
line_nr = 0
while True:
ret = ldns.ldns_rr_new_frm_fp_l_(inp, my_ttl, my_origin, my_prev)
s, rr, line_inc, new_ttl, new_origin, new_prev = ret # unpack the result
line_nr += line_inc # increase number of parsed lines
my_prev = new_prev # update ref to previous owner
if s == ldns.LDNS_STATUS_SYNTAX_TTL:
my_ttl = new_ttl # update default TTL
print("$TTL:", my_ttl)
elif s == ldns.LDNS_STATUS_SYNTAX_ORIGIN:
my_origin = new_origin # update reference to origin
print("$ORIGIN:", my_origin)
elif s == ldns.LDNS_STATUS_SYNTAX_EMPTY:
if last_pos == inp.tell():
break # no advance since last read - EOF
last_pos = inp.tell()
elif s != ldns.LDNS_STATUS_OK:
print("! parse error in line", line_nr)
else:
# we are sure to have LDNS_STATUS_OK
print(rr)
inp.close()
print("--------------------")
print("Read %d lines" % line_nr)

843
zonemaster-ldns/ldns/contrib/python/examples/test_buffer.py Executable file
View File

@@ -0,0 +1,843 @@
#!/usr/bin/env python
#
# ldns_buffer 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_buffer"
method_name = None
error_detected = False
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))
# Buffer creation.
capacity = 1024
#if not error_detected:
if True:
method_name = "ldns_buffer.__init__()"
try:
buf = ldns.ldns_buffer(1024)
except:
set_error()
#if not error_detected:
if True:
method_name = "ldns_buffer.__str__()"
buf.printf("abcedf")
try:
string = buf.__str__()
except:
set_error()
if not isinstance(string, str):
# Should be string.
set_error()
buf.clear()
#if not error_detected:
if True:
method_name = "ldns_buffer.at()"
try:
ret = buf.at(512)
except:
set_error()
try:
# Must raise TypeError.
ret = buf.at("")
set_error()
except TypeError:
pass
except:
set_error()
#if not error_detected:
if True:
method_name = "ldns_buffer.available()"
try:
ret = buf.available(capacity)
except:
set_error()
if not isinstance(ret, bool):
# Should be bool.
set_error()
if not buf.available(capacity):
# Should return True.
set_error()
if buf.available(capacity + 1):
# Should return False.
set_error()
try:
# Must raise TypeError.
ret = buf.available("")
set_error()
except TypeError:
pass
except:
set_error()
# try:
# # Must raise ValueError.
# ret = buf.available("")
# set_error()
# except ValueError:
# pass
# except:
# set_error()
#if not error_detected:
if True:
method_name = "ldns_buffer.available_at()"
try:
ret = buf.available_at(512, capacity - 512)
except:
set_error()
if not isinstance(ret, bool):
# Should be bool.
set_error()
if not buf.available_at(512, capacity - 512):
# Should return True.
set_error()
if buf.available_at(512, capacity - 512 + 1):
# Should return False.
set_error()
try:
# Must raise TypeError.
ret = buf.available_at("", 1)
set_error()
except TypeError:
pass
except:
set_error()
try:
# Must raise TypeError.
ret = buf.available_at(1, "")
set_error()
except TypeError:
pass
except:
set_error()
# try:
# # Must raise ValueError.
# ret = buf.available_at(-1, 512)
# set_error()
# except ValueError:
# pass
# except:
# set_error()
# try:
# # Must raise ValueError.
# ret = buf.available_at(512, -1)
# set_error()
# except ValueError:
# pass
# except:
# set_error()
#if not error_detected:
if True:
method_name = "ldns_buffer.begin()"
try:
ret = buf.begin()
except:
set_error()
#if not error_detected:
if True:
method_name = "ldns_buffer.capacity()"
try:
ret = buf.capacity()
except:
set_error()
if (not isinstance(ret, int)) and (not isinstance(ret, long)):
# Should be int.
set_error()
#if not error_detected:
if True:
method_name = "ldns_buffer.clear()"
try:
buf.clear()
except:
set_error()
#if not error_detected:
if True:
method_name = "ldns_buffer.copy()"
sys.stderr.write("%s not tested.\n" % (method_name))
# buf2 = ldns.ldns_buffer(10)
# buf2.printf("abcdef")
# try:
# buf.copy(buf2)
# print buf.capacity()
# print buf2.capacity()
# except:
# set_error()
# buf.printf("2")
# print buf
#if not error_detected:
if True:
method_name = "ldns_buffer.current()"
try:
ret = buf.current()
except:
set_error()
#if not error_detected:
if True:
method_name = "ldns_buffer.end()"
try:
ret = buf.end()
except:
set_error()
#if not error_detected:
if True:
method_name = "ldns_buffer.export()"
sys.stderr.write("%s not tested.\n" % (method_name))
#if not error_detected:
if True:
method_name = "ldns_buffer.flip()"
buf.printf("abcdef")
try:
buf.flip()
except:
set_error()
# if buf.remaining() != capacity:
# # Should be at beginning.
# set_error()
buf.clear()
#if not error_detected:
if True:
method_name = "ldns_buffer.getc()"
buf.printf("a")
buf.rewind()
try:
ret = buf.getc()
except:
set_error()
if ret != ord("a"):
set_error()
# Test return value for -1
buf.clear()
#if not error_detected:
if True:
method_name = "ldns_buffer.invariant()"
try:
buf.invariant()
except:
set_error()
#if not error_detected:
if True:
method_name = "ldns_buffer.limit()"
try:
ret = buf.limit()
except:
set_error()
if ret != capacity:
set_error()
#if not error_detected:
if True:
method_name = "ldns_buffer.position()"
try:
ret = buf.position()
except:
set_error()
if (not isinstance(ret, int)) and (not isinstance(ret, long)):
set_error()
#if not error_detected:
if True:
method_name = "ldns_buffer.printf()"
try:
ret = buf.printf("abcdef")
except:
set_error()
if not isinstance(ret, int):
set_error()
try:
ret = buf.printf(10)
set_error()
except TypeError:
pass
except:
set_error()
buf.clear()
#if not error_detected:
if True:
method_name = "ldns_buffer.read()"
sys.stderr.write("%s not tested.\n" % (method_name))
#if not error_detected:
if True:
method_name = "ldns_buffer.read_at()"
sys.stderr.write("%s not tested.\n" % (method_name))
#if not error_detected:
if True:
method_name = "ldns_buffer.read_u16()"
buf.printf("aac")
buf.rewind()
try:
ret = buf.read_u16()
except:
set_error()
if (not isinstance(ret, int)) and (not isinstance(ret, long)):
set_error()
if ret != (ord("a") * 0x0101):
set_error()
buf.clear()
#if not error_detected:
if True:
method_name = "ldns_buffer.read_u16_at()"
buf.printf("abbc")
try:
ret = buf.read_u16_at(1)
except:
set_error()
if (not isinstance(ret, int)) and (not isinstance(ret, long)):
set_error()
if ret != (ord("b") * 0x0101):
set_error()
try:
ret = buf.read_u16_at("")
set_error()
except TypeError:
pass
except:
set_error()
# try:
# ret = buf.read_u16_at(-1)
# set_error()
# except ValueError:
# pass
# except:
# set_error()
buf.clear()
#if not error_detected:
if True:
method_name = "ldns_buffer.read_u32()"
buf.printf("aaaac")
buf.rewind()
try:
ret = buf.read_u32()
except:
set_error()
if not isinstance(ret, int):
set_error()
if ret != (ord("a") * 0x01010101):
set_error()
buf.clear()
#if not error_detected:
if True:
method_name = "ldns_buffer.read_u32_at()"
buf.printf("abbbbc")
try:
ret = buf.read_u32_at(1)
except:
set_error()
if not isinstance(ret, int):
set_error()
if ret != (ord("b") * 0x01010101):
set_error()
try:
ret = buf.read_u32_at("")
set_error()
except TypeError:
pass
except:
set_error()
# try:
# ret = buf.read_u32_at(-1)
# set_error()
# except ValueError:
# pass
# except:
# set_error()
buf.clear()
#if not error_detected:
if True:
method_name = "ldns_buffer.read_u8()"
buf.printf("ac")
buf.rewind()
try:
ret = buf.read_u8()
except:
set_error()
if (not isinstance(ret, int)) and (not isinstance(ret, long)):
set_error()
if ret != ord("a"):
set_error()
buf.clear()
#if not error_detected:
if True:
method_name = "ldns_buffer.read_u8_at()"
buf.printf("abc")
try:
ret = buf.read_u8_at(1)
except:
set_error()
if (not isinstance(ret, int)) and (not isinstance(ret, long)):
set_error()
if ret != ord("b"):
set_error()
try:
ret = buf.read_u8_at("")
set_error()
except TypeError:
pass
except:
set_error()
# try:
# ret = buf.read_u8_at(-1)
# set_error()
# except ValueError:
# pass
# except:
# set_error()
buf.clear()
#if not error_detected:
if True:
method_name = "ldns_buffer.remaining()"
buf.printf("abcdef")
try:
ret = buf.remaining()
except:
set_error()
if (not isinstance(ret, int)) and (not isinstance(ret, long)):
set_error()
if ret != (capacity - 6):
set_error()
buf.clear()
#if not error_detected:
if True:
method_name = "ldns_buffer.remaining_at()"
buf.printf("abcdef")
try:
ret = buf.remaining_at(1)
except:
set_error()
if (not isinstance(ret, int)) and (not isinstance(ret, long)):
set_error()
if ret != (capacity - 1):
set_error()
try:
ret = buf.remaining_at("")
set_error()
except TypeError:
pass
except:
set_error()
# try:
# ret = buf.remaining_at(-1)
# set_error()
# except ValueError:
# pass
# except:
# set_error()
buf.clear()
#if not error_detected:
if True:
method_name = "ldns_buffer.reserve()"
buf2 = ldns.ldns_buffer(512)
try:
ret = buf2.reserve(1024)
except:
set_error()
if not isinstance(ret, bool):
set_error()
try:
ret = buf2.reserve("")
set_error()
except TypeError:
pass
except:
set_error()
# try:
# ret = buf2.reserve(-1)
# set_error()
# except ValueError:
# pass
# except:
# set_error()
#if not error_detected:
if True:
method_name = "ldns_buffer.rewind()"
buf.printf("abcdef")
try:
buf.rewind()
except:
set_error()
if buf.position() != 0:
set_error()
buf.clear()
#if not error_detected:
if True:
method_name = "ldns_buffer.set_capacity()"
try:
ret = buf.set_capacity(capacity)
except:
set_error()
if not isinstance(ret, bool):
set_error()
try:
ret = buf.set_capacity("")
set_error()
except TypeError:
pass
except:
set_error()
# try:
# ret = buf.set_capacity(-1)
# set_error()
# except ValueError:
# pass
# except:
# set_error()
buf.clear()
#if not error_detected:
if True:
method_name = "ldns_buffer.set_limit()"
try:
buf.set_limit(0)
except:
set_error()
try:
buf.set_limit("")
set_error()
except TypeError:
pass
except:
set_error()
# try:
# buf.set_limit(-1)
# set_error()
# except ValueError:
# pass
# except:
# set_error()
buf.clear()
#if not error_detected:
if True:
method_name = "ldns_buffer.set_position()"
try:
buf.set_position(0)
except:
set_error()
try:
buf.set_position("")
except TypeError:
pass
except:
set_error()
# try:
# buf.set_position(-1)
# except ValueError:
# pass
# except:
# set_error()
buf.clear()
#if not error_detected:
if True:
method_name = "ldns_buffer.skip()"
try:
buf.skip(10)
except:
set_error()
try:
buf.skip(-1)
except:
set_error()
try:
buf.skip("")
set_error()
except TypeError:
pass
except:
set_error()
buf.clear()
#if not error_detected:
if True:
method_name = "ldns_buffer.status()"
try:
ret = buf.status()
except:
set_error()
# Returned status is an integer.
if not isinstance(ret, int):
set_error()
buf.clear()
#if not error_detected:
if True:
method_name = "ldns_buffer.status_ok()"
try:
ret = buf.status_ok()
except:
set_error()
if not isinstance(ret, bool):
set_error()
buf.clear()
#if not error_detected:
if True:
method_name = "ldns_buffer.write()"
sys.stderr.write("%s not tested.\n" % (method_name))
#if not error_detected:
if True:
method_name = "ldns_buffer.write_at()"
sys.stderr.write("%s not tested.\n" % (method_name))
#if not error_detected:
if True:
method_name = "ldns_buffer.write_string()"
try:
buf.write_string("abcdef")
except:
set_error()
# try:
# buf.write_sring(-1)
# set_error()
# except TypeError:
# pass
# except:
# set_error()
sys.stderr.write("%s not tested for parameter correctness.\n" % \
(method_name))
buf.clear()
#if not error_detected:
if True:
method_name = "ldns_buffer.write_string_at()"
sys.stderr.write("%s not tested.\n" % (method_name))
#if not error_detected:
if True:
method_name = "ldns_buffer.write_u16()"
try:
buf.write_u16(ord("b") * 0x0101)
except:
set_error()
try:
buf.write_u16("")
set_error()
except TypeError:
pass
except:
set_error()
buf.clear()
#if not error_detected:
if True:
method_name = "ldns_buffer.write_u16_at()"
buf.printf("a")
try:
buf.write_u16_at(1, ord("b") * 0x0101)
except:
set_error()
try:
buf.write_u16_at("", ord("b") * 0x0101)
set_error()
except TypeError:
pass
except:
set_error()
# try:
# buf.write_u16_at(-1, ord("b") * 0x0101)
# set_error()
# except ValueError:
# pass
# except:
# set_error()
try:
buf.write_u16_at(1, "")
set_error()
except TypeError:
pass
except:
set_error()
#if not error_detected:
if True:
method_name = "ldns_buffer.write_u32()"
try:
buf.write_u32(ord("b") * 0x01010101)
except:
set_error()
try:
buf.write_u32("")
set_error()
except TypeError:
pass
except:
set_error()
buf.clear()
#if not error_detected:
if True:
method_name = "ldns_buffer.write_u32_at()"
buf.printf("a")
try:
buf.write_u32_at(1, ord("b") * 0x01010101)
except:
set_error()
try:
buf.write_u32_at("", ord("b") * 0x01010101)
set_error()
except TypeError:
pass
except:
set_error()
# try:
# buf.write_u32_at(-1, ord("b") * 0x01010101)
# set_error()
# except ValueError:
# pass
# except:
# set_error()
try:
buf.write_u32_at(1, "")
set_error()
except TypeError:
pass
except:
set_error()
#if not error_detected:
if True:
method_name = "ldns_buffer.write_u8()"
try:
buf.write_u8(ord("b"))
except:
set_error()
try:
buf.write_u8("")
set_error()
except TypeError:
pass
except:
set_error()
buf.clear()
#if not error_detected:
if True:
method_name = "ldns_buffer.write_u8_at()"
buf.printf("a")
try:
buf.write_u8_at(1, ord("b"))
except:
set_error()
try:
buf.write_u8_at("", ord("b"))
set_error()
except TypeError:
pass
except:
set_error()
# try:
# buf.write_u8_at(-1, ord("b"))
# set_error()
# except ValueError:
# pass
# except:
# set_error()
try:
buf.write_u8_at(1, "")
set_error()
except TypeError:
pass
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)

474
zonemaster-ldns/ldns/contrib/python/examples/test_dname.py Executable file
View File

@@ -0,0 +1,474 @@
#!/usr/bin/env python
#
# ldns_dname 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_dname"
method_name = None
error_detected = False
temp_fname = "tmp_dname.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 + ".__init__()"
rdf1 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "test.nic.cz.")
rdf2 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_A, "217.31.205.50")
try:
dname = ldns.ldns_dname("www.nic.cz.")
if not isinstance(dname, ldns.ldns_dname):
set_error()
except:
set_error()
#
# Error when printing a dname which was created from an empty string.
# Must find out why.
#
try:
dname = ldns.ldns_dname(rdf1)
if not isinstance(dname, ldns.ldns_dname):
set_error()
except:
set_error()
# Test whether rdf1 and dname independent.
dname.cat(dname)
if dname.__str__() == rdf1.__str__():
set_error()
# Test whether rdf1 and dname are dependent.
dname = ldns.ldns_dname(rdf1, clone=False)
dname.cat(dname)
if dname.__str__() != rdf1.__str__():
set_error()
# Test whether constructs from non-dname rdfs.
try:
dname = ldns.ldns_dname(rdf2)
set_error()
except TypeError:
pass
except:
set_error()
try:
dname = ldns.ldns_dname(1)
set_error()
except TypeError:
pass
except:
set_error()
#if not error_detected:
if True:
method_name = class_name + ".[comparison operators]"
dn1 = ldns.ldns_dname("a.test")
dn2 = ldns.ldns_dname("b.test")
try:
ret = dn1 < dn2
if not isinstance(ret, bool):
set_error()
if ret != True:
set_error()
except:
set_error()
try:
ret = dn2 < dn1
if not isinstance(ret, bool):
set_error()
if ret != False:
set_error()
except:
set_error()
try:
ret = dn1 <= dn2
if not isinstance(ret, bool):
set_error()
if ret != True:
set_error()
except:
set_error()
try:
ret = dn2 <= dn1
if not isinstance(ret, bool):
set_error()
if ret != False:
set_error()
except:
set_error()
try:
ret = dn1 == dn2
if not isinstance(ret, bool):
set_error()
if ret != False:
set_error()
except:
set_error()
try:
ret = dn1 == dn1
if not isinstance(ret, bool):
set_error()
if ret != True:
set_error()
except:
set_error()
try:
ret = dn1 != dn2
if not isinstance(ret, bool):
set_error()
if ret != True:
set_error()
except:
set_error()
try:
ret = dn1 != dn1
if not isinstance(ret, bool):
set_error()
if ret != False:
set_error()
except:
set_error()
try:
ret = dn1 > dn2
if not isinstance(ret, bool):
set_error()
if ret != False:
set_error()
except:
set_error()
try:
ret = dn2 > dn1
if not isinstance(ret, bool):
set_error()
if ret != True:
set_error()
except:
set_error()
try:
ret = dn1 >= dn2
if not isinstance(ret, bool):
set_error()
if ret != False:
set_error()
except:
set_error()
try:
ret = dn2 >= dn1
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 + ".absolute()"
dname = ldns.ldns_dname("www.nic.cz.")
try:
ret = dname.absolute()
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 + ".cat()"
rdf1 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "test.nic.cz.")
rdf2 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_A, "217.31.205.50")
dname = ldns.ldns_dname("www.nic.cz.")
try:
ret = dname.cat(dname)
if ret != ldns.LDNS_STATUS_OK:
set_error()
if dname.__str__() != "www.nic.cz.www.nic.cz.":
set_error()
except:
set_error()
try:
ret = dname.cat(rdf1)
if ret != ldns.LDNS_STATUS_OK:
set_error()
if dname.__str__() != "www.nic.cz.www.nic.cz.test.nic.cz.":
set_error()
except:
set_error()
try:
ret = dname.cat(rdf2)
if ret == ldns.LDNS_STATUS_OK:
set_error()
except:
set_error()
try:
ret = dname.cat("")
set_error()
except TypeError:
pass
except:
set_error()
#if not error_detected:
if True:
method_name = class_name + ".cat_clone()"
rdf1 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "test.nic.cz.")
rdf2 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_A, "217.31.205.50")
dname = ldns.ldns_dname("www.nic.cz.")
try:
ret = dname.cat_clone(dname)
if not isinstance(ret, ldns.ldns_dname):
set_error()
if ret.__str__() != "www.nic.cz.www.nic.cz.":
set_error()
except:
set_error()
try:
ret = dname.cat_clone(rdf1)
if not isinstance(ret, ldns.ldns_dname):
set_error()
if ret.__str__() != "www.nic.cz.test.nic.cz.":
set_error()
except:
set_error()
try:
ret = dname.cat_clone(rdf2)
if ret != None:
set_error()
except:
set_error()
try:
ret = dname.cat_clone("")
except TypeError:
pass
except:
set_error()
#if not error_detected:
if True:
method_name = class_name + ".interval()"
dn1 = ldns.ldns_dname("a.ns.nic.cz.")
dn2 = ldns.ldns_dname("b.ns.nic.cz.")
dn3 = ldns.ldns_dname("c.ns.nic.cz.")
try:
ret = dn1.interval(dn2, dn3)
if ret != -1:
set_error()
except:
set_error()
try:
ret = dn2.interval(dn1, dn3)
if ret != 1:
set_error()
except:
set_error()
rdf4 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "d.ns.nic.cz.")
rdf5 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_A, "194.0.12.1")
try:
ret = dn1.interval(dn2, rdf4)
if ret != -1:
set_error()
except:
set_error()
try:
ret = dn2.interval(dn1, rdf4)
if ret != 1:
set_error()
except:
set_error()
try:
ret = dn1.interval(dn2, rdf5)
set_error()
except Exception:
pass
except:
set_error()
try:
ret = dn1.interval(dn2, "")
set_error()
except TypeError:
pass
except:
set_error()
#if not error_detected:
if True:
method_name = class_name + ".is_subdomain()"
dn1 = ldns.ldns_dname("nic.cz.")
dn2 = ldns.ldns_dname("www.nic.cz.")
rdf3 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "www.nic.cz.")
try:
ret = dn1.is_subdomain(dn2)
if not isinstance(ret, bool):
set_error()
if ret == True:
set_error()
ret = dn2.is_subdomain(dn1)
if ret != True:
set_error()
except:
set_error()
try:
ret = dn1.is_subdomain(rdf3)
if not isinstance(ret, bool):
set_error()
if ret == True:
set_error()
except:
set_error()
rdf4 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_A, "194.0.12.1")
try:
ret = dn1.is_subdomain(rdf4)
if ret != False:
set_error()
except:
set_error()
try:
ret = dn1.is_subdomain("")
set_error()
except TypeError:
pass
except:
set_error()
#if not error_detected:
if True:
method_name = class_name + ".label()"
dn = ldns.ldns_dname("nic.cz.")
try:
ret = dn.label(0)
if not isinstance(ret, ldns.ldns_dname):
set_error()
except:
set_error()
try:
ret = dn.label(10)
if ret != None:
set_error()
except:
set_error()
try:
ret = dn.label("")
except TypeError:
pass
except:
set_error()
#if not error_detected:
if True:
method_name = class_name + ".label_count()"
dn = ldns.ldns_dname("www.nic.cz.")
try:
ret = dn.label_count()
if (not isinstance(ret, int)) and (not isinstance(ret, long)):
set_error()
if ret != 3:
set_error()
except:
set_error()
#if not error_detected:
if True:
method_name = class_name + ".left_chop()"
dn = ldns.ldns_dname("www.nic.cz.")
try:
ret = dn.left_chop()
if not isinstance(ret, ldns.ldns_dname):
set_error()
except:
set_error()
#if not error_detected:
if True:
method_name = class_name + ".make_canonical()"
dn = ldns.ldns_dname("WWW.NIC.CZ.")
try:
dn.make_canonical()
if dn.__str__() != "www.nic.cz.":
set_error()
except:
set_error()
#if not error_detected:
if True:
method_name = class_name + ".new_frm_rdf()"
# Tested via constructor call.
#if not error_detected:
if True:
method_name = class_name + ".new_frm_str()"
# Tested via constructor call.
#if not error_detected:
if True:
method_name = class_name + ".reverse()"
dn = ldns.ldns_dname("www.nic.cz.")
try:
ret = dn.reverse()
if not isinstance(ret, ldns.ldns_dname):
set_error()
if ret.__str__() != "cz.nic.www.":
set_error()
except:
set_error()
#if not error_detected:
if True:
method_name = class_name + ".write_to_buffer()"
dn = ldns.ldns_dname("www.nic.cz.")
buf = ldns.ldns_buffer(1024)
try:
ret = dn.write_to_buffer(buf)
if ret != ldns.LDNS_STATUS_OK:
set_error()
if buf.position() != 12:
set_error()
except:
set_error()
try:
ret = dn.write_to_buffer("")
except TypeError:
pass
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)

1937
zonemaster-ldns/ldns/contrib/python/examples/test_pkt.py Executable file
View File

File diff suppressed because it is too large Load Diff

820
zonemaster-ldns/ldns/contrib/python/examples/test_rdf.py Executable file
View File

@@ -0,0 +1,820 @@
#!/usr/bin/env python
#
# ldns_rdf 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_rdf"
method_name = None
error_detected = False
temp_fname = "tmp_rdf.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 + ".__init__()"
try:
# Should raise an Exception
rdf = ldns.ldns_rdf()
set_error()
except Exception as e:
pass
#if not error_detected:
if True:
method_name = class_name + ".[comparison operators]"
rdf1 = ldns.ldns_rdf.new_frm_str("0.0.0.0", ldns.LDNS_RDF_TYPE_A)
rdf2 = ldns.ldns_rdf.new_frm_str("1.1.1.1", ldns.LDNS_RDF_TYPE_A)
try:
ret = rdf1 < rdf2
if not isinstance(ret, bool):
set_error()
if ret != True:
set_error()
except:
set_error()
try:
ret = rdf2 < rdf1
if not isinstance(ret, bool):
set_error()
if ret != False:
set_error()
except:
set_error()
try:
ret = rdf1 <= rdf2
if not isinstance(ret, bool):
set_error()
if ret != True:
set_error()
except:
set_error()
try:
ret = rdf2 <= rdf1
if not isinstance(ret, bool):
set_error()
if ret != False:
set_error()
except:
set_error()
try:
ret = rdf1 == rdf2
if not isinstance(ret, bool):
set_error()
if ret != False:
set_error()
except:
set_error()
try:
ret = rdf1 == rdf1
if not isinstance(ret, bool):
set_error()
if ret != True:
set_error()
except:
set_error()
try:
ret = rdf1 != rdf2
if not isinstance(ret, bool):
set_error()
if ret != True:
set_error()
except:
set_error()
try:
ret = rdf1 != rdf1
if not isinstance(ret, bool):
set_error()
if ret != False:
set_error()
except:
set_error()
try:
ret = rdf1 > rdf2
if not isinstance(ret, bool):
set_error()
if ret != False:
set_error()
except:
set_error()
try:
ret = rdf2 > rdf1
if not isinstance(ret, bool):
set_error()
if ret != True:
set_error()
except:
set_error()
try:
ret = rdf1 >= rdf2
if not isinstance(ret, bool):
set_error()
if ret != False:
set_error()
except:
set_error()
try:
ret = rdf2 >= rdf1
if not isinstance(ret, bool):
set_error()
if ret != True:
set_error()
except:
set_error()
#if not error_detected:
if True:
method_name = "ldns_rdf_new()"
sys.stderr.write("%s not tested.\n" % (method_name))
#if not error_detected:
if True:
method_name = "ldns_rdf_new_frm_data()"
sys.stderr.write("%s not tested.\n" % (method_name))
#if not error_detected:
if True:
method_name = "ldns_rdf_new_frm_str()"
try:
rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "www.nic.cz")
except:
set_error()
try:
rdf = ldns.ldns_rdf_new_frm_str("", "www.nic.cz")
et_error()
except TypeError:
pass
except:
set_error()
try:
rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, 1)
except TypeError:
pass
except:
set_error()
#if not error_detected:
if True:
method_name = "ldns_rdf_new_frm_fp()"
f = open(temp_fname, "w")
f.write("217.31.205.50")
f.close()
f = open(temp_fname, "r")
try:
status, rdf = ldns.ldns_rdf_new_frm_fp(ldns.LDNS_RDF_TYPE_A, f)
if status != ldns.LDNS_STATUS_OK:
set_error()
if rdf == None:
set_error()
except:
set_error()
try:
# Reading past file end.
status, rdf = ldns.ldns_rdf_new_frm_fp(ldns.LDNS_RDF_TYPE_AAAA, f)
if status == ldns.LDNS_STATUS_OK:
set_error()
if rdf != None:
set_error()
except:
set_error()
f.close()
f = open(temp_fname, "r")
try:
status, rdf = ldns.ldns_rdf_new_frm_fp(ldns.LDNS_RDF_TYPE_AAAA, f)
if status != ldns.LDNS_STATUS_OK:
set_error()
if rdf != None:
set_error()
except:
set_error()
f.close()
os.remove(temp_fname)
try:
status, rdf = ldns.ldns_rdf_new_frm_fp("", f)
except TypeError:
pass
except:
set_error()
try:
status, rdf = ldns.ldns_rdf_new_frm_fp(ldns.LDNS_RDF_TYPE_AAAA, "")
except TypeError:
pass
except:
set_error()
#if not error_detected:
if True:
method_name = "ldns_rdf_new_frm_fp_l()"
f = open(temp_fname, "w")
f.write("217.31.205.50\n194.0.12.1")
f.close()
f = open(temp_fname, "r")
try:
status, rdf, line = ldns.ldns_rdf_new_frm_fp_l(ldns.LDNS_RDF_TYPE_A, f)
if status != ldns.LDNS_STATUS_OK:
set_error()
if rdf == None:
set_error()
except:
set_error()
try:
status, rdf, line = ldns.ldns_rdf_new_frm_fp_l(ldns.LDNS_RDF_TYPE_A, f)
if status != ldns.LDNS_STATUS_OK:
set_error()
if rdf == None:
set_error()
except:
set_error()
try:
# Reading past file end.
status, rdf, line = ldns.ldns_rdf_new_frm_fp_l(ldns.LDNS_RDF_TYPE_A, f)
if status == ldns.LDNS_STATUS_OK:
set_error()
if rdf != None:
set_error()
except:
set_error()
f.close()
os.remove(temp_fname)
try:
status, rdf = ldns.ldns_rdf_new_frm_fp_l("", f)
except TypeError:
pass
except:
set_error()
try:
status, rdf = ldns.ldns_rdf_new_frm_fp_l(ldns.LDNS_RDF_TYPE_AAAA, "")
except TypeError:
pass
except:
set_error()
#if not error_detected:
if True:
method_name = "ldns_drf.absolute()"
rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "www.nic.cz.")
try:
ret = rdf.absolute()
if not isinstance(ret, bool):
set_error()
if not ret:
set_error()
except:
set_error()
#if not error_detected:
if True:
method_name = "ldns_rdf.address_reverse()"
rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_A, "194.0.12.1")
try:
ret = rdf.address_reverse()
if ret == None:
set_error()
except:
set_error()
rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_AAAA, "::1")
try:
ret = rdf.address_reverse()
if ret == None:
set_error()
except:
set_error()
rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "www.nic.cz.")
try:
ret = rdf.address_reverse()
if ret != None:
set_error()
except:
set_error()
#if not error_detected:
if True:
method_name = "ldns_rdf.cat()"
rdf1 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "www.nic")
rdf2 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "cz.")
try:
ret = rdf1.cat(rdf2)
if ret != ldns.LDNS_STATUS_OK:
set_error()
except:
set_error()
rdf1 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "www.nic.")
rdf2 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_A, "127.0.0.1")
try:
ret = rdf1.cat(rdf2)
if ret == ldns.LDNS_STATUS_OK:
set_error()
except:
set_error()
try:
ret = rdf2.cat(rdf1)
if ret == ldns.LDNS_STATUS_OK:
set_error()
except:
set_error()
try:
ret = rdf2.cat("")
set_error()
except TypeError:
pass
except:
set_error()
#if not error_detected:
if True:
method_name = "ldns_rdf.cat_clone()"
rdf1 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "www.nic")
rdf2 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "cz.")
try:
ret = rdf1.cat_clone(rdf2)
if ret == None:
set_error()
except:
set_error()
rdf1 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "www.nic.")
rdf2 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_A, "127.0.0.1")
try:
ret = rdf1.cat_clone(rdf2)
if ret != None:
set_error()
except:
set_error()
try:
ret = rdf2.cat_clone(rdf1)
if ret != None:
set_error()
except:
set_error()
try:
ret = rdf2.cat_clone("")
set_error()
except TypeError:
pass
except:
set_error()
#if not error_detected:
if True:
method_name = "ldns_rdf.clone()"
rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "www.nic.cz.")
try:
ret = rdf.clone()
except:
set_error()
#if not error_detected:
if True:
method_name = "ldns_rdf.data()"
rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "www.nic.cz.")
try:
ret = rdf.data()
except:
set_error()
#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.")
try:
ret = rdf1.dname_compare(rdf2)
if ret != 1:
set_error()
except:
set_error()
try:
ret = rdf2.dname_compare(rdf1)
if ret != -1:
set_error()
except:
set_error()
try:
ret = rdf1.dname_compare(rdf1)
if ret != 0:
set_error()
except:
set_error()
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_A, "127.0.0.1")
try:
ret = rdf1.dname_compare(rdf2)
set_error()
except Exception:
pass
except:
set_error()
#if not error_detected:
if True:
method_name = "ldns_rdf.dname_new_frm_str()"
try:
rdf = ldns.ldns_rdf.dname_new_frm_str("www.nic.cz.")
if rdf == None:
set_error()
except:
set_error()
try:
rdf = ldns.ldns_rdf.dname_new_frm_str("")
if rdf != None:
set_error()
except:
set_error()
try:
rdf = ldns.ldns_rdf.dname_new_frm_str(1)
set_error()
except TypeError:
pass
except:
set_error()
#if not error_detected:
if True:
method_name = "ldns_rdf.get_type()"
rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "www.nic.cz.")
try:
ret = rdf.get_type()
if not isinstance(ret, int):
set_error()
if ret != ldns.LDNS_RDF_TYPE_DNAME:
set_error()
except:
set_error()
#if not error_detected:
if True:
method_name = "ldns_rdf.get_type_str()"
rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "www.nic.cz.")
try:
ret = rdf.get_type_str()
if not isinstance(ret, str):
set_error()
except:
set_error()
#if not error_detected:
if True:
method_name = "ldns_rdf.interval()"
rdf1 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "a.ns.nic.cz.")
rdf2 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "b.ns.nic.cz.")
rdf3 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "c.ns.nic.cz.")
try:
ret = rdf1.interval(rdf2, rdf3)
if ret != -1:
set_error()
except:
set_error()
try:
ret = rdf2.interval(rdf1, rdf3)
if ret != 1:
set_error()
except:
set_error()
rdf1 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_A, "194.0.12.1")
rdf2 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "b.ns.nic.cz.")
rdf3 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "c.ns.nic.cz.")
try:
ret = rdf1.interval(rdf2, rdf3)
set_error()
except Exception:
pass
except:
set_error()
try:
ret = rdf2.interval("", rdf3)
set_error()
except TypeError:
pass
except:
set_error()
#if not error_detected:
if True:
method_name = "ldns_rdf.is_subdomain()"
rdf1 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "nic.cz.")
rdf2 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "www.nic.cz.")
try:
ret = rdf1.is_subdomain(rdf2)
if not isinstance(ret, bool):
set_error()
if ret == True:
set_error()
ret = rdf2.is_subdomain(rdf1)
if ret != True:
set_error()
except:
set_error()
rdf1 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_A, "194.0.12.1")
rdf2 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "www.nic.cz.")
try:
ret = rdf1.is_subdomain(rdf2)
if ret != False:
set_error()
except:
set_error()
try:
ret = rdf2.is_subdomain(rdf1)
if ret != False:
set_error()
except:
set_error()
try:
ret = rdf2.is_subdomain("")
set_error()
except TypeError:
pass
except:
set_error()
#if not error_detected:
if True:
method_name = "ldns_rdf.label()"
rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "www.nic.cz.")
try:
ret = rdf.label(0)
if not isinstance(ret, ldns.ldns_rdf):
set_error()
except:
set_error()
try:
ret = rdf.label(10)
if ret != None:
set_error()
except:
set_error()
try:
ret = rdf.label("")
except TypeError:
pass
except:
set_error()
rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_A, "127.0.0.1")
try:
ret = rdf.label(0)
if ret != None:
set_error()
except:
set_error()
#if not error_detected:
if True:
method_name = "ldns_rdf.label_count()"
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)) and (not isinstance(ret, long)):
set_error()
if ret != 3:
set_error()
except:
set_error()
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)) and (not isinstance(ret, long)):
set_error()
if ret != 0:
set_error()
except:
set_error()
#if not error_detected:
if True:
method_name = "ldns_rdf.left_chop()"
rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "www.nic.cz.")
try:
ret = rdf.left_chop()
if not isinstance(ret, ldns.ldns_rdf):
set_error()
except:
set_error()
rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_A, "127.0.0.1")
try:
ret = rdf.left_chop()
if ret != None:
set_error()
except:
set_error()
#if not error_detected:
if True:
method_name = "ldns_rdf.make_canonical()"
rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "WWW.NIC.CZ.")
try:
rdf.make_canonical()
if rdf.__str__() != "www.nic.cz.":
set_error()
except:
set_error()
rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_A, "127.0.0.1")
try:
rdf.make_canonical()
except:
set_error()
#if not error_detected:
if True:
method_name = "ldns_rdf.new_frm_str()"
try:
rdf = ldns.ldns_rdf.new_frm_str("www.nic.cz.", ldns.LDNS_RDF_TYPE_DNAME)
except:
set_error()
try:
rdf = ldns.ldns_rdf.new_frm_str("www.nic.cz.", ldns.LDNS_RDF_TYPE_AAAA)
set_error()
except Exception:
pass
except:
set_error()
try:
rdf = ldns.ldns_rdf.new_frm_str("www.nic.cz.", ldns.LDNS_RDF_TYPE_AAAA, raiseException = False)
if rdf != None:
set_error()
except:
set_error()
try:
rdf = ldns.ldns_rdf.new_frm_str("", "www.nic.cz")
et_error()
except TypeError:
pass
except:
set_error()
try:
rdf = ldns.ldns_rdf.new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, 1)
except TypeError:
pass
except:
set_error()
#if not error_detected:
if True:
rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_A, "127.0.0.1")
f = open(temp_fname, "w")
try:
rdf.print_to_file(f)
except:
set_error()
f.close()
f = open(temp_fname, "r")
if f.read() != "127.0.0.1":
set_error()
f.close()
os.remove(temp_fname)
#if not error_detected:
if True:
rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "www.nic.cz.")
try:
ret = rdf.reverse()
if not isinstance(ret, ldns.ldns_rdf):
set_error()
if ret.__str__() != "cz.nic.www.":
set_error()
except:
set_error()
rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_A, "127.0.0.1")
try:
ret = rdf.reverse()
set_error()
except Exception:
pass
except:
set_error()
#if not error_detected:
if True:
method_name = "ldns_rdf.set_data()"
sys.stderr.write("%s not tested.\n" % (method_name))
#if not error_detected:
if True:
method_name = "ldns_rdf.set_size()"
sys.stderr.write("%s not tested.\n" % (method_name))
#if not error_detected:
if True:
method_name = "ldns_rdf.set_type()"
sys.stderr.write("%s not tested.\n" % (method_name))
#if not error_detected:
if True:
method_name = "ldns_rdf.size()"
rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "www.nic.cz.")
try:
ret = rdf.size()
if ret != 12:
set_error()
except:
set_error()
#if not error_detected:
if True:
method_name = "ldns_rdf.write_to_buffer()"
rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "www.nic.cz.")
buf = ldns.ldns_buffer(1024)
try:
ret = rdf.write_to_buffer(buf)
if ret != ldns.LDNS_STATUS_OK:
set_error()
if buf.position() != 12:
set_error()
except:
set_error()
try:
ret = rdf.write_to_buffer("")
except TypeError:
pass
except:
set_error()
#if not error_detected:
if True:
method_name = "ldns_rdf.write_to_buffer_canonical()"
rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "WWW.NIC.CZ.")
buf = ldns.ldns_buffer(1024)
try:
ret = rdf.write_to_buffer_canonical(buf)
if ret != ldns.LDNS_STATUS_OK:
set_error()
if buf.position() != 12:
set_error()
except:
set_error()
try:
ret = rdf.write_to_buffer_canonical("")
except TypeError:
pass
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)

1751
zonemaster-ldns/ldns/contrib/python/examples/test_resolver.py Executable file
View File

File diff suppressed because it is too large Load Diff

2383
zonemaster-ldns/ldns/contrib/python/examples/test_rr.py Executable file
View File

File diff suppressed because it is too large Load Diff

15
zonemaster-ldns/ldns/contrib/python/examples/zone.txt Normal file
View File

@@ -0,0 +1,15 @@
$ORIGIN example.
$TTL 600
example. IN SOA example. admin.example. (
2008022501 ; serial
28800 ; refresh (8 hours)
7200 ; retry (2 hours)
604800 ; expire (1 week)
18000 ; minimum (5 hours)
)
@ IN MX 10 mail.example.
@ IN NS ns1
@ IN NS ns2
@ IN A 192.168.1.1