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

53
zonemaster-ldns/ldns/contrib/DNS-LDNS/Changes Normal file
View File

@@ -0,0 +1,53 @@
Revision history for Perl extension DNS::LDNS.
0.01 Thu Nov 22 12:48:29 2012
- original version; created by h2xs 1.23 with options
-A -n LDNS
0.02 Fri Jan 18 09:47:57 2013
- Support for DNSSec and Resolver. Added some more constants from
the header files; created by h2xs 1.23 with options
-n LDNS /usr/include/ldns/ldns.h /usr/include/ldns/error.h /usr/include/ldns/rr.h /usr/include/ldns/keys.h /usr/include/ldns/packet.h /usr/include/ldns/resolver.h /usr/include/ldns/rdata.h /usr/include/ldns/dnssec.h
0.03 Fri Apr 19 13:40:57 2013
- Renamed module to Net::LDNS
0.04 Fri Dec 13 14:15:26 2013
- Renamed module to DNS::LDNS
0.05 Mon Dec 30 10:14:00 2013
- Corrected versioning variable in all classes.
- Cleaned up the base class documentation.
0.06 Tue Dec 31 12:17:00 2013
- Corrected pod syntax
0.50 Sun Mar 30 11:05:23 2014
- Added prev parameter to the DNS::LDNS::RR::new(str) constructor.
- Corrected DNS::LDNS::RR::new(file/filename) constructor. Added prev
parameter, changed the default_ttl and origin parameters to
references so they can return data back to the caller as intended.
Using the 'built-in' default values for ttl and origin, rather than
my own values.
- Corrected the DNS::LDNS::Zone::new() constructor. Corrected file
option for reading zone from stream. Using the 'built-in' default
values for ttl and origin, rather than my own values.
- Removed the $DNS::LDNS::DEFAULT_* variables, they proved to be less
useful after modifying the Zone and RR constructors.
- More robust Makefile.PL. Check for existence of ldns library
and perl modules required for the test suite.
0.51 Wed Apr 2 09:12:00 2014
- Added META.yml, and added some more package dependencies.
- Compatibility with ldns < 1.6.12.
0.52 Tue May 5 09:13:00 2015
- Fixed typo in META.yml
0.60 Thu Dec 29 11:15:00 2016
- Compatibility with ldns 1.7
- Dist::zilla build management
0.61 Fri Dec 30 14:32:00 2016
- Bugfixes for ldns 1.7 compatibility
- Compatibility with perl 5.25

3434
zonemaster-ldns/ldns/contrib/DNS-LDNS/LDNS.xs Normal file
View File

File diff suppressed because it is too large Load Diff

38
zonemaster-ldns/ldns/contrib/DNS-LDNS/MANIFEST Normal file
View File

@@ -0,0 +1,38 @@
Changes
constants.PL
dist.ini
LDNS.xs
lib/DNS/LDNS.pm
lib/DNS/LDNS/DNSSecDataChain.pm
lib/DNS/LDNS/DNSSecName.pm
lib/DNS/LDNS/DNSSecRRs.pm
lib/DNS/LDNS/DNSSecRRSets.pm
lib/DNS/LDNS/DNSSecTrustTree.pm
lib/DNS/LDNS/DNSSecZone.pm
lib/DNS/LDNS/GC.pm
lib/DNS/LDNS/Key.pm
lib/DNS/LDNS/KeyList.pm
lib/DNS/LDNS/Packet.pm
lib/DNS/LDNS/RBNode.pm
lib/DNS/LDNS/RBTree.pm
lib/DNS/LDNS/RData.pm
lib/DNS/LDNS/Resolver.pm
lib/DNS/LDNS/RR.pm
lib/DNS/LDNS/RRList.pm
lib/DNS/LDNS/Zone.pm
MANIFEST
ppport.h
README
t/dnssec_datachain.t
t/dnssec_zone.t
t/key.t
t/DNS-LDNS.t
t/rdata.t
t/resolver.t
t/rr.t
t/rrlist.t
t/testdata/key.private
t/testdata/myzone.org
t/testdata/resolv.conf
t/zone.t
typemap

36
zonemaster-ldns/ldns/contrib/DNS-LDNS/README Normal file
View File

@@ -0,0 +1,36 @@
DNS::LDNS version 0.61
======================
DESCRIPTION
DNS::LDNS is a perl OO-wrapper for the ldns library. For a detailed
description on how this library works, you are advised to read the ldns
documentation. For a functional description of the wrapper classes,
please read the perldoc for DNS::LDNS and subclasses.
INSTALLATION
To install this module type the following:
perl Makefile.PL
make
make test
make install
DEPENDENCIES
This module requires these other modules and libraries:
ldns
AUTHOR
Erik Pihl Ostlyngen, erik.ostlyngen@uninett.no
COPYRIGHT AND LICENCE
Copyright (C) 2013 by UNINETT Norid AS
This library is free software; you can redistribute it and/or modify
it under the same terms as Perl itself, either Perl version 5.8.8 or,
at your option, any later version of Perl 5 you may have available.

280
zonemaster-ldns/ldns/contrib/DNS-LDNS/constants.PL Normal file
View File

@@ -0,0 +1,280 @@
use ExtUtils::Constant;
# If you edit these definitions to change the constants used by this module,
# you will need to use the generated const-c.inc and const-xs.inc
# files to replace their "fallback" counterparts before distributing your
# changes.
my @names = (qw(LDNS_AA LDNS_AD LDNS_CD LDNS_DEFAULT_EXP_TIME
LDNS_DEFAULT_TTL LDNS_DNSSEC_KEYPROTO LDNS_IP4ADDRLEN
LDNS_IP6ADDRLEN LDNS_KEY_REVOKE_KEY LDNS_KEY_SEP_KEY
LDNS_KEY_ZONE_KEY LDNS_MAX_DOMAINLEN LDNS_MAX_KEYLEN
LDNS_MAX_LABELLEN LDNS_MAX_PACKETLEN LDNS_MAX_POINTERS
LDNS_MAX_RDFLEN LDNS_NSEC3_MAX_ITERATIONS
LDNS_NSEC3_VARS_OPTOUT_MASK LDNS_PORT LDNS_QR LDNS_RA LDNS_RD
LDNS_RDATA_FIELD_DESCRIPTORS_COMMON LDNS_RDF_SIZE_16BYTES
LDNS_RDF_SIZE_6BYTES LDNS_RDF_SIZE_BYTE
LDNS_RDF_SIZE_DOUBLEWORD LDNS_RDF_SIZE_WORD LDNS_RESOLV_ANCHOR
LDNS_RESOLV_DEFDOMAIN LDNS_RESOLV_INET LDNS_RESOLV_INET6
LDNS_RESOLV_INETANY LDNS_RESOLV_KEYWORD LDNS_RESOLV_KEYWORDS
LDNS_RESOLV_NAMESERVER LDNS_RESOLV_OPTIONS LDNS_RESOLV_RTT_INF
LDNS_RESOLV_RTT_MIN LDNS_RESOLV_SEARCH LDNS_RESOLV_SORTLIST
LDNS_RR_OVERHEAD LDNS_SIGNATURE_LEAVE_ADD_NEW
LDNS_SIGNATURE_LEAVE_NO_ADD LDNS_SIGNATURE_REMOVE_ADD_NEW
LDNS_SIGNATURE_REMOVE_NO_ADD LDNS_TC),
{name=>"LDNS_CERT_ACPKIX", macro=>"1"},
{name=>"LDNS_CERT_IACPKIX", macro=>"1"},
{name=>"LDNS_CERT_IPGP", macro=>"1"},
{name=>"LDNS_CERT_IPKIX", macro=>"1"},
{name=>"LDNS_CERT_ISPKI", macro=>"1"},
{name=>"LDNS_CERT_OID", macro=>"1"},
{name=>"LDNS_CERT_PGP", macro=>"1"},
{name=>"LDNS_CERT_PKIX", macro=>"1"},
{name=>"LDNS_CERT_SPKI", macro=>"1"},
{name=>"LDNS_CERT_URI", macro=>"1"},
{name=>"LDNS_DH", macro=>"1"},
{name=>"LDNS_DSA", macro=>"1"},
{name=>"LDNS_DSA_NSEC3", macro=>"1"},
{name=>"LDNS_ECC", macro=>"1"},
{name=>"LDNS_ECC_GOST", macro=>"1"},
{name=>"LDNS_HASH_GOST", macro=>"1"},
{name=>"LDNS_PACKET_ANSWER", macro=>"1"},
{name=>"LDNS_PACKET_IQUERY", macro=>"1"},
{name=>"LDNS_PACKET_NODATA", macro=>"1"},
{name=>"LDNS_PACKET_NOTIFY", macro=>"1"},
{name=>"LDNS_PACKET_NXDOMAIN", macro=>"1"},
{name=>"LDNS_PACKET_QUERY", macro=>"1"},
{name=>"LDNS_PACKET_QUESTION", macro=>"1"},
{name=>"LDNS_PACKET_REFERRAL", macro=>"1"},
{name=>"LDNS_PACKET_STATUS", macro=>"1"},
{name=>"LDNS_PACKET_UNKNOWN", macro=>"1"},
{name=>"LDNS_PACKET_UPDATE", macro=>"1"},
{name=>"LDNS_PRIVATEDNS", macro=>"1"},
{name=>"LDNS_PRIVATEOID", macro=>"1"},
{name=>"LDNS_RCODE_FORMERR", macro=>"1"},
{name=>"LDNS_RCODE_NOERROR", macro=>"1"},
{name=>"LDNS_RCODE_NOTAUTH", macro=>"1"},
{name=>"LDNS_RCODE_NOTIMPL", macro=>"1"},
{name=>"LDNS_RCODE_NOTZONE", macro=>"1"},
{name=>"LDNS_RCODE_NXDOMAIN", macro=>"1"},
{name=>"LDNS_RCODE_NXRRSET", macro=>"1"},
{name=>"LDNS_RCODE_REFUSED", macro=>"1"},
{name=>"LDNS_RCODE_SERVFAIL", macro=>"1"},
{name=>"LDNS_RCODE_YXDOMAIN", macro=>"1"},
{name=>"LDNS_RCODE_YXRRSET", macro=>"1"},
{name=>"LDNS_RDF_TYPE_A", macro=>"1"},
{name=>"LDNS_RDF_TYPE_AAAA", macro=>"1"},
{name=>"LDNS_RDF_TYPE_ALG", macro=>"1"},
{name=>"LDNS_RDF_TYPE_APL", macro=>"1"},
{name=>"LDNS_RDF_TYPE_ATMA", macro=>"1"},
{name=>"LDNS_RDF_TYPE_B32_EXT", macro=>"1"},
{name=>"LDNS_RDF_TYPE_B64", macro=>"1"},
{name=>"LDNS_RDF_TYPE_CERT_ALG", macro=>"1"},
{name=>"LDNS_RDF_TYPE_CLASS", macro=>"1"},
{name=>"LDNS_RDF_TYPE_DNAME", macro=>"1"},
{name=>"LDNS_RDF_TYPE_HEX", macro=>"1"},
{name=>"LDNS_RDF_TYPE_INT16", macro=>"1"},
{name=>"LDNS_RDF_TYPE_INT16_DATA", macro=>"1"},
{name=>"LDNS_RDF_TYPE_INT32", macro=>"1"},
{name=>"LDNS_RDF_TYPE_INT8", macro=>"1"},
{name=>"LDNS_RDF_TYPE_IPSECKEY", macro=>"1"},
{name=>"LDNS_RDF_TYPE_LOC", macro=>"1"},
{name=>"LDNS_RDF_TYPE_NONE", macro=>"1"},
{name=>"LDNS_RDF_TYPE_NSAP", macro=>"1"},
{name=>"LDNS_RDF_TYPE_NSEC", macro=>"1"},
{name=>"LDNS_RDF_TYPE_NSEC3_NEXT_OWNER", macro=>"1"},
{name=>"LDNS_RDF_TYPE_NSEC3_SALT", macro=>"1"},
{name=>"LDNS_RDF_TYPE_PERIOD", macro=>"1"},
{name=>"LDNS_RDF_TYPE_SERVICE", macro=>"1"},
{name=>"LDNS_RDF_TYPE_STR", macro=>"1"},
{name=>"LDNS_RDF_TYPE_TIME", macro=>"1"},
{name=>"LDNS_RDF_TYPE_HIP", macro=>"1"},
{name=>"LDNS_RDF_TYPE_TSIGTIME", macro=>"1"},
{name=>"LDNS_RDF_TYPE_TYPE", macro=>"1"},
{name=>"LDNS_RDF_TYPE_UNKNOWN", macro=>"1"},
{name=>"LDNS_RDF_TYPE_WKS", macro=>"1"},
{name=>"LDNS_RR_CLASS_ANY", macro=>"1"},
{name=>"LDNS_RR_CLASS_CH", macro=>"1"},
{name=>"LDNS_RR_CLASS_COUNT", macro=>"1"},
{name=>"LDNS_RR_CLASS_FIRST", macro=>"1"},
{name=>"LDNS_RR_CLASS_HS", macro=>"1"},
{name=>"LDNS_RR_CLASS_IN", macro=>"1"},
{name=>"LDNS_RR_CLASS_LAST", macro=>"1"},
{name=>"LDNS_RR_CLASS_NONE", macro=>"1"},
{name=>"LDNS_RR_COMPRESS", macro=>"1"},
{name=>"LDNS_RR_NO_COMPRESS", macro=>"1"},
{name=>"LDNS_RR_TYPE_A", macro=>"1"},
{name=>"LDNS_RR_TYPE_A6", macro=>"1"},
{name=>"LDNS_RR_TYPE_AAAA", macro=>"1"},
{name=>"LDNS_RR_TYPE_AFSDB", macro=>"1"},
{name=>"LDNS_RR_TYPE_ANY", macro=>"1"},
{name=>"LDNS_RR_TYPE_APL", macro=>"1"},
{name=>"LDNS_RR_TYPE_ATMA", macro=>"1"},
{name=>"LDNS_RR_TYPE_AXFR", macro=>"1"},
{name=>"LDNS_RR_TYPE_CERT", macro=>"1"},
{name=>"LDNS_RR_TYPE_CNAME", macro=>"1"},
{name=>"LDNS_RR_TYPE_COUNT", macro=>"1"},
{name=>"LDNS_RR_TYPE_DHCID", macro=>"1"},
{name=>"LDNS_RR_TYPE_DLV", macro=>"1"},
{name=>"LDNS_RR_TYPE_DNAME", macro=>"1"},
{name=>"LDNS_RR_TYPE_DNSKEY", macro=>"1"},
{name=>"LDNS_RR_TYPE_DS", macro=>"1"},
{name=>"LDNS_RR_TYPE_EID", macro=>"1"},
{name=>"LDNS_RR_TYPE_FIRST", macro=>"1"},
{name=>"LDNS_RR_TYPE_GID", macro=>"1"},
{name=>"LDNS_RR_TYPE_GPOS", macro=>"1"},
{name=>"LDNS_RR_TYPE_HINFO", macro=>"1"},
{name=>"LDNS_RR_TYPE_IPSECKEY", macro=>"1"},
{name=>"LDNS_RR_TYPE_ISDN", macro=>"1"},
{name=>"LDNS_RR_TYPE_IXFR", macro=>"1"},
{name=>"LDNS_RR_TYPE_KEY", macro=>"1"},
{name=>"LDNS_RR_TYPE_KX", macro=>"1"},
{name=>"LDNS_RR_TYPE_LAST", macro=>"1"},
{name=>"LDNS_RR_TYPE_LOC", macro=>"1"},
{name=>"LDNS_RR_TYPE_MAILA", macro=>"1"},
{name=>"LDNS_RR_TYPE_MAILB", macro=>"1"},
{name=>"LDNS_RR_TYPE_MB", macro=>"1"},
{name=>"LDNS_RR_TYPE_MD", macro=>"1"},
{name=>"LDNS_RR_TYPE_MF", macro=>"1"},
{name=>"LDNS_RR_TYPE_MG", macro=>"1"},
{name=>"LDNS_RR_TYPE_MINFO", macro=>"1"},
{name=>"LDNS_RR_TYPE_MR", macro=>"1"},
{name=>"LDNS_RR_TYPE_MX", macro=>"1"},
{name=>"LDNS_RR_TYPE_NAPTR", macro=>"1"},
{name=>"LDNS_RR_TYPE_NIMLOC", macro=>"1"},
{name=>"LDNS_RR_TYPE_NS", macro=>"1"},
{name=>"LDNS_RR_TYPE_NSAP", macro=>"1"},
{name=>"LDNS_RR_TYPE_NSAP_PTR", macro=>"1"},
{name=>"LDNS_RR_TYPE_NSEC", macro=>"1"},
{name=>"LDNS_RR_TYPE_NSEC3", macro=>"1"},
{name=>"LDNS_RR_TYPE_NSEC3PARAM", macro=>"1"},
{name=>"LDNS_RR_TYPE_NSEC3PARAMS", macro=>"1"},
{name=>"LDNS_RR_TYPE_NULL", macro=>"1"},
{name=>"LDNS_RR_TYPE_NXT", macro=>"1"},
{name=>"LDNS_RR_TYPE_OPT", macro=>"1"},
{name=>"LDNS_RR_TYPE_PTR", macro=>"1"},
{name=>"LDNS_RR_TYPE_PX", macro=>"1"},
{name=>"LDNS_RR_TYPE_RP", macro=>"1"},
{name=>"LDNS_RR_TYPE_RRSIG", macro=>"1"},
{name=>"LDNS_RR_TYPE_RT", macro=>"1"},
{name=>"LDNS_RR_TYPE_SIG", macro=>"1"},
{name=>"LDNS_RR_TYPE_SINK", macro=>"1"},
{name=>"LDNS_RR_TYPE_SOA", macro=>"1"},
{name=>"LDNS_RR_TYPE_SPF", macro=>"1"},
{name=>"LDNS_RR_TYPE_SRV", macro=>"1"},
{name=>"LDNS_RR_TYPE_SSHFP", macro=>"1"},
{name=>"LDNS_RR_TYPE_TALINK", macro=>"1"},
{name=>"LDNS_RR_TYPE_TSIG", macro=>"1"},
{name=>"LDNS_RR_TYPE_TXT", macro=>"1"},
{name=>"LDNS_RR_TYPE_UID", macro=>"1"},
{name=>"LDNS_RR_TYPE_UINFO", macro=>"1"},
{name=>"LDNS_RR_TYPE_UNSPEC", macro=>"1"},
{name=>"LDNS_RR_TYPE_WKS", macro=>"1"},
{name=>"LDNS_RR_TYPE_X25", macro=>"1"},
{name=>"LDNS_RSAMD5", macro=>"1"},
{name=>"LDNS_RSASHA1", macro=>"1"},
{name=>"LDNS_RSASHA1_NSEC3", macro=>"1"},
{name=>"LDNS_RSASHA256", macro=>"1"},
{name=>"LDNS_RSASHA512", macro=>"1"},
{name=>"LDNS_SECTION_ADDITIONAL", macro=>"1"},
{name=>"LDNS_SECTION_ANSWER", macro=>"1"},
{name=>"LDNS_SECTION_ANY", macro=>"1"},
{name=>"LDNS_SECTION_ANY_NOQUESTION", macro=>"1"},
{name=>"LDNS_SECTION_AUTHORITY", macro=>"1"},
{name=>"LDNS_SECTION_QUESTION", macro=>"1"},
{name=>"LDNS_SHA1", macro=>"1"},
{name=>"LDNS_SHA256", macro=>"1"},
{name=>"LDNS_SIGN_DSA", macro=>"1"},
{name=>"LDNS_SIGN_DSA_NSEC3", macro=>"1"},
{name=>"LDNS_SIGN_ECC_GOST", macro=>"1"},
{name=>"LDNS_SIGN_HMACSHA1", macro=>"1"},
{name=>"LDNS_SIGN_HMACSHA256", macro=>"1"},
{name=>"LDNS_SIGN_RSAMD5", macro=>"1"},
{name=>"LDNS_SIGN_RSASHA1", macro=>"1"},
{name=>"LDNS_SIGN_RSASHA1_NSEC3", macro=>"1"},
{name=>"LDNS_SIGN_RSASHA256", macro=>"1"},
{name=>"LDNS_SIGN_RSASHA512", macro=>"1"},
{name=>"LDNS_STATUS_ADDRESS_ERR", macro=>"1"},
{name=>"LDNS_STATUS_CERT_BAD_ALGORITHM", macro=>"1"},
{name=>"LDNS_STATUS_CRYPTO_ALGO_NOT_IMPL", macro=>"1"},
{name=>"LDNS_STATUS_CRYPTO_BOGUS", macro=>"1"},
{name=>"LDNS_STATUS_CRYPTO_EXPIRATION_BEFORE_INCEPTION", macro=>"1"},
{name=>"LDNS_STATUS_CRYPTO_NO_DNSKEY", macro=>"1"},
{name=>"LDNS_STATUS_CRYPTO_NO_DS", macro=>"1"},
{name=>"LDNS_STATUS_CRYPTO_NO_MATCHING_KEYTAG_DNSKEY", macro=>"1"},
{name=>"LDNS_STATUS_CRYPTO_NO_RRSIG", macro=>"1"},
{name=>"LDNS_STATUS_CRYPTO_NO_TRUSTED_DNSKEY", macro=>"1"},
{name=>"LDNS_STATUS_CRYPTO_NO_TRUSTED_DS", macro=>"1"},
{name=>"LDNS_STATUS_CRYPTO_SIG_EXPIRED", macro=>"1"},
{name=>"LDNS_STATUS_CRYPTO_SIG_NOT_INCEPTED", macro=>"1"},
{name=>"LDNS_STATUS_CRYPTO_TSIG_BOGUS", macro=>"1"},
{name=>"LDNS_STATUS_CRYPTO_TSIG_ERR", macro=>"1"},
{name=>"LDNS_STATUS_CRYPTO_TYPE_COVERED_ERR", macro=>"1"},
{name=>"LDNS_STATUS_CRYPTO_UNKNOWN_ALGO", macro=>"1"},
{name=>"LDNS_STATUS_CRYPTO_VALIDATED", macro=>"1"},
{name=>"LDNS_STATUS_DDD_OVERFLOW", macro=>"1"},
{name=>"LDNS_STATUS_DNSSEC_EXISTENCE_DENIED", macro=>"1"},
{name=>"LDNS_STATUS_DNSSEC_NSEC3_ORIGINAL_NOT_FOUND", macro=>"1"},
{name=>"LDNS_STATUS_DNSSEC_NSEC_RR_NOT_COVERED", macro=>"1"},
{name=>"LDNS_STATUS_DNSSEC_NSEC_WILDCARD_NOT_COVERED", macro=>"1"},
{name=>"LDNS_STATUS_DOMAINNAME_OVERFLOW", macro=>"1"},
{name=>"LDNS_STATUS_DOMAINNAME_UNDERFLOW", macro=>"1"},
{name=>"LDNS_STATUS_EMPTY_LABEL", macro=>"1"},
{name=>"LDNS_STATUS_ENGINE_KEY_NOT_LOADED", macro=>"1"},
{name=>"LDNS_STATUS_ERR", macro=>"1"},
{name=>"LDNS_STATUS_FILE_ERR", macro=>"1"},
{name=>"LDNS_STATUS_INTERNAL_ERR", macro=>"1"},
{name=>"LDNS_STATUS_INVALID_B32_EXT", macro=>"1"},
{name=>"LDNS_STATUS_INVALID_B64", macro=>"1"},
{name=>"LDNS_STATUS_INVALID_HEX", macro=>"1"},
{name=>"LDNS_STATUS_INVALID_INT", macro=>"1"},
{name=>"LDNS_STATUS_INVALID_IP4", macro=>"1"},
{name=>"LDNS_STATUS_INVALID_IP6", macro=>"1"},
{name=>"LDNS_STATUS_INVALID_POINTER", macro=>"1"},
{name=>"LDNS_STATUS_INVALID_STR", macro=>"1"},
{name=>"LDNS_STATUS_INVALID_TIME", macro=>"1"},
{name=>"LDNS_STATUS_LABEL_OVERFLOW", macro=>"1"},
{name=>"LDNS_STATUS_MEM_ERR", macro=>"1"},
{name=>"LDNS_STATUS_MISSING_RDATA_FIELDS_KEY", macro=>"1"},
{name=>"LDNS_STATUS_MISSING_RDATA_FIELDS_RRSIG", macro=>"1"},
{name=>"LDNS_STATUS_NETWORK_ERR", macro=>"1"},
{name=>"LDNS_STATUS_NOT_IMPL", macro=>"1"},
{name=>"LDNS_STATUS_NO_DATA", macro=>"1"},
{name=>"LDNS_STATUS_NSEC3_ERR", macro=>"1"},
{name=>"LDNS_STATUS_NULL", macro=>"1"},
{name=>"LDNS_STATUS_OK", macro=>"1"},
{name=>"LDNS_STATUS_PACKET_OVERFLOW", macro=>"1"},
{name=>"LDNS_STATUS_RES_NO_NS", macro=>"1"},
{name=>"LDNS_STATUS_RES_QUERY", macro=>"1"},
{name=>"LDNS_STATUS_SOCKET_ERROR", macro=>"1"},
{name=>"LDNS_STATUS_SSL_ERR", macro=>"1"},
{name=>"LDNS_STATUS_SYNTAX_ALG_ERR", macro=>"1"},
{name=>"LDNS_STATUS_SYNTAX_BAD_ESCAPE", macro=>"1"},
{name=>"LDNS_STATUS_SYNTAX_CLASS_ERR", macro=>"1"},
{name=>"LDNS_STATUS_SYNTAX_DNAME_ERR", macro=>"1"},
{name=>"LDNS_STATUS_SYNTAX_EMPTY", macro=>"1"},
{name=>"LDNS_STATUS_SYNTAX_ERR", macro=>"1"},
{name=>"LDNS_STATUS_SYNTAX_INCLUDE", macro=>"1"},
{name=>"LDNS_STATUS_SYNTAX_INCLUDE_ERR_NOTIMPL", macro=>"1"},
{name=>"LDNS_STATUS_SYNTAX_INTEGER_OVERFLOW", macro=>"1"},
{name=>"LDNS_STATUS_SYNTAX_ITERATIONS_OVERFLOW", macro=>"1"},
{name=>"LDNS_STATUS_SYNTAX_KEYWORD_ERR", macro=>"1"},
{name=>"LDNS_STATUS_SYNTAX_MISSING_VALUE_ERR", macro=>"1"},
{name=>"LDNS_STATUS_SYNTAX_ORIGIN", macro=>"1"},
{name=>"LDNS_STATUS_SYNTAX_RDATA_ERR", macro=>"1"},
{name=>"LDNS_STATUS_SYNTAX_TTL", macro=>"1"},
{name=>"LDNS_STATUS_SYNTAX_TTL_ERR", macro=>"1"},
{name=>"LDNS_STATUS_SYNTAX_TYPE_ERR", macro=>"1"},
{name=>"LDNS_STATUS_SYNTAX_VERSION_ERR", macro=>"1"},
{name=>"LDNS_STATUS_UNKNOWN_INET", macro=>"1"},
{name=>"LDNS_STATUS_WIRE_INCOMPLETE_ADDITIONAL", macro=>"1"},
{name=>"LDNS_STATUS_WIRE_INCOMPLETE_ANSWER", macro=>"1"},
{name=>"LDNS_STATUS_WIRE_INCOMPLETE_AUTHORITY", macro=>"1"},
{name=>"LDNS_STATUS_WIRE_INCOMPLETE_HEADER", macro=>"1"},
{name=>"LDNS_STATUS_WIRE_INCOMPLETE_QUESTION", macro=>"1"});
ExtUtils::Constant::WriteConstants(
NAME => 'LDNS',
NAMES => \@names,
DEFAULT_TYPE => 'IV',
C_FILE => 'const-c.inc',
XS_FILE => 'const-xs.inc',
);

18
zonemaster-ldns/ldns/contrib/DNS-LDNS/dist.ini Normal file
View File

@@ -0,0 +1,18 @@
name = DNS-LDNS
author = Erik Ostlyngen <erik@uninett.no>
copyright_holder = UNINETT Norid AS
copyright_year = 2013
license = None
version = 0.61
[AutoPrereqs]
[GatherDir]
[MetaYAML]
[MakeMaker::Awesome]
WriteMakefile_arg = LIBS => ['-lldns']
footer_file = constants.PL
[CheckLib]
lib = ldns
header = ldns/ldns.h
[License]
[PruneCruft]

1298
zonemaster-ldns/ldns/contrib/DNS-LDNS/lib/DNS/LDNS.pm Normal file
View File

File diff suppressed because it is too large Load Diff

87
zonemaster-ldns/ldns/contrib/DNS-LDNS/lib/DNS/LDNS/DNSSecDataChain.pm Normal file
View File

@@ -0,0 +1,87 @@
package DNS::LDNS::DNSSecDataChain;
use 5.008008;
use strict;
use warnings;
use DNS::LDNS;
our $VERSION = '0.61';
sub rrset {
my $self = shift;
return DNS::LDNS::GC::own($self->_rrset, $self);
}
sub signatures {
my $self = shift;
return DNS::LDNS::GC::own($self->_signatures, $self);
}
sub parent {
my $self = shift;
return DNS::LDNS::GC::own($self->_parent, $self);
}
sub derive_trust_tree {
my ($self, $rr) = @_;
if (!DNS::LDNS::GC::is_owned($rr) or DNS::LDNS::GC::owner($rr) ne $self) {
die "The rr ($rr) must be in the data chain ($self)";
}
return DNS::LDNS::GC::own($self->_derive_trust_tree($rr), $self);
}
sub derive_trust_tree_time {
my ($self, $rr, $checktime) = @_;
if (!DNS::LDNS::GC::is_owned($rr) or DNS::LDNS::GC::owner($rr) ne $self) {
die "The rr ($rr) must be in the data chain ($self)";
}
return DNS::LDNS::GC::own(
$self->_derive_trust_tree_time($rr, $checktime), $self);
}
1;
__END__
=head1 NAME
DNS::LDNS::DNSSecDataChain - DNSSec data chain element
=head1 SYNOPSIS
use DNS::LDNS ':all'
chain = new DNS::LDNS::DNSSecDataChain
chain->print(fp)
chain->derive_trust_tree(rr)
chain->derive_trust_tree_time(rr, checktime)
# Node attributes
rrset = chain->rrset
rrset = chain->signatures
rrtype = chain->parent_type
pchain = chain->parent
rcode = chain->packet_rcode
rrtype = chain->packet_qtype
bool = chain->packet_nodata
=head1 SEE ALSO
http://www.nlnetlabs.nl/projects/ldns
=head1 AUTHOR
Erik Pihl Ostlyngen, E<lt>erik.ostlyngen@uninett.noE<gt>
=head1 COPYRIGHT AND LICENSE
Copyright (C) 2013 by UNINETT Norid AS
This library is free software; you can redistribute it and/or modify
it under the same terms as Perl itself, either Perl version 5.14.2 or,
at your option, any later version of Perl 5 you may have available.
=cut

110
zonemaster-ldns/ldns/contrib/DNS-LDNS/lib/DNS/LDNS/DNSSecName.pm Normal file
View File

@@ -0,0 +1,110 @@
package DNS::LDNS::DNSSecName;
use 5.008008;
use strict;
use warnings;
use DNS::LDNS ':all';
our $VERSION = '0.61';
sub new {
my $class = shift;
return _new;
}
sub name {
my $self = shift;
return DNS::LDNS::GC::own($self->_name, $self);
}
sub set_name {
my ($self, $name) = @_;
DNS::LDNS::GC::disown(my $old = $self->name);
_set_name($self, my $copy = $name->clone);
DNS::LDNS::GC::own($copy, $self);
}
sub rrsets {
my $self = shift;
return DNS::LDNS::GC::own($self->_rrsets, $self);
}
sub add_rr {
my ($self, $rr) = @_;
my $s = _add_rr($self, my $copy = $rr->clone);
DNS::LDNS::GC::own($copy, $self);
$DNS::LDNS::last_status = $s;
return $s;
}
sub nsec {
my $self = shift;
return DNS::LDNS::GC::own($self->_nsec, $self);
}
sub set_nsec {
my ($self, $nsec) = @_;
DNS::LDNS::GC::disown(my $old = $self->nsec);
_set_nsec($self, my $copy = $nsec->clone);
DNS::LDNS::GC::own($copy, $self);
}
sub hashed_name {
my $self = shift;
return DNS::LDNS::GC::own($self->_hashed_name, $self);
}
sub nsec_signatures {
my $self = shift;
return DNS::LDNS::GC::own($self->_nsec_signatures, $self);
}
sub DESTROY {
DNS::LDNS::GC::free($_[0]);
}
1;
__END__
=head1 NAME
DNS::LDNS::DNSSecName - Dname with rrsets in a dnssec zone
=head1 SYNOPSIS
use LDNS ':all'
my name = new DNS::LDNS::DNSSecName
rdata = name->name
name->set_name(rdata)
bool = name->is_glue
rrsets = name->rrsets
name->add_rr(rr)
rr = name->nsec
name->set_nsec(rr)
hash = name->hashed_name
rrs = name->nsec_signatures
=head1 SEE ALSO
http://www.nlnetlabs.nl/projects/ldns
=head1 AUTHOR
Erik Pihl Ostlyngen, E<lt>erik.ostlyngen@uninett.noE<gt>
=head1 COPYRIGHT AND LICENSE
Copyright (C) 2013 by UNINETT Norid AS
This library is free software; you can redistribute it and/or modify
it under the same terms as Perl itself, either Perl version 5.14.2 or,
at your option, any later version of Perl 5 you may have available.
=cut

85
zonemaster-ldns/ldns/contrib/DNS-LDNS/lib/DNS/LDNS/DNSSecRRSets.pm Normal file
View File

@@ -0,0 +1,85 @@
package DNS::LDNS::DNSSecRRSets;
use 5.008008;
use strict;
use warnings;
use DNS::LDNS;
our $VERSION = '0.61';
# Note: Since this class does not have a constructor, we can let its child
# objects be owned by the parent. This reduces the recursion depth on
# DESTROY.
sub rrs {
my $self = shift;
return DNS::LDNS::GC::own($self->_rrs, DNS::LDNS::GC::owner($self));
}
sub signatures {
my $self = shift;
return DNS::LDNS::GC::own($self->_signatures, DNS::LDNS::GC::owner($self));
}
sub next {
my $self = shift;
return DNS::LDNS::GC::own($self->_next, DNS::LDNS::GC::owner($self));
}
sub set_type {
my ($self, $type) = @_;
my $s = _set_type($self, $type);
$DNS::LDNS::last_status = $s;
return $s;
}
sub add_rr {
my ($self, $rr) = @_;
my $s = _add_rr($self, my $copy = $rr->clone);
$DNS::LDNS::last_status = $s;
DNS::LDNS::GC::own($copy, $self);
return $s;
}
sub DESTROY {
DNS::LDNS::GC::free($_[0]);
}
1;
__END__
=head1 NAME
DNS::LDNS::DNSSecRRSets - Linked list of rrsets in a dnssec zone
=head1 SYNOPSIS
use DNS::LDNS ':all'
rrs = rrsets->rrs
rrs = rrsets->signatures
rrsets2 = rrsets->next
rrsets->add_rr(rr)
bool = rrsets->contains_type(rr_type)
rr_type = rrsets->type
rrsets->set_type(rr_type)
=head1 SEE ALSO
http://www.nlnetlabs.nl/projects/ldns
=head1 AUTHOR
Erik Pihl Ostlyngen, E<lt>erik.ostlyngen@uninett.noE<gt>
=head1 COPYRIGHT AND LICENSE
Copyright (C) 2013 by UNINETT Norid AS
This library is free software; you can redistribute it and/or modify
it under the same terms as Perl itself, either Perl version 5.14.2 or,
at your option, any later version of Perl 5 you may have available.
=cut

82
zonemaster-ldns/ldns/contrib/DNS-LDNS/lib/DNS/LDNS/DNSSecRRs.pm Normal file
View File

@@ -0,0 +1,82 @@
package DNS::LDNS::DNSSecRRs;
use 5.008008;
use strict;
use warnings;
use DNS::LDNS;
our $VERSION = '0.61';
# Note: This class does not have a constructor. Thus, it can not be created
# as an individual object. The data structure of the node is owned
# and freed by the owner of the parent rather than the parent node. This
# is to prevent deep recursion on DESTROY.
sub to_string {
my $self = shift;
my $ret = '';
while ($self and $self->rr) {
$ret .= $self->rr->to_string;
$self = $self->next;
}
return $ret;
}
sub add_rr {
my ($self, $rr) = @_;
my $s = _add_rr($self, my $copy = $rr->clone);
DNS::LDNS::GC::own($self, $copy);
$DNS::LDNS::last_status = $s;
return $s;
}
sub rr {
my $self = shift;
return DNS::LDNS::GC::own($self->_rr, DNS::LDNS::GC::owner($self));
}
sub next {
my $self = shift;
return DNS::LDNS::GC::own($self->_next, DNS::LDNS::GC::owner($self));
}
sub DESTROY {
DNS::LDNS::GC::free($_[0]);
}
1;
__END__
=head1 NAME
DNS::LDNS::DNSSecRRs - Linked list of rrs in a dnssec zone
=head1 SYNOPSIS
use DNS::LDNS ':all'
rrs->to_string
rrs->add_rr(rr)
rr = rrs->rr
rrs2 = rrs->next
=head1 SEE ALSO
http://www.nlnetlabs.nl/projects/ldns
=head1 AUTHOR
Erik Pihl Ostlyngen, E<lt>erik.ostlyngen@uninett.noE<gt>
=head1 COPYRIGHT AND LICENSE
Copyright (C) 2013 by UNINETT Norid AS
This library is free software; you can redistribute it and/or modify
it under the same terms as Perl itself, either Perl version 5.14.2 or,
at your option, any later version of Perl 5 you may have available.
=cut

99
zonemaster-ldns/ldns/contrib/DNS-LDNS/lib/DNS/LDNS/DNSSecTrustTree.pm Normal file
View File

@@ -0,0 +1,99 @@
package DNS::LDNS::DNSSecTrustTree;
use 5.008008;
use strict;
use warnings;
use DNS::LDNS;
our $VERSION = '0.61';
sub add_parent {
my ($self, $parent, $sig, $parent_status) = @_;
if (DNS::LDNS::GC::is_owned($parent)) {
die "Cannot add to multiple trees.";
}
my $s = _add_parent($self, $parent, $sig, $parent_status);
DNS::LDNS::GC::own($parent, $self);
$DNS::LDNS::last_status = $s;
return $s;
}
sub contains_keys {
my ($self, $trusted_keys) = @_;
my $s = _contains_keys($self, $trusted_keys);
$DNS::LDNS::last_status = $s;
return $s;
}
sub rr {
my $self = shift;
return DNS::LDNS::GC::own($self->_rr, $self);
}
sub rrset {
my $self = shift;
return DNS::LDNS::GC::own($self->_rrset, $self);
}
sub parent {
my ($self, $i) = @_;
return DNS::LDNS::GC::own($self->_parent($i), $self);
}
sub parent_status {
my ($self, $i) = @_;
my $s = _parent_status($self, $i);
$DNS::LDNS::last_status = $s;
return $s;
}
sub parent_signature {
my ($self, $i) = @_;
return DNS::LDNS::GC::own($self->_parent_signature($i), $self);
}
1;
__END__
=head1 NAME
DNS::LDNS::DNSSecTrustTree - Trust tree from signed RR to trust anchors
=head1 SYNOPSIS
use DNS::LDNS ':all'
tree = new DNS::LDNS::DNSSecTrustTree
tree->print(fp)
d = tree->depth
status = tree->add_parent(parent, sig, parent_status)
status = tree->contains_keys(trusted_keys)
# Node attributes
rr = tree->rr;
rrset = tree->rrset
ptree = tree->parent(i)
pstatus = tree->parent_status(i)
rr = tree->parent_signature(i)
count = tree->parent_count
=head1 SEE ALSO
http://www.nlnetlabs.nl/projects/ldns
=head1 AUTHOR
Erik Pihl Ostlyngen, E<lt>erik.ostlyngen@uninett.noE<gt>
=head1 COPYRIGHT AND LICENSE
Copyright (C) 2013 by UNINETT Norid AS
This library is free software; you can redistribute it and/or modify
it under the same terms as Perl itself, either Perl version 5.14.2 or,
at your option, any later version of Perl 5 you may have available.
=cut

176
zonemaster-ldns/ldns/contrib/DNS-LDNS/lib/DNS/LDNS/DNSSecZone.pm Normal file
View File

@@ -0,0 +1,176 @@
package DNS::LDNS::DNSSecZone;
use 5.008008;
use strict;
use warnings;
use DNS::LDNS ':all';
our $VERSION = '0.61';
sub new {
my ($class, %args) = @_;
my $line_nr;
my $status = &LDNS_STATUS_OK;
my $zone;
my $file;
if ($args{filename}) {
unless (open FILE, $args{filename}) {
$DNS::LDNS::last_status = &LDNS_STATUS_FILE_ERR;
$DNS::LDNS::line_nr = 0;
return;
}
$file = \*FILE;
}
elsif ($args{file}) {
$file = $args{file};
}
if ($file) {
$zone = _new_from_file($file,
$args{origin},
$args{ttl} || 0,
$args{class} || 0,
$status, $line_nr);
}
else {
$zone = _new();
}
if ($args{filename}) {
close $file;
}
$DNS::LDNS::last_status = $status;
$DNS::LDNS::line_nr = $line_nr;
if (!defined $zone) {
return;
}
return $zone;
}
sub soa {
my $self = shift;
return DNS::LDNS::GC::own($self->_soa, $self);
}
sub names {
my $self = shift;
return DNS::LDNS::GC::own($self->_names, $self);
}
sub find_rrset {
my ($self, $name, $type) = @_;
return DNS::LDNS::GC::own($self->_find_rrset($name, $type), $self);
}
sub add_rr {
my ($self, $rr) = @_;
# Set a copy of the rr in case it is already owned
my $s = _add_rr($self, my $copy = $rr->clone);
$DNS::LDNS::last_status = $s;
DNS::LDNS::GC::own($copy, $self);
return $s;
}
sub add_empty_nonterminals {
my $self = shift;
my $s = _add_empty_nonterminals($self);
$DNS::LDNS::last_status = $s;
return $s;
}
sub mark_glue {
my $self = shift;
my $s = _mark_glue($self);
$DNS::LDNS::last_status = $s;
return $s;
}
sub sign {
my ($self, $keylist, $policy, $flags) = @_;
my $s = _sign($self, $keylist, $policy, $flags);
$DNS::LDNS::last_status = $s;
return $s;
}
sub sign_nsec3 {
my ($self, $keylist, $policy, $algorithm, $flags, $iterations, $salt,
$signflags) = @_;
my $s = _sign_nsec3($self, $keylist, $policy, $algorithm, $flags,
$iterations, $salt, $signflags);
$DNS::LDNS::last_status = $s;
return $s;
}
sub to_string {
return "DNS::LDNS::DNSSecZone::to_string is not yet implemented";
}
sub DESTROY {
DNS::LDNS::GC::free($_[0]);
}
1;
__END__
=head1 NAME
DNS::LDNS::DNSSecZone - Zone with dnssec data
=head1 SYNOPSIS
use DNS::LDNS ':all'
my z = new DNS::LDNS::DNSSecZone(
filename => '/path/to/myzone',
origin => new DNS::LDNS::RData(LDNS_RDF_TYPE_DNAME, 'myzone'), #optional
ttl => 3600, #optional
class => LDNS_RR_CLASS_, #optional
)
my z = new DNS::LDNS::DNSSecZone(
file => \*FILE,
origin => ..., ttl => ..., class => ...
)
my z = new DNS::LDNS::DNSSecZone
rr = z->soa
rbtree = z->names
rrsets = z->find_rrset
z->add_rr(rr)
z->create_from_zone(zone)
z->add_empty_nonterminals
z->sign(keylist, policy)
z->sign_nsec3(keylist, policy, algorithm, flags, iterations, salt)
z->create_nsecs
z->create_nsec3s(algorithm, flags, iterations, salt)
z->create_rrsigs(key_list, policy, flags)
=head1 TODO
z->to_string
=head1 SEE ALSO
http://www.nlnetlabs.nl/projects/ldns
=head1 AUTHOR
Erik Pihl Ostlyngen, E<lt>erik.ostlyngen@uninett.noE<gt>
=head1 COPYRIGHT AND LICENSE
Copyright (C) 2013 by UNINETT Norid AS
This library is free software; you can redistribute it and/or modify
it under the same terms as Perl itself, either Perl version 5.14.2 or,
at your option, any later version of Perl 5 you may have available.
=cut

122
zonemaster-ldns/ldns/contrib/DNS-LDNS/lib/DNS/LDNS/GC.pm Normal file
View File

@@ -0,0 +1,122 @@
package DNS::LDNS::GC;
use strict;
use warnings;
our $VERSION = '0.61';
my %ref_count;
my %owned_by;
sub own {
my ($obj, $owner) = @_;
# print STDERR "Owning $obj -> $owner\n";
return unless (defined $obj);
if ($owned_by{$$owner}) {
# If the owner is an owned object, let obj be owned by
# the owners owner. We want to avoid recursive ownerships.
$owner = $owned_by{$$owner};
}
if (exists $owned_by{$$obj}) {
$ref_count{$$obj}++;
}
else {
$ref_count{$$obj} = 1;
$owned_by{$$obj} = $owner;
}
return $obj;
}
# Return true if the object is owned by someone
sub is_owned {
return (exists $owned_by{${$_[0]}});
}
sub owner {
return $owned_by{${$_[0]}};
}
sub disown {
return unless (defined $_[0]);
delete $owned_by{${$_[0]}};
}
my %free_method = (
'DNS::LDNS::Zone' => '_zone_deep_free',
'DNS::LDNS::RRList' => '_rrlist_deep_free',
'DNS::LDNS::RR' => '_rr_free',
'DNS::LDNS::RData' => '_rdata_deep_free',
'DNS::LDNS::DNSSecZone' => '_dnssec_zone_deep_free',
'DNS::LDNS::DNSSecName' => '_dnssec_name_deep_free',
'DNS::LDNS::Resolver' => '_resolver_deep_free',
'DNS::LDNS::Packet' => '_packet_free',
'DNS::LDNS::Key' => '_key_deep_free',
'DNS::LDNS::KeyList' => '_keylist_free',
'DNS::LDNS::DNSSecDataChain' => '_dnssec_datachain',
);
my %not_deleted_by_owner = (
'DNS::LDNS::DNSSecTrustChain' => 1,
);
sub free {
my $obj = shift;
# print STDERR "Freeing $obj\n";
if (exists $ref_count{$$obj}) {
# print STDERR "Derefing $obj\n";
$ref_count{$$obj}--;
return if ($ref_count{$$obj} > 0);
}
# print STDERR "Deleting $obj\n";
delete $ref_count{$$obj};
if (exists $owned_by{$$obj}) {
delete $owned_by{$$obj};
return unless ($not_deleted_by_owner{ref $obj});
}
my $class = ref $obj;
my $free = $free_method{ref $obj};
die "Internal error: No freeing method for $obj (".ref $obj.")"
unless ($free);
no strict;
&$free($obj);
}
1;
__END__
=head1 NAME
DNS::LDNS::GC - Garbage collector, used internally by the DNS::LDNS modules
=head1 SYNOPSIS
Garbage collector class for DNS::LDNS objects.
=head1 SEE ALSO
http://www.nlnetlabs.nl/projects/ldns
=head1 AUTHOR
Erik Pihl Ostlyngen, E<lt>erik.ostlyngen@uninett.noE<gt>
=head1 COPYRIGHT AND LICENSE
Copyright (C) 2013 by UNINETT Norid AS
This library is free software; you can redistribute it and/or modify
it under the same terms as Perl itself, either Perl version 5.14.2 or,
at your option, any later version of Perl 5 you may have available.
=cut

122
zonemaster-ldns/ldns/contrib/DNS-LDNS/lib/DNS/LDNS/Key.pm Normal file
View File

@@ -0,0 +1,122 @@
package DNS::LDNS::Key;
use 5.008008;
use strict;
use warnings;
use DNS::LDNS ':all';
our $VERSION = '0.61';
sub new {
my ($class, %args) = @_;
my $key;
if ($args{filename} or $args{file}) {
my $status = &LDNS_STATUS_OK;
my $line_nr = 0;
my $file = $args{file};
if ($args{filename}) {
unless (open FILE, $args{filename}) {
$DNS::LDNS::last_status = &LDNS_STATUS_FILE_ERR;
return;
}
$file = \*FILE;
}
$key = _new_from_file($file, $line_nr, $status);
if ($args{filename}) {
close $file;
}
$DNS::LDNS::last_status = $status;
$DNS::LDNS::line_nr = $line_nr;
if (!defined $key) {
return;
}
}
else {
$key = _new();
}
return $key;
}
sub set_pubkey_owner {
my ($self, $owner) = @_;
my $oldowner = $self->pubkey_owner;
DNS::LDNS::GC::disown(my $old = $self->pubkey_owner);
$self->_set_pubkey_owner($owner);
return DNS::LDNS::GC::own($owner, $self);
}
sub pubkey_owner {
my $self = shift;
return DNS::LDNS::GC::own($self->_pubkey_owner, $self);
}
sub DESTROY {
DNS::LDNS::GC::free($_[0]);
}
1;
__END__
=head1 NAME
DNS::LDNS::Key - DNSSec private key
=head1 SYNOPSIS
use DNS::LDNS ':all'
key = new DNS::LDNS::Key
key = new DNS::LDNS::Key(file => \*FILE)
key = new DNS::LDNS::Key(filename => 'keyfile')
str = key->to_string
key->print(\*OUTPUT)
key->set_algorithm(alg)
alg = key->algorithm
key->set_flags(flags)
flags = key->flags
key->set_hmac_key(hmac)
hmac = key->hmac_key
key->set_hmac_size(size)
size = key->hmac_size
key->set_origttl(ttl)
ttl = key->origttl
key->set_inception(epoch)
epoch = key->inception
key->set_expiration(epoch)
epoch = key->expiration
key->set_pubkey_owner(rdata)
rdata = key->pubkey_owner
key->set_keytag(tag)
tag = key->keytag
key->set_use(bool)
bool = key->use
str = key->get_file_base_name
rr = key->to_rr
=head1 SEE ALSO
http://www.nlnetlabs.nl/projects/ldns
=head1 AUTHOR
Erik Pihl Ostlyngen, E<lt>erik.ostlyngen@uninett.noE<gt>
=head1 COPYRIGHT AND LICENSE
Copyright (C) 2013 by UNINETT Norid AS
This library is free software; you can redistribute it and/or modify
it under the same terms as Perl itself, either Perl version 5.14.2 or,
at your option, any later version of Perl 5 you may have available.
=cut

72
zonemaster-ldns/ldns/contrib/DNS-LDNS/lib/DNS/LDNS/KeyList.pm Normal file
View File

@@ -0,0 +1,72 @@
package DNS::LDNS::KeyList;
use 5.008008;
use strict;
use warnings;
use DNS::LDNS ':all';
our $VERSION = '0.61';
sub new {
my $class = shift;
return _new();
}
sub push {
my ($self, @keys) = @_;
for my $k (@keys) {
if (DNS::LDNS::GC::is_owned($k)) {
die "Cannot push a key on multiple lists.";
}
$self->_push($k);
DNS::LDNS::GC::own($k, $self);
}
}
sub key {
my ($self, $index) = @_;
return DNS::LDNS::GC::own($self->_key($index), $self);
}
sub DESTROY {
DNS::LDNS::GC::free($_[0]);
}
1;
__END__
=head1 NAME
DNS::LDNS::KeyList - Linked list of dnssec keys
=head1 SYNOPSIS
use DNS::LDNS ':all'
my l = new DNS::LDNS::KeyList
l->set_use(bool)
l->push(@keys)
key = l->pop
c = l->count
key = l->key(index)
=head1 SEE ALSO
http://www.nlnetlabs.nl/projects/ldns
=head1 AUTHOR
Erik Pihl Ostlyngen, E<lt>erik.ostlyngen@uninett.noE<gt>
=head1 COPYRIGHT AND LICENSE
Copyright (C) 2013 by UNINETT Norid AS
This library is free software; you can redistribute it and/or modify
it under the same terms as Perl itself, either Perl version 5.14.2 or,
at your option, any later version of Perl 5 you may have available.
=cut

259
zonemaster-ldns/ldns/contrib/DNS-LDNS/lib/DNS/LDNS/Packet.pm Normal file
View File

@@ -0,0 +1,259 @@
package DNS::LDNS::Packet;
use 5.008008;
use strict;
use warnings;
use DNS::LDNS;
our $VERSION = '0.61';
sub new {
my ($class, %args) = @_;
if ($args{name}) {
return _query_new(
$args{name}, $args{type}, $args{class}, $args{flags});
}
else {
return _new;
}
}
sub question {
my $self = shift;
return DNS::LDNS::GC::own($self->_question, $self);
}
sub set_question {
my ($self, $l) = @_;
DNS::LDNS::GC::disown(my $old = $self->question);
$self->_set_question($l);
return DNS::LDNS::GC::own($l, $self);
}
sub answer {
my $self = shift;
return DNS::LDNS::GC::own($self->_answer, $self);
}
sub set_answer {
my ($self, $l) = @_;
DNS::LDNS::GC::disown(my $old = $self->answer);
$self->_set_answer($l);
return DNS::LDNS::GC::own($l, $self);
}
sub authority {
my $self = shift;
return DNS::LDNS::GC::own($self->_authority, $self);
}
sub set_authority {
my ($self, $l) = @_;
DNS::LDNS::GC::disown(my $old = $self->authority);
$self->_set_authority($l);
return DNS::LDNS::GC::own($l, $self);
}
sub additional {
my $self = shift;
return DNS::LDNS::GC::own($self->_additional, $self);
}
sub set_additional {
my ($self, $l) = @_;
DNS::LDNS::GC::disown(my $old = $self->additional);
$self->_set_additional($l);
return DNS::LDNS::GC::own($l, $self);
}
sub answerfrom {
my $self = shift;
return DNS::LDNS::GC::own($self->_answerfrom, $self);
}
sub set_answerfrom {
my ($self, $a) = @_;
DNS::LDNS::GC::disown(my $old = $self->answerfrom);
$self->_set_answerfrom($a);
return DNS::LDNS::GC::own($a, $self);
}
sub timestamp {
my $self = shift;
my $t = _timestamp($self);
return wantarray ? @$t : $t;
}
sub edns_data {
my $self = shift;
return DNS::LDNS::GC::own($self->_edns_data, $self);
}
sub set_edns_data {
my ($self, $data) = @_;
DNS::LDNS::GC::disown(my $old = $self->edns_data);
$self->_set_edns_data($data);
return DNS::LDNS::GC::own($data, $self);
}
sub push_rr {
my ($self, $sec, $rr) = @_;
my $ret = $self->_push_rr($sec, my $copy = $_->clone);
DNS::LDNS::GC::own($copy, $self);
return $ret;
}
sub safe_push_rr {
my ($self, $sec, $rr) = @_;
my $ret = $self->_safe_push_rr($sec, my $copy = $_->clone);
if ($ret) {
DNS::LDNS::GC::own($copy, $self);
}
return $ret;
}
sub tsig {
my $self = shift;
return DNS::LDNS::GC::own($self->_tsig, $self);
}
sub set_tsig {
my ($self, $rr) = @_;
DNS::LDNS::GC::disown(my $old = $self->tsig);
$self->_set_tsig($rr);
return DNS::LDNS::GC::own($rr, $self);
}
sub DESTROY {
DNS::LDNS::GC::free($_[0]);
}
1;
__END__
=head1 NAME
DNS::LDNS::Packet - DNS packet
=head1 SYNOPSIS
use DNS::LDNS ':all'
my pkt = new DNS::LDNS::Packet(name => rdata, type => LDNS_RR_TYPE_...,
class => LDNS_RR_CLASS_..., flags => ...)
my pkt = new DNS::LDNS::Packet
pkt2 = pkt->clone
pkt->to_string
rrlist = pkt->question
pkt->set_question(rrlist)
'
rrlist = pkt->answer
pkt->set_answer(rrlist)
rrlist = pkt->authority
pkt->set_authority(rrlist)
rrlist = pkt->additional
pkt->set_additional(rrlist)
rrlist = pkt->all
rrlist = pkt->all_noquestion
for (qw/qr aa tc rd cd ra ad/) {
bool = pkt->$_
pkt->set_$_(bool)
}
id = pkt->id
pkt->set_id(id)
pkt->set_random_id
count = pkt->qdcount
count = pkt->ancount
count = pkt->nscount
count = pkt->arcount
opcode = pkt->opcode
pkt->set_opcode(opcode)
rcode = pkt->rcode # Response code
pkt->set_rcode(rcode)
size = pkt->size
epoch = pkt->querytime
pkt->set_querytime(epoch)
rdata = pkt->answerfrom
pkt->set_answerfrom(rdata)
(sec, usec) = pkt->timestamp
pkt->set_timestamp(sec, usec)
bool = pkt->edns
size = pkt->edns_udp_size
pkt->set_edns_udp_size(size)
rcode = pkt->edns_extended_rcode
pkt->set_edns_extended_rcode(rcode)
v = pkt->edns_version
pkt->set_edns_version(v)
z = pkt->edns_z
pkt->set_edns_z(z)
do = pkt->edns_do
pkt->set_edns_do(do)
rdata = pkt->edns_data
pkt->set_edns_data(rdata)
pkt->set_flags(flags)
rrlist = pkt->rr_list_by_name(rdata, section)
rrlist = pkt->rr_list_by_type(type, section)
rrlist = pkt->rr_list_by_name_and_type(rdata, type, section)
bool = pkt->rr(section, rr) # Check if rr exists
pkt->push_rr(section, rr)
pkt->safe_push_rr(section, rr)
count = pkt->section_count(section)
bool = pkt->empty
rr = pkt->tsig
pkt->set_tsig(rr)
type = pkt->reply_type
rrlist = pkt->get_rrsigs_for_name_and_type(rdata, rrtype)
rrlist = pkt->get_rrsigs_for_type(rrtype)
=head1 SEE ALSO
http://www.nlnetlabs.nl/projects/ldns
=head1 AUTHOR
Erik Pihl Ostlyngen, E<lt>erik.ostlyngen@uninett.noE<gt>
=head1 COPYRIGHT AND LICENSE
Copyright (C) 2013 by UNINETT Norid AS
This library is free software; you can redistribute it and/or modify
it under the same terms as Perl itself, either Perl version 5.14.2 or,
at your option, any later version of Perl 5 you may have available.
=cut

71
zonemaster-ldns/ldns/contrib/DNS-LDNS/lib/DNS/LDNS/RBNode.pm Normal file
View File

@@ -0,0 +1,71 @@
package DNS::LDNS::RBNode;
use 5.008008;
use strict;
use warnings;
use DNS::LDNS;
our $VERSION = '0.61';
# Note: This class does not have a constructor. Thus, it can not be created
# as an individual object. The data structure of the object will always be
# owned and freed by its parent object.
sub next {
my $self = shift;
return DNS::LDNS::GC::own($self->_next, $self);
}
sub previous {
my $self = shift;
return DNS::LDNS::GC::own($self->_previous, $self);
}
sub next_nonglue {
my $self = shift;
return DNS::LDNS::GC::own($self->_next_nonglue, $self);
}
sub name {
my ($self) = @_;
return DNS::LDNS::GC::own($self->_name, $self);
}
sub DESTROY {
DNS::LDNS::GC::free($_[0]);
}
1;
__END__
=head1 NAME
DNS::LDNS::RBNode - Node in the RBTree
=head1 SYNOPSIS
use DNS::LDNS ':all'
node2 = node->next
node2 = node->next_nonglue
bool = node->is_null
dnssec_name = node->name
=head1 SEE ALSO
http://www.nlnetlabs.nl/projects/ldns
=head1 AUTHOR
Erik Pihl Ostlyngen, E<lt>erik.ostlyngen@uninett.noE<gt>
=head1 COPYRIGHT AND LICENSE
Copyright (C) 2013 by UNINETT Norid AS
This library is free software; you can redistribute it and/or modify
it under the same terms as Perl itself, either Perl version 5.14.2 or,
at your option, any later version of Perl 5 you may have available.
=cut

59
zonemaster-ldns/ldns/contrib/DNS-LDNS/lib/DNS/LDNS/RBTree.pm Normal file
View File

@@ -0,0 +1,59 @@
package DNS::LDNS::RBTree;
use 5.008008;
use strict;
use warnings;
use DNS::LDNS;
our $VERSION = '0.61';
# Note: Since this class does not have a constructor, we can let its child
# objects be owned by the parent. This reduces the recursion depth on
# DESTROY.
sub first {
my $self = shift;
return DNS::LDNS::GC::own($self->_first, $self);
}
sub last {
my $self = shift;
return DNS::LDNS::GC::own($self->_last, $self);
}
sub DESTROY {
DNS::LDNS::GC::free($_[0]);
}
1;
__END__
=head1 NAME
DNS::LDNS::RBTree - Tree of DNSSecName nodes
=head1 SYNOPSIS
use DNS::LDNS ':all'
rbnode = rbtree->first
rbnode = rbtree->last
=head1 SEE ALSO
http://www.nlnetlabs.nl/projects/ldns
=head1 AUTHOR
Erik Pihl Ostlyngen, E<lt>erik.ostlyngen@uninett.noE<gt>
=head1 COPYRIGHT AND LICENSE
Copyright (C) 2013 by UNINETT Norid AS
This library is free software; you can redistribute it and/or modify
it under the same terms as Perl itself, either Perl version 5.14.2 or,
at your option, any later version of Perl 5 you may have available.
=cut

91
zonemaster-ldns/ldns/contrib/DNS-LDNS/lib/DNS/LDNS/RData.pm Normal file
View File

@@ -0,0 +1,91 @@
package DNS::LDNS::RData;
use 5.008008;
use strict;
use warnings;
use DNS::LDNS;
our $VERSION = '0.61';
sub new {
my ($class, $type, $str) = @_;
return _new($type, $str);
}
sub cat {
my ($self, $other) = @_;
my $s = _cat($self, $other);
$DNS::LDNS::last_status = $s;
return $s;
}
sub nsec3_hash_name {
my ($self, $algorithm, $iterations, $salt) = @_;
return DNS::LDNS::GC::own(
$self->_nsec3_hash_name($algorithm, $iterations, $salt), $self);
}
sub DESTROY {
DNS::LDNS::GC::free($_[0]);
}
1;
__END__
=head1 NAME
DNS::LDNS::RData - Rdata field or a dname in an rr
=head1 SYNOPSIS
use DNS::LDNS ':all'
my rd = new DNS::LDNS::RData(rdf_type, str)
rd2 = rd->clone
rdf_type = rd->type
rd->set_type(rdf_type)
rd->print(\*FILE)
str = rd->to_string
count = rd->label_count
rd2 = rd->label(pos)
bool = rd->is_wildcard
bool = rd->matches_wildcard(wildcard)
bool = rd->is_subdomain(parent)
rd2 = rd->left_chop
status = rd->cat(rd2)
rd->compare(rd2)
rd2 = rd->address_reverse
rd2 = rd->dname_reverse
rd2 = rd->nsec3_hash_name(name, algorithm, iterations, salt)
epoch = rd->to_unix_time
( epoch = rd->2native_time_t )
rr_type = rd->to_rr_type
=head1 SEE ALSO
http://www.nlnetlabs.nl/projects/ldns
=head1 AUTHOR
Erik Pihl Ostlyngen, E<lt>erik.ostlyngen@uninett.noE<gt>
=head1 COPYRIGHT AND LICENSE
Copyright (C) 2013 by UNINETT Norid AS
This library is free software; you can redistribute it and/or modify
it under the same terms as Perl itself, either Perl version 5.14.2 or,
at your option, any later version of Perl 5 you may have available.
=cut

493
zonemaster-ldns/ldns/contrib/DNS-LDNS/lib/DNS/LDNS/RR.pm Normal file
View File

@@ -0,0 +1,493 @@
package DNS::LDNS::RR;
use 5.008008;
use strict;
use warnings;
use DNS::LDNS ':all';
our $VERSION = '0.61';
sub new {
my $class = shift;
my $rr;
my $status = &LDNS_STATUS_OK;
if (scalar(@_) == 0) {
$rr = _new;
}
elsif (scalar(@_) == 1) {
$rr = _new_from_str($_[0], 0,
undef, undef,
$status);
}
else {
my %args = @_;
# Perl 5.25 does not allow us to pass read-only undef into a
# parameter changing function. So we must send it with a variable.
my $undef = undef;
if ($args{str}) {
$rr = _new_from_str($args{str},
$args{default_ttl} || 0,
$args{origin},
$args{prev} ? ${$args{prev}} : $undef,
$status);
}
elsif ($args{filename} or $args{file}) {
my $line_nr = 0;
my $file = $args{file};
if ($args{filename}) {
unless (open FILE, $args{filename}) {
$DNS::LDNS::last_status = &LDNS_STATUS_FILE_ERR;
$DNS::LDNS::line_nr = 0;
return;
}
$file = \*FILE;
}
my $ttl = 0;
$rr = _new_from_file($file,
$args{default_ttl} ? ${$args{default_ttl}} : $ttl,
$args{origin} ? ${$args{origin}} : $undef,
$args{prev} ? ${$args{prev}} : $undef,
$status,
$line_nr);
if ($args{filename}) {
close $file;
}
$DNS::LDNS::line_nr = $line_nr;
}
elsif ($args{type}) {
$rr = _new_from_type($args{type});
if ($args{owner}) {
$rr->set_owner(ref $args{owner} ? $args{owner} :
new DNS::LDNS::RData(&LDNS_RDF_TYPE_DNAME, $args{owner}));
}
$rr->set_ttl($args{ttl}) if ($args{ttl});
$rr->set_class($args{class}) if ($args{class});
if ($args{rdata}) {
if (!$rr->set_rdata(@{$args{rdata}})) {
$DNS::LDNS::last_status = &LDNS_STATUS_SYNTAX_RDATA_ERR;
return;
}
}
}
}
if (!defined $rr) {
$DNS::LDNS::last_status = $status;
return;
}
return $rr;
}
sub owner {
my $self = shift;
return DNS::LDNS::GC::own($self->_owner, $self);
}
sub set_owner {
my ($self, $owner) = @_;
DNS::LDNS::GC::disown(my $old = $self->owner);
$self->_set_owner($owner);
return DNS::LDNS::GC::own($owner, $self);
}
sub dname {
return $_[0]->owner->to_string;
}
sub rdata {
my ($self, $index) = @_;
return DNS::LDNS::GC::own($self->_rdata($index), $self);
}
# replace all existing rdata with new ones. Requires the
# input array to be exactly same length as rd_count
sub set_rdata {
my ($self, @rdata) = @_;
if (scalar @rdata != $self->rd_count) {
# Hopefully this is a proper error to return here...
$DNS::LDNS::last_status = LDNS_STATUS_SYNTAX_RDATA_ERR;
return;
}
my $i = 0;
for (@rdata) {
my $oldrd = _set_rdata($self, my $copy = $_->clone, $i);
DNS::LDNS::GC::disown(my $old = $oldrd);
DNS::LDNS::GC::own($copy, $self);
$i++;
}
return 1;
}
sub push_rdata {
my ($self, @rdata) = @_;
for (@rdata) {
# Push a copy in case the input rdata are already owned
$self->_push_rdata(my $copy = $_->clone);
DNS::LDNS::GC::own($copy, $self);
}
}
sub rrsig_typecovered {
my $self = shift;
return DNS::LDNS::GC::own($self->_rrsig_typecovered, $self);
}
sub rrsig_set_typecovered {
my ($self, $type) = shift;
DNS::LDNS::GC::disown(my $old = $self->rrsig_typecovered);
my $result = $self->_rrsig_set_typecovered(my $copy = $type->clone);
DNS::LDNS::GC::own($copy, $self);
return $result;
}
sub rrsig_algorithm {
my $self = shift;
return DNS::LDNS::GC::own($self->_rrsig_algorithm, $self);
}
sub rrsig_set_algorithm {
my ($self, $algo) = shift;
DNS::LDNS::GC::disown(my $old = $self->rrsig_algorithm);
my $result = $self->_rrsig_set_algorithm(my $copy = $algo->clone);
DNS::LDNS::GC::own($copy, $self);
return $result;
}
sub rrsig_expiration {
my $self = shift;
return DNS::LDNS::GC::own($self->_rrsig_expiration, $self);
}
sub rrsig_set_expiration {
my ($self, $date) = shift;
DNS::LDNS::GC::disown(my $old = $self->rrsig_expiration);
my $result = $self->_rrsig_set_expiration(my $copy = $date->clone);
DNS::LDNS::GC::own($copy, $self);
return $result;
}
sub rrsig_inception {
my $self = shift;
return DNS::LDNS::GC::own($self->_rrsig_inception, $self);
}
sub rrsig_set_inception {
my ($self, $date) = shift;
DNS::LDNS::GC::disown(my $old = $self->rrsig_inception);
my $result = $self->_rrsig_set_inception(my $copy = $date->clone);
DNS::LDNS::GC::own($copy, $self);
return $result;
}
sub rrsig_keytag {
my $self = shift;
return DNS::LDNS::GC::own($self->_rrsig_keytag, $self);
}
sub rrsig_set_keytag {
my ($self, $tag) = shift;
DNS::LDNS::GC::disown(my $old = $self->rrsig_keytag);
my $result = $self->_rrsig_set_keytag(my $copy = $tag->clone);
DNS::LDNS::GC::own($copy, $self);
return $result;
}
sub rrsig_sig {
my $self = shift;
return DNS::LDNS::GC::own($self->_rrsig_sig, $self);
}
sub rrsig_set_sig {
my ($self, $sig) = shift;
DNS::LDNS::GC::disown(my $old = $self->rrsig_sig);
my $result = $self->_rrsig_set_sig(my $copy = $sig->clone);
DNS::LDNS::GC::own($copy, $self);
return $result;
}
sub rrsig_labels {
my $self = shift;
return DNS::LDNS::GC::own($self->_rrsig_labels, $self);
}
sub rrsig_set_labels {
my ($self, $lab) = shift;
DNS::LDNS::GC::disown(my $old = $self->rrsig_labels);
my $result = $self->_rrsig_set_labels(my $copy = $lab->clone);
DNS::LDNS::GC::own($copy, $self);
return $result;
}
sub rrsig_origttl {
my $self = shift;
return DNS::LDNS::GC::own($self->_rrsig_origttl, $self);
}
sub rrsig_set_origttl {
my ($self, $ttl) = shift;
DNS::LDNS::GC::disown(my $old = $self->rrsig_origttl);
my $result = $self->_rrsig_set_origttl(my $copy = $ttl->clone);
DNS::LDNS::GC::own($copy, $self);
return $result;
}
sub rrsig_signame {
my $self = shift;
return DNS::LDNS::GC::own($self->_rrsig_signame, $self);
}
sub rrsig_set_signame {
my ($self, $name) = shift;
DNS::LDNS::GC::disown(my $old = $self->rrsig_signame);
my $result = $self->_rrsig_set_signame(my $copy = $name->clone);
DNS::LDNS::GC::own($copy, $self);
return $result;
}
sub dnskey_algorithm {
my $self = shift;
return DNS::LDNS::GC::own($self->_dnskey_algorithm, $self);
}
sub dnskey_set_algorithm {
my ($self, $algo) = shift;
DNS::LDNS::GC::disown(my $old = $self->dnskey_algorithm);
my $result = $self->_dnskey_set_algorithm(my $copy = $algo->clone);
DNS::LDNS::GC::own($copy, $self);
return $result;
}
sub dnskey_flags {
my $self = shift;
return DNS::LDNS::GC::own($self->_dnskey_flags, $self);
}
sub dnskey_set_flags {
my ($self, $flags) = shift;
DNS::LDNS::GC::disown(my $old = $self->flags);
my $result = $self->_dnskey_set_flags(my $copy = $flags->clone);
DNS::LDNS::GC::own($copy, $self);
return $result;
}
sub dnskey_protocol {
my $self = shift;
return DNS::LDNS::GC::own($self->_dnskey_protocol, $self);
}
sub dnskey_set_protocol {
my ($self, $proto) = shift;
DNS::LDNS::GC::disown(my $old = $self->dnskey_protocol);
my $result = $self->_dnskey_set_protocol(my $copy = $proto->clone);
DNS::LDNS::GC::own($copy, $self);
return $result;
}
sub dnskey_key {
my $self = shift;
return DNS::LDNS::GC::own($self->_dnskey_key, $self);
}
sub dnskey_set_key {
my ($self, $key) = shift;
DNS::LDNS::GC::disown(my $old = $self->dnskey_key);
my $result = $self->_dnskey_set_key(my $copy = $key->clone);
DNS::LDNS::GC::own($copy, $self);
return $result;
}
sub nsec3_next_owner {
my $self = shift;
return DNS::LDNS::GC::own($self->_nsec3_next_owner, $self);
}
sub nsec3_bitmap {
my $self = shift;
return DNS::LDNS::GC::own($self->_nsec3_bitmap, $self);
}
sub nsec3_salt {
my $self = shift;
return DNS::LDNS::GC::own($self->_nsec3_salt, $self);
}
sub hash_name_from_nsec3 {
my ($self, $name) = @_;
my $hash = $self->_hash_name_from_nsec3($name);
return DNS::LDNS::GC::own($self->_hash_name_from_nsec3($name), $self);
}
sub verify_denial {
my ($self, $nsecs, $rrsigs) = @_;
my $s = _verify_denial($self, $nsecs, $rrsigs);
$DNS::LDNS::last_status = $s;
return $s;
}
sub verify_denial_nsec3 {
my ($self, $nsecs, $rrsigs, $packet_rcode, $packet_qtype,
$packet_nodata) = @_;
my $s = _verify_denial_nsec3($self, $nsecs, $rrsigs, $packet_rcode,
$packet_qtype, $packet_nodata);
$DNS::LDNS::last_status = $s;
return $s;
}
sub verify_denial_nsec3_match {
my ($self, $nsecs, $rrsigs, $packet_rcode, $packet_qtype,
$packet_nodata) = @_;
my $status;
my $match = _verify_denial_nsec3_match($self, $nsecs, $rrsigs, $packet_rcode, $packet_qtype, $packet_nodata, $status);
$DNS::LDNS::last_status = $status;
if ($status != &LDNS_STATUS_OK) {
return;
}
# $match is an RR owned by the $nsecs list.
return DNS::LDNS::GC::own($match, $nsecs);
}
sub DESTROY {
DNS::LDNS::GC::free($_[0]);
}
1;
__END__
=head1 NAME
DNS::LDNS::RR - Resource record
=head1 SYNOPSIS
use DNS::LDNS ':all'
my rr = new DNS::LDNS::RR('mylabel 3600 IN A 168.10.10.10')
my rr = new DNS::LDNS::RR(
str => 'mylabel 3600 IN A 168.10.10.10',
default_ttl => 3600, # optional
origin => $origin_rdata, # optional
prev => \$prev_rdata, # optional
)
my rr = new DNS::LDNS::RR(
filename => '/path/to/rr',
default_ttl => \$ttl, # optional
origin => \$origin_rdata, # optional
prev => \$prev_rdata) # optional
my rr = new DNS::LDNS::RR(
file => \*FILE,
default_ttl => \$ttl, # optional
origin => \$origin_rdata, # optional
prev => \$prev_rdata) # optional
my rr = new DNS::LDNS::RR(
type => LDNS_RR_TYPE_A,
rdata => [new DNS::LDNS::RData(...), new DNS::LDNS::RData(...), ...],
class => LDNS_RR_CLASS_IN, # optional
ttl => 3600, # optional
owner => new DNS::LDNS::RData(LDNS_RDF_TYPE_DNAME, 'mylabel'), # optional)
my rr = new DNS::LDNS::RR
rr2 = rr->clone
rr->print(\*FILE)
rr->to_string
ttl = rr->ttl
rr->set_ttl(ttl)
type = rr->type
rr->set_type(type)
class = rr->class
rr->set_class(class)
rdata = rr->owner
rr->set_owner(rdata)
str = rr->dname
count = rr->rd_count
rdata = rr->rdata(index)
rr->set_rdata(rd1, rd2, rd3, ...)
rr->push_rdata(rd1, rd2, rd3, ...)
rdata = rr->pop_rdata
rr->compare(rr2)
rr->compare_dname(rr2)
rr->compare_no_rdata(rr2)
rr->compare_ds(rr2)
hash = rr->hash_name_from_nsec3(dname)
status = rr->verify_denial(nsecs, rrsigs)
status = rr->verify_denial_nsec3(nsecs, rrsigs, packet_rcode, packet_qtype, packet_nodata)
match = rr->verify_denial_nsec3_match(nsecs, rrsigs, packet_rcode, packet_qtype, packet_nodata)
rr->nsec3_add_param_rdfs(algorithm, flags, iterations, salt)
a = rr->nsec3_algorithm
f = rr->nsec3_flags
o = rr->nsec3_optout
i = rr->nsec3_iterations
rdata = rr->nsec3_next_owner
rdata = rr->nsec3_bitmap
rdata = rr->nsec3_salt
rdata = rr->rrsig_keytag
bool = rr->rrsig_set_keytag(rdata)
rdata = rr->rrsig_signame
bool = rr->rrsig_set_signame(rdata)
rdata = rr->rrsig_sig
bool = rr->rrsig_set_sig(rdata)
rdata = rr->rrsig_algorithm
bool = rr->rrsig_set_algorithm(rdata)
rdata = rr->rrsig_inception
bool = rr->rrsig_set_inception(rdata)
rdata = rr->rrsig_expiration
bool = rr->rrsig_set_expiration(rdata)
rdata = rr->rrsig_labels
bool = rr->rrsig_set_labels(rdata)
rdata = rr->rrsig_origttl
bool = rr->rrsig_set_origttl(rdata)
key = rr->get_dnskey_for_rrsig(rrlist)
rdata = rr->dnskey_algorithm
bool = rr->dnskey_set_algorithm(rdata)
rdata = rr->dnskey_flags
bool = rr->dnskey_set_flags(rdata)
rdata = rr->dnskey_protocol
bool = rr->dnskey_set_protocol(rdata)
rdata = rr->dnskey_key
bool = rr->dnskey_set_key(rdata)
bits = rr->dnskey_key_size
tag = rr->calc_keytag
ds = rr->key_to_ds(hash)
rr->is_question
=head1 SEE ALSO
http://www.nlnetlabs.nl/projects/ldns
=head1 AUTHOR
Erik Pihl Ostlyngen, E<lt>erik.ostlyngen@uninett.noE<gt>
=head1 COPYRIGHT AND LICENSE
Copyright (C) 2013 by UNINETT Norid AS
This library is free software; you can redistribute it and/or modify
it under the same terms as Perl itself, either Perl version 5.14.2 or,
at your option, any later version of Perl 5 you may have available.
=cut

183
zonemaster-ldns/ldns/contrib/DNS-LDNS/lib/DNS/LDNS/RRList.pm Normal file
View File

@@ -0,0 +1,183 @@
package DNS::LDNS::RRList;
use 5.008008;
use strict;
use warnings;
use DNS::LDNS;
our $VERSION = '0.61';
sub new {
my ($class, %args) = @_;
if ($args{hosts_filename} or $args{hosts_file}) {
my $file = $args{hosts_file};
if ($args{hosts_filename}) {
unless (open FILE, $args{hosts_filename}) {
$DNS::LDNS::last_status = &LDNS_STATUS_FILE_ERR;
$DNS::LDNS::line_nr = 0;
return;
}
$file = \*FILE;
}
my $list = _new_hosts_from_file($file, $DNS::LDNS::line_nr);
if ($args{hosts_filename}) {
close $file;
}
return $list;
}
return _new();
}
sub rr {
my ($self, $index) = @_;
return DNS::LDNS::GC::own($self->_rr($index), $self);
}
sub push {
my ($self, @rrs) = @_;
for my $rr (@rrs) {
# Push a copy of the rr in case it is already owned
$self->_push(my $copy = $rr->clone);
DNS::LDNS::GC::own($copy, $self);
}
}
sub push_list {
my ($self, $list) = @_;
$self->_push_list(my $copy = $list->clone);
DNS::LDNS::GC::own($copy, $self);
}
sub verify {
my ($self, $sig, $keys) = @_;
my $goodkeys = new DNS::LDNS::RRList;
my $s = _verify($self, $sig, $keys, $goodkeys);
$DNS::LDNS::last_status = $s;
return wantarray ? ($s, $goodkeys) : $s;
}
sub verify_time {
my ($self, $sig, $keys, $checktime) = @_;
my $goodkeys = new DNS::LDNS::RRList;
my $s = _verify_time($self, $sig, $keys, $checktime, $goodkeys);
$DNS::LDNS::last_status = $s;
return wantarray ? ($s, $goodkeys) : $s;
}
sub verify_notime {
my ($self, $sig, $keys) = @_;
my $goodkeys = new DNS::LDNS::RRList;
my $s = _verify_notime($self, $sig, $keys, $goodkeys);
$DNS::LDNS::last_status = $s;
return wantarray ? ($s, $goodkeys) : $s;
}
sub verify_rrsig_keylist {
my ($self, $sig, $keys) = @_;
my $goodkeys = new DNS::LDNS::RRList;
my $s = _verify_rrsig_keylist($self, $sig, $keys, $goodkeys);
$DNS::LDNS::last_status = $s;
return wantarray ? ($s, $goodkeys) : $s;
}
sub verify_rrsig_keylist_notime {
my ($self, $sig, $keys, $check_time) = @_;
my $goodkeys = new DNS::LDNS::RRList;
my $s = _verify_rrsig_keylist_notime($self, $sig, $keys, $goodkeys);
$DNS::LDNS::last_status = $s;
return wantarray ? ($s, $goodkeys) : $s;
}
sub get_dnskey_for_rrsig {
my ($self, $rrsig) = @_;
return DNS::LDNS::GC::own(_get_dnskey_for_rrsig($rrsig, $self), $self);
}
sub get_rrsig_for_name_and_type {
my ($self, $name, $type) = @_;
return DNS::LDNS::GC::own(
_get_dnskey_for_name_and_type($name, $type, $self), $self);
}
sub DESTROY {
DNS::LDNS::GC::free($_[0]);
}
1;
__END__
=head1 NAME
DNS::LDNS::RRList - List of rrs
=head1 SYNOPSIS
use DNS::LDNS ':all'
my l = new DNS::LDNS::RRList
my l = new DNS::LDNS::RRList(hosts_file => \*FILE)
my l = new DNS::LDNS::RRList(hosts_filename => fname)
my l2 = l->clone
l->to_string
l->print(\*FILE)
count = l->rr_count
rr = l->rr(index)
l->push(@rr)
rr = l->pop
l->push_list(l2)
l2 = l->pop_list(count)
l2 = l->pop_rrset
l->compare(l2)
l2 = l->subtype_by_rdata(rdata, pos)
bool = l->is_rrset
bool = l->contains_rr(rr)
(status, goodkeys) = l->verify(sig, keys)
(status, goodkeys) = l->verify_time(sig, keys, checktime)
(status, goodkeys) = l->verify_notime(sig, keys)
(status, goodkeys) = l->verify_rrsig_keylist(sig, keys)
(status, goodkeys) = l->verify_rrsig_keylist_time(sig, keys, checktime)
(status, goodkeys) = l->verify_rrsig_keylist_notime(sig, keys)
status = l->verify_rrsig(sig, keys)
status = l->verify_rrsig_time(sig, keys, checktime)
rr = l->create_empty_rrsig(key)
rrlist = l->sign_public(keylist)
rrlist->canonicalize
rrlist->sort
rrlist->sort_nsec3 # the list must contain only nsec3 rrs
rr = keylist->get_dnskey_for_rrsig(rrsig)
rr = keylist->get_rrsig_for_name_and_type(name, type)
=head1 SEE ALSO
http://www.nlnetlabs.nl/projects/ldns
=head1 AUTHOR
Erik Pihl Ostlyngen, E<lt>erik.ostlyngen@uninett.noE<gt>
=head1 COPYRIGHT AND LICENSE
Copyright (C) 2013 by UNINETT Norid AS
This library is free software; you can redistribute it and/or modify
it under the same terms as Perl itself, either Perl version 5.14.2 or,
at your option, any later version of Perl 5 you may have available.
=cut

355
zonemaster-ldns/ldns/contrib/DNS-LDNS/lib/DNS/LDNS/Resolver.pm Normal file
View File

@@ -0,0 +1,355 @@
package DNS::LDNS::Resolver;
use 5.008008;
use strict;
use warnings;
use DNS::LDNS ':all';
our $VERSION = '0.61';
sub new {
my ($class, %args) = @_;
my $file;
my $status = &LDNS_STATUS_OK;
if ($args{filename}) {
unless (open FILE, $args{filename}) {
$DNS::LDNS::last_status = &LDNS_STATUS_FILE_ERR;
$DNS::LDNS::line_nr = 0;
return;
}
$file = \*FILE;
}
elsif ($args{file}) {
$file = $args{file};
}
my $resolver;
if ($file) {
$resolver = _new_from_file($file, $status);
}
else {
$resolver = _new();
}
if ($args{filename}) {
close $file;
}
$DNS::LDNS::last_status = $status;
if (!defined $resolver) {
return;
}
return $resolver;
}
sub dnssec_anchors {
my $self = shift;
return DNS::LDNS::GC::own($self->_dnssec_anchors, $self);
}
sub push_dnssec_anchor {
my ($self, $rr) = @_;
_push_dnssec_anchor($self, my $copy = $rr->clone);
DNS::LDNS::GC::own($copy, $self);
}
sub set_dnssec_anchors {
my ($self, $l) = @_;
DNS::LDNS::GC::disown(my $old = $self->dnssec_anchors);
$self->_set_dnssec_anchors($l);
DNS::LDNS::GC::own($l, $self);
return $l;
}
sub domain {
my $self = shift;
return DNS::LDNS::GC::own($self->_domain, $self);
}
sub set_domain {
my ($self, $dom) = @_;
DNS::LDNS::GC::disown(my $old = $self->domain);
_set_domain($self, my $copy = $dom->clone);
DNS::LDNS::GC::own($copy, $self);
}
sub nameservers {
my $self = shift;
my $list = _nameservers($self);
for my $r (@$list) {
DNS::LDNS::GC::own($r, $self);
}
return wantarray ? @$list : $list;
}
sub push_nameserver {
my ($self, $n) = @_;
my $s = _push_nameserver($self, my $copy = $n->clone);
DNS::LDNS::GC::own($copy, $self);
$DNS::LDNS::last_status = $s;
return $s;
}
sub pop_nameserver {
my $self = shift;
return DNS::LDNS::GC::own($self->_pop_nameserver);
}
sub push_searchlist {
my ($self, $rd) = @_;
_push_searchlist($self, my $copy = $rd->clone);
DNS::LDNS::GC::own($copy, $self);
}
sub searchlist {
my $self = shift;
my $list = _searchlist($self);
for my $r (@$list) {
DNS::LDNS::GC::own($r, $self);
}
return wantarray ? @$list : $list;
}
sub timeout {
my $self = shift;
my $t = _timeout($self);
return wantarray ? @$t : $t;
}
sub rtt {
my $self = shift;
my $list = _rtt($self);
return wantarray ? @$list : $list;
}
sub set_rtt {
my ($self, @rtt) = @_;
# FIXME: Validate @rtt, existence, size
_set_rtt($self, \@rtt);
}
sub fetch_valid_domain_keys {
my ($self, $domain, $keys) = @_;
my $status;
my $trusted = _fetch_valid_domain_keys($self, $domain, $keys, $status);
$DNS::LDNS::last_status = $status;
if (!$trusted) {
return;
}
return DNS::LDNS::GC::own($trusted, $self);
}
sub fetch_valid_domain_keys_time {
my ($self, $domain, $keys, $checktime) = @_;
my $status;
my $trusted = _fetch_valid_domain_keys_time(
$self, $domain, $keys, $checktime, $status);
$DNS::LDNS::last_status = $status;
if (!$trusted) {
return;
}
return DNS::LDNS::GC::own($trusted, $self);
}
sub prepare_query_pkt {
my ($self, $rdata, $type, $class, $flags) = @_;
my $s = &LDNS_STATUS_OK;
my $qry = _prepare_query_pkt($self, $rdata, $type, $class, $flags, $s);
$DNS::LDNS::last_status = $s;
if ($s != LDNS_STATUS_OK) {
return;
}
return $qry;
}
sub send {
my ($self, $rdata, $type, $class, $flags) = @_;
my $s = &LDNS_STATUS_OK;
my $ans = _send($self, $rdata, $type, $class, $flags, $s);
$DNS::LDNS::last_status = $s;
if ($s != LDNS_STATUS_OK) {
return;
}
return $ans;
}
sub send_pkt {
my ($self, $qry) = @_;
my $s = &LDNS_STATUS_OK;
my $ans = _send_pkt($self, $qry, $s);
$DNS::LDNS::last_status = $s;
if ($s != LDNS_STATUS_OK) {
return;
}
return $ans;
}
sub verify_trusted {
my ($self, $rrset, $rrsigs, $validating_keys) = @_;
my $s = _verify_trusted($self, $rrset, $rrsigs, $validating_keys);
$DNS::LDNS::last_status = $s;
return $s;
}
sub verify_trusted_time {
my ($self, $rrset, $rrsigs, $check_time, $validating_keys) = @_;
my $s = _verify_trusted_time($self, $rrset, $rrsigs, $check_time,
$validating_keys);
$DNS::LDNS::last_status = $s;
return $s;
}
sub DESTROY {
DNS::LDNS::GC::free($_[0]);
}
1;
__END__
=head1 NAME
DNS::LDNS::Resolver - DNS resolver
=head1 SYNOPSIS
use DNS::LDNS ':all'
my r = new DNS::LDNS::Resolver(filename => '/my/resolv.conf')
my r = new DNS::LDNS::Resolver(file => \*FILE)
my r = new DNS::LDNS::Resolver
bool = r->dnssec
r->set_dnssec(bool)
bool = r->dnssec_cd # Resolver sets the CD bit
r->set_dnssec_cd(bool)
port = r->port
r->set_port(port)
bool = r->recursive
r->set_recursive(bool)
bool = r->debug
r->set_debug(bool)
count = r->retry
r->set_retry(count)
count = r->retrans
r->set_retrans(count)
bool = r->fallback # Resolver truncation fallback mechanism
r->set_fallback(bool)
bool = r->ip6
r->set_ip6(bool)
size = r->edns_udp_size
r->set_edns_udp_size(size)
bool = r->usevc # Use virtual circuit (TCP)
r->set_usevc(bool)
r->fail
r->set_fail
r->defnames
r->set_defnames
r->dnsrch
r->set_dnsrch
r->igntc
r->set_igntc
bool = r->random # randomize nameserver before usage
r->set_random(bool)
rrlist = r->dnssec_anchors # list of trusted DNSSEC anchors
r->push_dnssec_anchor(rr)
r->set_dnssec_anchors(rrlist)
rdata = r->domain # Domain to add to relative queries
r->set_domain(rdata)
@rdata = r->nameservers
count = r->nameserver_count
r->push_nameserver(rdata)
rdata = r->pop_nameserver
r->nameservers_randomize
str = r->tsig_keyname
r->set_tsig_keyname(str)
str = r->tsig_algorithm
r->set_tsig_algorithm(str)
str = r->tsig_keydata
r->set_tsig_keydata(str)
count = r->searchlist_count
r->push_searchlist(rdata)
@rdata = r->searchlist
@times = r->rtt # Round trip times
r->set_rtt(@rtt)
time = r->nameserver_rtt(pos)
r->set_nameserver_rtt(pos, time)
(sec, usec) = r->timeout
r->set_timeout(sec, usec)
# DNSSec validation
rrlist = r->fetch_valid_domain_keys(domain, keys)
rrlist = r->fetch_valid_domain_keys_time(domain, keys, checktime)
rrlist = r->validate_domain_ds(domain, keys)
rrlist = r->validate_domain_ds_time(domain, keys, checktime)
rrlist = r->validate_domain_dnskey(domain, keys)
rrlist = r->validate_domain_dnskey_time(domain, keys, checktime)
status = r->verify_trusted(rrset, rrsigs, validation_keys)
status = r->verify_trusted_time(rrset, rrsigs, checktime, validation_keys)
bool = r->trusted_key(keys, trusted_keys)
chain = r->build_data_chain(qflags, dataset, pkt, orig_rr)
# Query
pkt = r->query(rdata, type, class, flags)
pkt = r->search(rdata, type, class, flags)
query = r->prepare_query_pkt(rdata, type, class, flags)
answer = r->send(rdata, type, class, flags)
answer = r->send_pkt(query)
rrlist = r->get_rr_list_addr_by_name(name, class, flags)
rrlist = r->get_rr_list_name_by_addr(addr, class, flags)
=head1 SEE ALSO
http://www.nlnetlabs.nl/projects/ldns
=head1 AUTHOR
Erik Pihl Ostlyngen, E<lt>erik.ostlyngen@uninett.noE<gt>
=head1 COPYRIGHT AND LICENSE
Copyright (C) 2013 by UNINETT Norid AS
This library is free software; you can redistribute it and/or modify
it under the same terms as Perl itself, either Perl version 5.14.2 or,
at your option, any later version of Perl 5 you may have available.
=cut

140
zonemaster-ldns/ldns/contrib/DNS-LDNS/lib/DNS/LDNS/Zone.pm Normal file
View File

@@ -0,0 +1,140 @@
package DNS::LDNS::Zone;
use 5.008008;
use strict;
use warnings;
use DNS::LDNS ':all';
our $VERSION = '0.61';
sub new {
my ($class, %args) = @_;
my $line_nr = 0;
my $status = &LDNS_STATUS_OK;
my $zone;
my $file;
if ($args{filename}) {
unless (open FILE, $args{filename}) {
$DNS::LDNS::last_status = &LDNS_STATUS_FILE_ERR;
$DNS::LDNS::line_nr = 0;
return;
}
$file = \*FILE;
}
elsif ($args{file}) {
$file = $args{file};
}
if ($file) {
$zone = _new_from_file($file,
$args{origin},
$args{default_ttl} || 0,
$args{class} || 0,
$status, $line_nr);
}
else {
$zone = _new();
}
if ($args{filename}) {
close $file;
}
$DNS::LDNS::last_status = $status;
$DNS::LDNS::line_nr = $line_nr;
if (!defined $zone) {
return;
}
return $zone;
}
sub to_string {
my $self = shift;
return join('', map { $self->$_ ? $self->$_->to_string : '' } qw/soa rrs/);
}
sub soa {
my $self = shift;
return DNS::LDNS::GC::own($self->_soa, $self);
}
sub set_soa {
my ($self, $soa) = @_;
DNS::LDNS::GC::disown(my $old = $self->soa);
$self->_set_soa(my $copy = $soa->clone);
return DNS::LDNS::GC::own($copy, $self);
}
sub rrs {
my $self = shift;
return DNS::LDNS::GC::own($self->_rrs, $self);
}
sub set_rrs {
my ($self, $list) = @_;
DNS::LDNS::GC::disown(my $old = $self->rrs);
$self->_set_rrs(my $copy = $list->clone);
return DNS::LDNS::GC::own($copy, $self);
}
sub DESTROY {
DNS::LDNS::GC::free($_[0]);
}
1;
__END__
=head1 NAME
DNS::LDNS::Zone - Parsed zonefile
=head1 SYNOPSIS
use DNS::LDNS ':all'
my z = new DNS::LDNS::Zone(
filename => '/path/to/myzone',
origin => new DNS::LDNS::RData(LDNS_RDF_TYPE_DNAME, 'myzone'), #optional
default_ttl => 3600, #optional
class => LDNS_RR_CLASS_IN, #optional
)
my z = new DNS::LDNS::Zone(
file => \*FILE,
origin => ..., default_ttl => ..., class => ...
)
my z = new DNS::LDNS::Zone
z->to_string
z->print(\*FILE)
z->canonicalize
z->sort
rr = z->soa
z->set_soa(rr)
rrlist = z->rrs
z->set_rrs(rrlist)
z->sign(keylist)
z->sign_nsec3(keylist, algorithm, flags, iterations, salt)
=head1 SEE ALSO
http://www.nlnetlabs.nl/projects/ldns
=head1 AUTHOR
Erik Pihl Ostlyngen, E<lt>erik.ostlyngen@uninett.noE<gt>
=head1 COPYRIGHT AND LICENSE
Copyright (C) 2013 by UNINETT Norid AS
This library is free software; you can redistribute it and/or modify
it under the same terms as Perl itself, either Perl version 5.14.2 or,
at your option, any later version of Perl 5 you may have available.
=cut

136
zonemaster-ldns/ldns/contrib/DNS-LDNS/t/DNS-LDNS.t Normal file
View File

@@ -0,0 +1,136 @@
# Before `make install' is performed this script should be runnable with
# `make test'. After `make install' it should work as `perl DNS-LDNS.t'
#########################
# change 'tests => 2' to 'tests => last_test_to_print';
use strict;
use warnings;
use Test::More tests => 2;
BEGIN { use_ok('DNS::LDNS') };
my $fail = 0;
foreach my $constname (qw(
LDNS_AA LDNS_AD LDNS_CD LDNS_CERT_ACPKIX LDNS_CERT_IACPKIX
LDNS_CERT_IPGP LDNS_CERT_IPKIX LDNS_CERT_ISPKI LDNS_CERT_OID
LDNS_CERT_PGP LDNS_CERT_PKIX LDNS_CERT_SPKI LDNS_CERT_URI
LDNS_DEFAULT_TTL LDNS_DH LDNS_DSA LDNS_DSA_NSEC3 LDNS_ECC LDNS_ECC_GOST
LDNS_HASH_GOST LDNS_IP4ADDRLEN LDNS_IP6ADDRLEN
LDNS_KEY_REVOKE_KEY LDNS_KEY_SEP_KEY LDNS_KEY_ZONE_KEY
LDNS_MAX_DOMAINLEN LDNS_MAX_LABELLEN LDNS_MAX_PACKETLEN
LDNS_MAX_POINTERS LDNS_MAX_RDFLEN LDNS_NSEC3_VARS_OPTOUT_MASK
LDNS_PACKET_ANSWER LDNS_PACKET_IQUERY LDNS_PACKET_NODATA
LDNS_PACKET_NOTIFY LDNS_PACKET_NXDOMAIN LDNS_PACKET_QUERY
LDNS_PACKET_QUESTION LDNS_PACKET_REFERRAL LDNS_PACKET_STATUS
LDNS_PACKET_UNKNOWN LDNS_PACKET_UPDATE LDNS_PORT LDNS_PRIVATEDNS
LDNS_PRIVATEOID LDNS_QR LDNS_RA LDNS_RCODE_FORMERR LDNS_RCODE_NOERROR
LDNS_RCODE_NOTAUTH LDNS_RCODE_NOTIMPL LDNS_RCODE_NOTZONE
LDNS_RCODE_NXDOMAIN LDNS_RCODE_NXRRSET LDNS_RCODE_REFUSED
LDNS_RCODE_SERVFAIL LDNS_RCODE_YXDOMAIN LDNS_RCODE_YXRRSET LDNS_RD
LDNS_RDATA_FIELD_DESCRIPTORS_COMMON LDNS_RDF_SIZE_16BYTES
LDNS_RDF_SIZE_6BYTES LDNS_RDF_SIZE_BYTE LDNS_RDF_SIZE_DOUBLEWORD
LDNS_RDF_SIZE_WORD LDNS_RDF_TYPE_A LDNS_RDF_TYPE_AAAA LDNS_RDF_TYPE_ALG
LDNS_RDF_TYPE_APL LDNS_RDF_TYPE_ATMA LDNS_RDF_TYPE_B32_EXT
LDNS_RDF_TYPE_B64 LDNS_RDF_TYPE_CERT_ALG LDNS_RDF_TYPE_CLASS
LDNS_RDF_TYPE_DNAME LDNS_RDF_TYPE_HEX LDNS_RDF_TYPE_INT16
LDNS_RDF_TYPE_INT16_DATA LDNS_RDF_TYPE_INT32 LDNS_RDF_TYPE_INT8
LDNS_RDF_TYPE_IPSECKEY LDNS_RDF_TYPE_LOC LDNS_RDF_TYPE_NONE
LDNS_RDF_TYPE_NSAP LDNS_RDF_TYPE_NSEC LDNS_RDF_TYPE_NSEC3_NEXT_OWNER
LDNS_RDF_TYPE_NSEC3_SALT LDNS_RDF_TYPE_PERIOD LDNS_RDF_TYPE_SERVICE
LDNS_RDF_TYPE_STR LDNS_RDF_TYPE_TIME LDNS_RDF_TYPE_HIP
LDNS_RDF_TYPE_TSIGTIME LDNS_RDF_TYPE_TYPE LDNS_RDF_TYPE_UNKNOWN
LDNS_RDF_TYPE_WKS LDNS_RESOLV_ANCHOR LDNS_RESOLV_DEFDOMAIN
LDNS_RESOLV_INET LDNS_RESOLV_INET6 LDNS_RESOLV_INETANY
LDNS_RESOLV_KEYWORD LDNS_RESOLV_KEYWORDS LDNS_RESOLV_NAMESERVER
LDNS_RESOLV_OPTIONS LDNS_RESOLV_RTT_INF LDNS_RESOLV_RTT_MIN
LDNS_RESOLV_SEARCH LDNS_RESOLV_SORTLIST LDNS_RR_CLASS_ANY
LDNS_RR_CLASS_CH LDNS_RR_CLASS_COUNT LDNS_RR_CLASS_FIRST
LDNS_RR_CLASS_HS LDNS_RR_CLASS_IN LDNS_RR_CLASS_LAST LDNS_RR_CLASS_NONE
LDNS_RR_COMPRESS LDNS_RR_NO_COMPRESS LDNS_RR_OVERHEAD LDNS_RR_TYPE_A
LDNS_RR_TYPE_A6 LDNS_RR_TYPE_AAAA LDNS_RR_TYPE_AFSDB LDNS_RR_TYPE_ANY
LDNS_RR_TYPE_APL LDNS_RR_TYPE_ATMA LDNS_RR_TYPE_AXFR LDNS_RR_TYPE_CERT
LDNS_RR_TYPE_CNAME LDNS_RR_TYPE_COUNT LDNS_RR_TYPE_DHCID
LDNS_RR_TYPE_DLV LDNS_RR_TYPE_DNAME LDNS_RR_TYPE_DNSKEY LDNS_RR_TYPE_DS
LDNS_RR_TYPE_EID LDNS_RR_TYPE_FIRST LDNS_RR_TYPE_GID LDNS_RR_TYPE_GPOS
LDNS_RR_TYPE_HINFO LDNS_RR_TYPE_IPSECKEY LDNS_RR_TYPE_ISDN
LDNS_RR_TYPE_IXFR LDNS_RR_TYPE_KEY LDNS_RR_TYPE_KX LDNS_RR_TYPE_LAST
LDNS_RR_TYPE_LOC LDNS_RR_TYPE_MAILA LDNS_RR_TYPE_MAILB LDNS_RR_TYPE_MB
LDNS_RR_TYPE_MD LDNS_RR_TYPE_MF LDNS_RR_TYPE_MG LDNS_RR_TYPE_MINFO
LDNS_RR_TYPE_MR LDNS_RR_TYPE_MX LDNS_RR_TYPE_NAPTR LDNS_RR_TYPE_NIMLOC
LDNS_RR_TYPE_NS LDNS_RR_TYPE_NSAP LDNS_RR_TYPE_NSAP_PTR
LDNS_RR_TYPE_NSEC LDNS_RR_TYPE_NSEC3 LDNS_RR_TYPE_NSEC3PARAM
LDNS_RR_TYPE_NSEC3PARAMS LDNS_RR_TYPE_NULL LDNS_RR_TYPE_NXT
LDNS_RR_TYPE_OPT LDNS_RR_TYPE_PTR LDNS_RR_TYPE_PX LDNS_RR_TYPE_RP
LDNS_RR_TYPE_RRSIG LDNS_RR_TYPE_RT LDNS_RR_TYPE_SIG LDNS_RR_TYPE_SINK
LDNS_RR_TYPE_SOA LDNS_RR_TYPE_SPF LDNS_RR_TYPE_SRV LDNS_RR_TYPE_SSHFP
LDNS_RR_TYPE_TALINK LDNS_RR_TYPE_TSIG LDNS_RR_TYPE_TXT LDNS_RR_TYPE_UID
LDNS_RR_TYPE_UINFO LDNS_RR_TYPE_UNSPEC LDNS_RR_TYPE_WKS
LDNS_RR_TYPE_X25 LDNS_RSAMD5 LDNS_RSASHA1 LDNS_RSASHA1_NSEC3
LDNS_RSASHA256 LDNS_RSASHA512 LDNS_SECTION_ADDITIONAL
LDNS_SECTION_ANSWER LDNS_SECTION_ANY LDNS_SECTION_ANY_NOQUESTION
LDNS_SECTION_AUTHORITY LDNS_SECTION_QUESTION LDNS_SHA1 LDNS_SHA256
LDNS_SIGN_DSA LDNS_SIGN_DSA_NSEC3 LDNS_SIGN_ECC_GOST
LDNS_SIGN_HMACSHA1 LDNS_SIGN_HMACSHA256
LDNS_SIGN_RSAMD5 LDNS_SIGN_RSASHA1 LDNS_SIGN_RSASHA1_NSEC3
LDNS_SIGN_RSASHA256 LDNS_SIGN_RSASHA512 LDNS_STATUS_ADDRESS_ERR
LDNS_STATUS_CERT_BAD_ALGORITHM LDNS_STATUS_CRYPTO_ALGO_NOT_IMPL
LDNS_STATUS_CRYPTO_BOGUS LDNS_STATUS_CRYPTO_EXPIRATION_BEFORE_INCEPTION
LDNS_STATUS_CRYPTO_NO_DNSKEY LDNS_STATUS_CRYPTO_NO_DS
LDNS_STATUS_CRYPTO_NO_MATCHING_KEYTAG_DNSKEY
LDNS_STATUS_CRYPTO_NO_RRSIG LDNS_STATUS_CRYPTO_NO_TRUSTED_DNSKEY
LDNS_STATUS_CRYPTO_NO_TRUSTED_DS LDNS_STATUS_CRYPTO_SIG_EXPIRED
LDNS_STATUS_CRYPTO_SIG_NOT_INCEPTED LDNS_STATUS_CRYPTO_TSIG_BOGUS
LDNS_STATUS_CRYPTO_TSIG_ERR LDNS_STATUS_CRYPTO_TYPE_COVERED_ERR
LDNS_STATUS_CRYPTO_UNKNOWN_ALGO LDNS_STATUS_CRYPTO_VALIDATED
LDNS_STATUS_DDD_OVERFLOW LDNS_STATUS_DNSSEC_EXISTENCE_DENIED
LDNS_STATUS_DNSSEC_NSEC3_ORIGINAL_NOT_FOUND
LDNS_STATUS_DNSSEC_NSEC_RR_NOT_COVERED
LDNS_STATUS_DNSSEC_NSEC_WILDCARD_NOT_COVERED
LDNS_STATUS_DOMAINNAME_OVERFLOW LDNS_STATUS_DOMAINNAME_UNDERFLOW
LDNS_STATUS_EMPTY_LABEL LDNS_STATUS_ENGINE_KEY_NOT_LOADED
LDNS_STATUS_ERR LDNS_STATUS_FILE_ERR LDNS_STATUS_INTERNAL_ERR
LDNS_STATUS_INVALID_B32_EXT LDNS_STATUS_INVALID_B64
LDNS_STATUS_INVALID_HEX LDNS_STATUS_INVALID_INT LDNS_STATUS_INVALID_IP4
LDNS_STATUS_INVALID_IP6 LDNS_STATUS_INVALID_POINTER
LDNS_STATUS_INVALID_STR LDNS_STATUS_INVALID_TIME
LDNS_STATUS_LABEL_OVERFLOW LDNS_STATUS_MEM_ERR
LDNS_STATUS_MISSING_RDATA_FIELDS_KEY
LDNS_STATUS_MISSING_RDATA_FIELDS_RRSIG LDNS_STATUS_NETWORK_ERR
LDNS_STATUS_NOT_IMPL LDNS_STATUS_NO_DATA LDNS_STATUS_NSEC3_ERR
LDNS_STATUS_NULL LDNS_STATUS_OK LDNS_STATUS_PACKET_OVERFLOW
LDNS_STATUS_RES_NO_NS LDNS_STATUS_RES_QUERY LDNS_STATUS_SOCKET_ERROR
LDNS_STATUS_SSL_ERR LDNS_STATUS_SYNTAX_ALG_ERR
LDNS_STATUS_SYNTAX_BAD_ESCAPE LDNS_STATUS_SYNTAX_CLASS_ERR
LDNS_STATUS_SYNTAX_DNAME_ERR LDNS_STATUS_SYNTAX_EMPTY
LDNS_STATUS_SYNTAX_ERR LDNS_STATUS_SYNTAX_INCLUDE
LDNS_STATUS_SYNTAX_INCLUDE_ERR_NOTIMPL
LDNS_STATUS_SYNTAX_INTEGER_OVERFLOW
LDNS_STATUS_SYNTAX_ITERATIONS_OVERFLOW LDNS_STATUS_SYNTAX_KEYWORD_ERR
LDNS_STATUS_SYNTAX_MISSING_VALUE_ERR LDNS_STATUS_SYNTAX_ORIGIN
LDNS_STATUS_SYNTAX_RDATA_ERR LDNS_STATUS_SYNTAX_TTL
LDNS_STATUS_SYNTAX_TTL_ERR LDNS_STATUS_SYNTAX_TYPE_ERR
LDNS_STATUS_SYNTAX_VERSION_ERR LDNS_STATUS_UNKNOWN_INET
LDNS_STATUS_WIRE_INCOMPLETE_ADDITIONAL
LDNS_STATUS_WIRE_INCOMPLETE_ANSWER
LDNS_STATUS_WIRE_INCOMPLETE_AUTHORITY
LDNS_STATUS_WIRE_INCOMPLETE_HEADER LDNS_STATUS_WIRE_INCOMPLETE_QUESTION
LDNS_TC)) {
next if (eval "my \$a = $constname; 1");
if ($@ =~ /^Your vendor has not defined LDNS macro $constname/) {
print "# pass: $@";
} else {
print "# fail: $@";
$fail = 1;
}
}
ok( $fail == 0 , 'Constants' );
#########################
# Insert your test code below, the Test::More module is use()ed here so read
# its man page ( perldoc Test::More ) for help writing this test script.

60
zonemaster-ldns/ldns/contrib/DNS-LDNS/t/dnssec_datachain.t Normal file
View File

@@ -0,0 +1,60 @@
use Test::More tests => 10;
use Test::Exception;
use FindBin qw/$Bin/;
use DNS::LDNS ':all';
BEGIN { use_ok('DNS::LDNS') };
# Note: This test makes queries on real internet dns data, and assumes
# that the iis.se domain is signed.
my $r = new DNS::LDNS::Resolver(filename => "/etc/resolv.conf");
$r->set_dnssec(1);
$r->set_random(0);
my $p = $r->query(
new DNS::LDNS::RData(LDNS_RDF_TYPE_DNAME, 'iis.se.'),
LDNS_RR_TYPE_SOA, LDNS_RR_CLASS_IN, LDNS_RD);
SKIP: {
skip "Resolver is not dnssec able. Skip this test.", 9 unless ($p->ad);
isa_ok($p, 'DNS::LDNS::Packet');
my $rrset = $p->rr_list_by_type(LDNS_RR_TYPE_SOA, LDNS_SECTION_ANSWER);
ok($rrset->rr_count > 0, 'Got an answer with some content');
my $chain = $r->build_data_chain(LDNS_RD, $rrset, $p, undef);
isa_ok($chain, 'DNS::LDNS::DNSSecDataChain');
isa_ok($chain->parent, 'DNS::LDNS::DNSSecDataChain');
dies_ok {
my $new_rr = new DNS::LDNS::RR(str => 'test.test. 1234 IN A 10.0.0.1');
my $t = $chain->derive_trust_tree($new_rr);
} 'Making a trust tree with foreign rr fails.';
my $rr = $chain->rrset->rr(0);
my $tree = $chain->derive_trust_tree($rr);
isa_ok($tree, 'DNS::LDNS::DNSSecTrustTree');
# Get root keys.
my $root_keys_pk = $r->query(
new DNS::LDNS::RData(LDNS_RDF_TYPE_DNAME, '.'),
LDNS_RR_TYPE_DNSKEY, LDNS_RR_CLASS_IN, LDNS_RD);
my $root_keys = $root_keys_pk->rr_list_by_type(
LDNS_RR_TYPE_DNSKEY, LDNS_SECTION_ANSWER);
is($tree->contains_keys($root_keys), LDNS_STATUS_OK,
'Root key found in trust chain');
ok($tree->depth > 1, 'The trust tree is more than one node.');
isa_ok($tree->parent(0), 'DNS::LDNS::DNSSecTrustTree');
}

35
zonemaster-ldns/ldns/contrib/DNS-LDNS/t/dnssec_zone.t Normal file
View File

@@ -0,0 +1,35 @@
use Test::More tests => 7;
use FindBin qw/$Bin/;
use DNS::LDNS ':all';
BEGIN { use_ok('DNS::LDNS') };
# Create a new dnssec zone
my $z = new DNS::LDNS::DNSSecZone;
isa_ok($z, 'DNS::LDNS::DNSSecZone', 'Create an empty zone');
# Read a zone from file and create a dnssec zone from it
my $z2 = new DNS::LDNS::Zone(
filename => "$Bin/testdata/myzone.org");
$z->create_from_zone($z2);
my $rrset = $z->find_rrset(
new DNS::LDNS::RData(LDNS_RDF_TYPE_DNAME, 'ns1.myzone.org.'),
LDNS_RR_TYPE_A);
is($rrset->rrs->rr->type, LDNS_RR_TYPE_A, 'Found an A record');
is($rrset->rrs->rr->dname, 'ns1.myzone.org.', 'Dname is ns1.myzone.org.');
is($z->add_empty_nonterminals, LDNS_STATUS_OK, 'Add empty non-terminals');
my $klist = new DNS::LDNS::KeyList;
$klist->push(new DNS::LDNS::Key(filename => "$Bin/testdata/key.private"));
$klist->key(0)->set_pubkey_owner(
new DNS::LDNS::RData(LDNS_RDF_TYPE_DNAME, 'myzone.org'));
is($z->sign($klist, LDNS_SIGNATURE_REMOVE_ADD_NEW, 0), LDNS_STATUS_OK, 'Sign');
is($z->sign_nsec3($klist, LDNS_SIGNATURE_REMOVE_ADD_NEW, 1, 0, 10, 'ABBA', 0),
LDNS_STATUS_OK, 'Sign nsec3');

25
zonemaster-ldns/ldns/contrib/DNS-LDNS/t/key.t Normal file
View File

@@ -0,0 +1,25 @@
use Test::More tests => 8;
use FindBin qw/$Bin/;
use DNS::LDNS ':all';
BEGIN { use_ok('DNS::LDNS') };
my $key = new DNS::LDNS::Key(filename => "$Bin/testdata/key.private");
ok($key, 'Created new key object from file');
is($key->algorithm, 7, 'Algorithm is NSEC3RSASHA1');
my $now = time;
$key->set_inception($now);
$key->set_expiration($now + 10000);
is($key->inception, $now, 'Inception time');
is($key->expiration, $now + 10000, 'Expiration time');
like($key->to_rr->to_string, qr|3600\s+IN\s+DNSKEY\s+256\s+3\s+7\s+AwEAAfg/ghOkk|, 'Got rr representation of key');
my $klist = new DNS::LDNS::KeyList;
$klist->push($key);
is($klist->count, 1, 'Keylist has one key');
is($$key, ${$klist->key(0)}, 'Key in keylist is the one we pushed');
# FIXME: pop is buggy in ldns 1.6.12, uncomment when this starts working
# is($klist->pop(), $$key, 'Pop key from list');
# is($klist->count, 0, 'No keys left in list');

47
zonemaster-ldns/ldns/contrib/DNS-LDNS/t/rdata.t Normal file
View File

@@ -0,0 +1,47 @@
use Test::More tests => 18;
use DNS::LDNS ':all';
BEGIN { use_ok('DNS::LDNS') };
# Integer data
my $i = new DNS::LDNS::RData(LDNS_RDF_TYPE_INT32, '1237654');
is($i->to_string, '1237654', 'Integer value rdata');
my $ii = new DNS::LDNS::RData(LDNS_RDF_TYPE_INT32, '1237654X');
is($ii, undef, '1237654X is invalid');
# Period data
my $p1 = new DNS::LDNS::RData(LDNS_RDF_TYPE_PERIOD, '3h3m3s');
is($p1->to_string, sprintf("%d", 3600*3 + 60*3 + 3), 'Normalizing period');
my $pi = new DNS::LDNS::RData(LDNS_RDF_TYPE_PERIOD, '3h3X3s');
is($pi, undef, 'Invalid period value 3h3X3s');
# DNames
my $dn1 = new DNS::LDNS::RData(LDNS_RDF_TYPE_DNAME, 'azone.org');
my $dn2 = new DNS::LDNS::RData(LDNS_RDF_TYPE_DNAME, 'other.org');
my $dn3 = new DNS::LDNS::RData(LDNS_RDF_TYPE_DNAME, 'sub.other.org');
my $dn4 = new DNS::LDNS::RData(LDNS_RDF_TYPE_DNAME, 'adder.org');
$dn1->cat($dn2);
is($dn1->to_string, 'azone.org.other.org.', 'Concatenating two domain names');
my $chopped = $dn1->left_chop;
is($chopped->to_string, 'org.other.org.', 'Chop off left domain name label');
ok($dn3->is_subdomain($dn2), 'sub.other.org is subdomain of other.org');
ok(!$dn2->is_subdomain($dn3), 'other.org is not subdomain of sub.other.org');
is($dn3->label_count, 3, 'sub.other.org has 3 labels');
is($dn3->label(1)->to_string, 'other.', 'label 1 of sub.other.org is other.');
my $dni = new DNS::LDNS::RData(
LDNS_RDF_TYPE_DNAME, 'not..valid.org');
is($dni, undef, 'Invalid dname not_valid.org');
my $wc = new DNS::LDNS::RData(LDNS_RDF_TYPE_DNAME, '*.other.org');
ok($wc->is_wildcard, '*.other.org is a wildcard');
ok(!$dn3->is_wildcard, 'sub.other.org is not a wildcard');
ok($dn3->matches_wildcard($wc), 'sub.other.org matches *.other.org');
ok(!$dn4->matches_wildcard($wc), 'adder.org does not match *.other.org');
is($dn3->compare($dn4), 1, 'sub.other.org > adder.org');
is($dn4->compare($dn3), -1, 'adder.org < sub.other.org');

23
zonemaster-ldns/ldns/contrib/DNS-LDNS/t/resolver.t Normal file
View File

@@ -0,0 +1,23 @@
use Test::More tests => 3;
use FindBin qw/$Bin/;
use DNS::LDNS ':all';
BEGIN { use_ok('DNS::LDNS') };
my $r = new DNS::LDNS::Resolver(filename => "/etc/resolv.conf");
$r->set_random(0);
my $p = $r->query(
new DNS::LDNS::RData(LDNS_RDF_TYPE_DNAME, 'org'),
LDNS_RR_TYPE_SOA, LDNS_RR_CLASS_IN, LDNS_RD);
isa_ok($p, 'DNS::LDNS::Packet', 'Make a simple query');
my $r2 = new DNS::LDNS::Resolver(filename => "$Bin/testdata/resolv.conf");
$r2->set_rtt(2, 3);
my @rtt = $r2->rtt;
is_deeply(\@rtt, [2, 3], "set_rtt and rtt");

74
zonemaster-ldns/ldns/contrib/DNS-LDNS/t/rr.t Normal file
View File

@@ -0,0 +1,74 @@
use Test::More tests => 19;
use FindBin qw/$Bin/;
use DNS::LDNS ':all';
BEGIN { use_ok('DNS::LDNS') };
my $rr1 = new DNS::LDNS::RR;
isa_ok($rr1, 'DNS::LDNS::RR', 'Create empty rr');
$rr1 = new DNS::LDNS::RR(
type => LDNS_RR_TYPE_SOA,
class => LDNS_RR_CLASS_CH,
ttl => 1234,
owner => 'myzone.org',
rdata => [
new DNS::LDNS::RData(LDNS_RDF_TYPE_DNAME, 'hostmaster.myzone.org'),
new DNS::LDNS::RData(LDNS_RDF_TYPE_DNAME, 'master.myzone.org'),
new DNS::LDNS::RData(LDNS_RDF_TYPE_INT32, '2012113030'),
new DNS::LDNS::RData(LDNS_RDF_TYPE_PERIOD, '12345'),
new DNS::LDNS::RData(LDNS_RDF_TYPE_PERIOD, '1827'),
new DNS::LDNS::RData(LDNS_RDF_TYPE_PERIOD, '2345678'),
new DNS::LDNS::RData(LDNS_RDF_TYPE_PERIOD, '87654')
],
);
isa_ok($rr1, 'DNS::LDNS::RR', 'Create SOA rr with rdata');
like($rr1->to_string, qr/^myzone\.org\.\s+1234\s+CH\s+SOA\s+hostmaster\.myzone\.org\.\s+master\.myzone\.org\.\s+2012113030\s+12345\s+1827\s+2345678\s+87654$/,
'Format SOA rr as string');
is($rr1->pop_rdata->to_string, '87654', 'pop rdata');
$rr1->push_rdata(new DNS::LDNS::RData(LDNS_RDF_TYPE_PERIOD, '55667'));
is($rr1->rdata(6)->to_string, '55667', 'push_rdata and access rdata by index');
my $rr2 = new DNS::LDNS::RR(str => 'myzone.org. 1234 IN SOA hostmaster.myzone.org. master.myzone.org. 2012 12345 1827 2345678 87654');
isa_ok($rr2, 'DNS::LDNS::RR', 'Create SOA rr from string');
like($rr2->to_string, qr/^myzone\.org\.\s+1234\s+IN\s+SOA\s+hostmaster\.myzone\.org\.\s+master\.myzone\.org\.\s+2012\s+12345\s+1827\s+2345678\s+87654$/,
'Format it back to string');
ok($rr1->compare($rr2) > 0, 'Compare rr, greater than');
ok($rr2->compare($rr1) < 0, 'Compare rr, less than');
is($rr1->compare($rr1), 0, 'Compare rr, equal');
my $rr3 = new DNS::LDNS::RR(str => 'ozone.org. 1234 IN SOA hostmaster.ozone.org. master.ozone.org. 2012 12345 1827 2345678 87654');
ok($rr3->compare_dname($rr1) > 0, 'Compare dname, greater than');
ok($rr1->compare_dname($rr3) < 0, 'Compare dname, less than');
is($rr1->compare_dname($rr2), 0, 'Compare dname, equal');
# Read records from a zonefile
my $origin = new DNS::LDNS::RData(LDNS_RDF_TYPE_DNAME, '.');
my $prev = $origin->clone;
my $ttl = 0;
my $count = 0;
open(ZONE, "$Bin/testdata/myzone.org");
my $rr4 = new DNS::LDNS::RR(file => \*ZONE, default_ttl => \$ttl,
origin => \$origin, prev => \$prev);
is($DNS::LDNS::last_status, LDNS_STATUS_SYNTAX_TTL, "Read ttl statement.");
is($ttl, 4500, "TTL is 4500");
$rr4 = new DNS::LDNS::RR(file => \*ZONE, default_ttl => \$ttl,
origin => \$origin, prev => \$prev);
is($DNS::LDNS::last_status, LDNS_STATUS_SYNTAX_ORIGIN, "Read origin statement.");
is($origin->to_string, "myzone.org.", "Origin is myzone.org.");
while (!eof(\*ZONE)) {
$rr4 = new DNS::LDNS::RR(file => \*ZONE, default_ttl => \$ttl,
origin => \$origin, prev => \$prev);
last unless ($rr4);
$count++;
}
is($count, 6);

84
zonemaster-ldns/ldns/contrib/DNS-LDNS/t/rrlist.t Normal file
View File

@@ -0,0 +1,84 @@
use Test::More tests => 24;
use FindBin qw/$Bin/;
use DNS::LDNS ':all';
BEGIN { use_ok('DNS::LDNS') };
# Create list
my $list = new DNS::LDNS::RRList;
isa_ok($list, 'DNS::LDNS::RRList', 'Create an empty rr list');
# Push/pop/count rr
$list->push(new DNS::LDNS::RR(str => 'ns.myzone.org 3600 IN AAAA ::1'));
is($list->rr_count, 1, 'Added one rr');
like($list->rr(0)->to_string, qr/^ns\.myzone\.org\.\s+3600\s+IN\s+AAAA\s+::1$/, 'Added rr is at position 0');
$list->push(new DNS::LDNS::RR(str => 'ns.myzone.org 7200 IN A 192.168.100.2'));
is($list->rr_count, 2, 'Added another rr');
like($list->rr(1)->to_string, qr/^ns\.myzone\.org\.\s+7200\s+IN\s+A\s+192\.168\.100\.2$/, 'Last added rr is at position 1');
like($list->pop->to_string, qr/^ns\.myzone\.org\.\s+7200\s+IN\s+A\s+192\.168\.100\.2$/, 'pop the last element');
is($list->rr_count, 1, '1 element left in the list');
# Push/pop list
my $l2 = new DNS::LDNS::RRList;
$l2->push(new DNS::LDNS::RR(str => 'ns2.myzone.org 3600 IN A 192.168.100.0'));
$l2->push(new DNS::LDNS::RR(str => 'ns2.myzone.org 3600 IN A 192.168.100.1'));
$list->push_list($l2);
is($list->rr_count, 3, 'Pushed two elements. List count is now 3.');
$list->push_list($l2);
$list->push_list($l2);
my $l3 = $list->pop_list(1);
is($list->rr_count, 6, 'Pushed 4 elements, popped 1, count is now 6');
is($l3->rr_count, 1, 'Popped list contains 1 elements');
$l3 = $list->pop_list(3);
is($list->rr_count, 3, 'Popped 3 elements, count is now 3');
is($l3->rr_count, 3, 'Popped list contains 3 elements');
# RRSets
ok($l2->is_rrset, 'List is rrset');
ok(!$list->is_rrset, 'List is no longer an rrset');
my $rrset = $list->pop_rrset;
ok($rrset->is_rrset, 'Popped list is rrset');
is($rrset->rr_count, 2, 'Popped rrset has two elements.');
# Compare, contains, subtype
my $rr = new DNS::LDNS::RR(str => 'ns2.myzone.org 3600 IN A 192.168.100.0');
ok($rrset->contains_rr($rr), 'RRSet contains rr '.$rr->to_string);
is($list->compare($l2), -1, '$list < $l2');
is($l2->compare($list), 1, '$l2 > $list');
$list->push(new DNS::LDNS::RR(str => 'ns3.myzone.org 3600 IN A 192.168.100.0'),
new DNS::LDNS::RR(str => 'ns3.myzone.org 3600 IN A 192.168.100.1'),
new DNS::LDNS::RR(str => 'ns4.myzone.org 3600 IN A 192.168.100.1'));
my $subtype = $list->subtype_by_rdata(
new DNS::LDNS::RData(LDNS_RDF_TYPE_A, '192.168.100.1'), 0);
is($subtype->to_string, "ns3.myzone.org.\t3600\tIN\tA\t192.168.100.1\nns4.myzone.org.\t3600\tIN\tA\t192.168.100.1\n", 'Filter rrs by rdata');
# DNSSec signature verification
my $keylist = new DNS::LDNS::RRList;
$keylist->push(
new DNS::LDNS::RR(str => 'trondheim.no. 3600 IN DNSKEY 256 3 8 AwEAAZIDdRI8I+F/J6OT8xX7CbGQYRr8rWH9dvloUlRJXcEVE2pRAez6 pJC5Odg+i2WvDUeE4tUO1gwwjU83TIinZxxsDnqr7FzvqpHeJbVd2N3d S4zaJcbjSnwMqdebmTEXSrflp8DeIAH0GQGNQjhOPubbb/nADYP2RS1i CoOADa8P'),
new DNS::LDNS::RR(str => 'trondheim.no. 3600 IN DNSKEY 257 3 8 AwEAAax9EgKyRsMpU2B0E2dZ+nkWnmZHjlBO3uXBI+2x33dG8bk+XSqr kyWTelhhsqLqIxsaYSwYgzLtn+/qzlFjKwcaU95p+Tp95MOVXYqUtRyC VyLGkzA7ZDbx7TFCi3PyLDM/Arx+DvOx6nNvA/erqIU5gYEo9Nm1KXEy rhfSn3xc96p1AOhmTuSo6EfYlPY4gxHDgJdHFv7Fi9zV6VFmJ29h0rsG 5g3pV1lvCcGcxfRLJ1u7JRw2BWMo9lgHzGuypEVV7iLnvbfDlXhF+jAS owR2JxlESC3dOgNiNWvc4pbyVXBXpP6h/5JpcxkzF7BNJMZiLN14qvam G1+LuZM8qfc=')
);
my $soalist = new DNS::LDNS::RRList;
$soalist->push(
new DNS::LDNS::RR(str => 'trondheim.no. 3600 IN SOA charm.norid.no. hostmaster.norid.no. 2013021137 14400 1800 2419200 3600')
);
my $siglist = new DNS::LDNS::RRList;
$siglist->push(
new DNS::LDNS::RR(str => 'trondheim.no. 3600 IN RRSIG SOA 8 2 3600 20130227105101 20130213090318 36381 trondheim.no. NbeN8E4pvQSDk3Dn0i8B4e2A3KAY8JrX+zcJazPTgHbT6wjzCncn3ANn 6rs+HdcCLtptyX1QbzlZD/lOY8kjJw5TEUoFX2Q/2sBYdt1aT6qgt/+H o71iUz3bk1V73zjSG/OpqG0oXmjCWSBZgzK6UI+zGlgG0Kvrc7H1pw5S ZBA=')
);
my ($status, $goodkeys) = $soalist->verify_notime($siglist, $keylist);
is ($status, LDNS_STATUS_OK, 'Verification returned status ok.');
is ($goodkeys->rr_count, 1, 'One key matched the signature.');
my $klist = new DNS::LDNS::KeyList;
$klist->push(new DNS::LDNS::Key(filename => "$Bin/testdata/key.private"));
$klist->key(0)->set_pubkey_owner(
new DNS::LDNS::RData(LDNS_RDF_TYPE_DNAME, 'myzone.org'));
my $sigs = $l2->sign_public($klist);
is($sigs->rr_count, 1, 'Sign public, got 1 rrsig');

13
zonemaster-ldns/ldns/contrib/DNS-LDNS/t/testdata/key.private vendored Normal file
View File

@@ -0,0 +1,13 @@
Private-key-format: v1.2
Algorithm: 7 (NSEC3RSASHA1)
Modulus: +D+CE6ST+vFtbnXLdNESSprWSpbpRqEyri20vOx/JIViYdflGQyT0SDWSAE0JqtRlq73qSTDNuR3KWG/57oQQQ5P/wdQaF4TXA/nGjQJPEnhwKVUPVl5WRvqJLpW3C5xSSkhUkwjCp8y6z4NkbX0x7kum9ZTyTai6hkAhjyXu56yXAHX80DWadGK7RmX4JNlJalp2O33hJmakw8BVpgM9yaN4TixVsmZyHLi4hLjMAsjkEEJnfV8WoMEyyjs4kdKDHQAIa854loRcOluT1FiBKgecVAjDu/mkxnqYedN68Yx/wi7D+eClGf/gZjsmuoKKxCxnvDkRCKxrdMJtrsduw==
PublicExponent: AQAB
PrivateExponent: A8m0SmhweZvFd7IEcLvf85N5QZob5SAAjffUki1poz0Fy0hoDoHKn55IpsCd8xkaHZp93O7aq7PAvbjoHLkSFmwJfHK4H1+QHA+CDzxMB8d40l+zcVw0Jc/vOrA9Mw7iW6NtBrxyrG7RcBV6T4bfPUzuESKsFJ3oznmjMGksR4iUrnYAoUgi1pCQlxhSkPM74YhNWbUxYr4gRlL2xGGcJ2qMM8KG06or/Ok+d4bxnxiDBo41THik8ptfu/DL3HrJLOJ1CrvZGy9Q3uFiCvfD9Sk+eOZz1XPkJrUDKGYGoUvZc8enStXSM+TKd3EQy5owjJt+j2h0JdYJM8pxF2EWwQ==
Prime1: /5r4e+6kJS/+UJ0DMenJGm0vxfgFHvk5yLfz+1sKd6C9qQJN5da1m6kWuPdtBG7XGhZb8cJPOfK//g9hVS9GYEDyYmhYZsPTL+1vkiecDpeEQkrf4RCtU7NXLNT/AVNe01iEnIGuKbva6z19P1hjNO23d7LXHil1oULM1W8O1Z8=
Prime2: +KGhJOe+dB5Ud9cFlspMIIpZKHvoDc8VUb2avnhicDX5YC8dVS3nBoyc1cBNgxi4nSvBSl8/fwNT1cHJsPj7Xp2FOAsIBITRnmQt2P5JDpTEuMkEjMT8h/gJ8WnJ0+/VQhLG6rfsSAXdXvVhP4VYttPdiQ0fAe8b5v2MH1VzamU=
Exponent1: UWCEVeifR9ukywOCHeUBirFScWPKNZdBR18RhWfxyC5b07ARHuihvyIxQsg7ZBrpzrtpoGmtkZRwfbFl2poHfOOQh7YS1vzngq3ERLLpo1en2vc9mckWdbx2N6bEXSau3Pikl7NNwKm3RAe6lW1NgG9iZvCAPnESqzm6PwVxop8=
Exponent2: FMsnt/dttTZoKBGilQbcMQiBBmK+eJEuHkT2MSHOUcYh0gp+sIYDQUf3QeUwVlt17ScgpkCrBctYcpMfdB6On04bOyGpDP+yrEWClBhIMeD9RtsA92juGc0Dv93yFDiFpF3/pte0+h0Lc4qgFHjpf3jemTywsC+4LKxd0K0L1wU=
Coefficient: klnXksRr0Z8HPLASytPt4EeBK3Md7MM+Ihm6DIM5PA/KO9k0s8231hspcxBDj37HYwJ7eD77svUJFzdUOqIT8gChc6uq9VI9NFggs8rn4EndoEe+zU477NpL4U09LMfbAN+NATkhDWabVIQBeGqpIAR0fxFIqGhDtkiLyNqhq3c=
Created: 20120614100023
Publish: 20120614100023
Activate: 20120614100023

17
zonemaster-ldns/ldns/contrib/DNS-LDNS/t/testdata/myzone.org vendored Normal file
View File

@@ -0,0 +1,17 @@
$TTL 4500
$ORIGIN myzone.org.
myzone.org. 1000 IN SOA (
ldns.myzone.org.
ns.ldns.myzone.org.
2012113030
12345
1827
2345678
87654 )
ns.ldns A 192.168.100.2
ns2 5600 IN AAAA 2001:dead:dead::2
ns2 6600 IN A 192.168.100.7
ns1 3600 IN A 192.168.100.2
ns1 4600 IN AAAA 2001:dead:dead::1

3
zonemaster-ldns/ldns/contrib/DNS-LDNS/t/testdata/resolv.conf vendored Normal file
View File

@@ -0,0 +1,3 @@
nameserver 127.0.0.1
nameserver 192.168.100.1
search foo.bar.org

75
zonemaster-ldns/ldns/contrib/DNS-LDNS/t/zone.t Normal file
View File

@@ -0,0 +1,75 @@
use Test::More tests => 16;
use FindBin qw/$Bin/;
use DNS::LDNS ':all';
BEGIN { use_ok('DNS::LDNS') };
# Create a new zone
my $z = new DNS::LDNS::Zone;
isa_ok($z, 'DNS::LDNS::Zone', 'Create an empty zone');
# Fill inn a soa and some rrs
$z->set_soa(new DNS::LDNS::RR(str => join(' ', qw/myzone.org 1000 IN SOA
hostmaster.myzone.org. master.myzone.org. 2012113030 12345 1827 2345678
87654/)));
is($z->soa->dname, 'myzone.org.', 'Found soa record');
my $rrs = new DNS::LDNS::RRList;
$rrs->push(new DNS::LDNS::RR(str => 'ns2.myzone.org 3600 IN A 192.168.100.2'),
new DNS::LDNS::RR(str => 'ns2.myzone.org 3600 IN A 192.168.100.9'),
new DNS::LDNS::RR(str => 'ns3.myzone.org 3600 IN A 192.168.100.2'),
new DNS::LDNS::RR(str => 'ns1.myzone.org 3600 IN A 192.168.100.7'));
$z->set_rrs($rrs);
is($z->rrs->rr(0)->to_string, "ns2.myzone.org.\t3600\tIN\tA\t192.168.100.2\n",
'Check first rr');
is($z->rrs->rr(3)->to_string, "ns1.myzone.org.\t3600\tIN\tA\t192.168.100.7\n",
'Check last rr');
$z->sort;
is($z->rrs->rr(0)->to_string, "ns1.myzone.org.\t3600\tIN\tA\t192.168.100.7\n",
'Check first rr after sorting');
is($z->rrs->rr(3)->to_string, "ns3.myzone.org.\t3600\tIN\tA\t192.168.100.2\n",
'Check last rr after sorting');
# Read a zone from file
my $z2 = new DNS::LDNS::Zone(
filename => "$Bin/testdata/myzone.org", ttl => 100);
$z2->canonicalize;
like($z2->to_string, qr/\nns.ldns.myzone.org.\s+/, 'Canonicalize');
like($z2->to_string, qr/^myzone.org.\s+1000\s+IN\s+SOA\s+ldns.myzone.org.\s+ns.ldns.myzone.org.\s+2012113030\s+12345\s+1827\s+2345678\s+87654\s+/, 'Found soa rec');
like($z2->to_string, qr/ns.ldns.myzone.org.\s+4500\s+IN\s+A\s+192.168.100.2/, 'Found ns rec');
like($z2->to_string, qr/ns2.myzone.org.\s+5600\s+IN\s+AAAA\s+2001:dead:dead::2/, 'Found yet another ns rec');
is($z2->rrs->rr_count, 5, 'Zone has 5 rrs');
my $klist = new DNS::LDNS::KeyList;
$klist->push(new DNS::LDNS::Key(filename => "$Bin/testdata/key.private"));
$klist->key(0)->set_pubkey_owner(
new DNS::LDNS::RData(LDNS_RDF_TYPE_DNAME, 'myzone.org'));
my $z3 = $z2->sign($klist);
my $sigc = grep { $z3->rrs->rr($_)->type == LDNS_RR_TYPE_RRSIG }
(0 .. $z3->rrs->rr_count - 1);
is($sigc, 10, 'Signed zone has 10 signatures');
my $nsecc = grep { $z3->rrs->rr($_)->type == LDNS_RR_TYPE_NSEC }
(0 .. $z3->rrs->rr_count - 1);
is($nsecc, 4, 'Signed zone has 3 nsec recs');
my $z4 = $z2->sign_nsec3($klist, 1, 0, 2, 'ABC');
my $sigc3 = grep { $z4->rrs->rr($_)->type == LDNS_RR_TYPE_RRSIG }
(0 .. $z4->rrs->rr_count - 1);
is($sigc3, 12, 'NSEC3-signed zone has 12 signatures');
my $nsecc3 = grep { $z4->rrs->rr($_)->type == LDNS_RR_TYPE_NSEC3 }
(0 .. $z4->rrs->rr_count - 1);
is($nsecc3, 5, 'NSEC3-signed zone has 5 nsec recs');

71
zonemaster-ldns/ldns/contrib/DNS-LDNS/typemap Normal file
View File

@@ -0,0 +1,71 @@
TYPEMAP
DNS__LDNS__Zone LDNS_GENERIC_STRUCT
DNS__LDNS__RRList LDNS_GENERIC_STRUCT
DNS__LDNS__RR LDNS_GENERIC_STRUCT
DNS__LDNS__RData LDNS_GENERIC_STRUCT
DNS__LDNS__DNSSecZone LDNS_GENERIC_STRUCT
DNS__LDNS__DNSSecRRSets LDNS_GENERIC_STRUCT
DNS__LDNS__DNSSecRRs LDNS_GENERIC_STRUCT
DNS__LDNS__DNSSecName LDNS_GENERIC_STRUCT
DNS__LDNS__RBTree LDNS_GENERIC_STRUCT
DNS__LDNS__RBNode LDNS_GENERIC_STRUCT
DNS__LDNS__Resolver LDNS_GENERIC_STRUCT
DNS__LDNS__Packet LDNS_GENERIC_STRUCT
DNS__LDNS__Key LDNS_GENERIC_STRUCT
DNS__LDNS__KeyList LDNS_GENERIC_STRUCT
DNS__LDNS__DNSSecDataChain LDNS_GENERIC_STRUCT
DNS__LDNS__DNSSecTrustTree LDNS_GENERIC_STRUCT
Mortal_PV Mortal_PV
DNS__LDNS__RR__Opt LDNS_GENERIC_STRUCT_OPT
DNS__LDNS__RData__Opt LDNS_GENERIC_STRUCT_OPT
LDNS_Pkt_Opcode T_ENUM
LDNS_Pkt_Rcode T_ENUM
LDNS_Pkt_Section T_ENUM
LDNS_Pkt_Type T_ENUM
LDNS_RR_Type T_ENUM
LDNS_RR_Class T_ENUM
LDNS_RDF_Type T_ENUM
LDNS_Hash T_ENUM
LDNS_Status T_ENUM
LDNS_Signing_Algorithm T_ENUM
uint32_t T_UV
uint16_t T_UV
uint8_t T_UV
signed char T_UV
INPUT
LDNS_GENERIC_STRUCT_OPT
if (!SvOK($arg)) {
$var = NULL;
}
else if (sv_derived_from($arg, \"${(my $ntt=$ntype)=~s/__/::/g;$ntt=~s/::Opt$//;\$ntt}\")){
IV tmp = SvIV((SV*)SvRV($arg));
$var = INT2PTR($type, tmp);
}
else
croak(\"$var is not of type ${(my $ntt=$ntype)=~s/__/::/g;$ntt=~s/::Opt$//;\$ntt}\")
INPUT
LDNS_GENERIC_STRUCT
if (sv_derived_from($arg, \"${(my $ntt=$ntype)=~s/__/::/g;\$ntt}\")){
IV tmp = SvIV((SV*)SvRV($arg));
$var = INT2PTR($type, tmp);
}
else
croak(\"$var is not of type ${(my $ntt=$ntype)=~s/__/::/g;\$ntt}\")
OUTPUT
LDNS_GENERIC_STRUCT
sv_setref_pv($arg, \"${(my $ntt=$ntype)=~s/__/::/g;\$ntt}\", (void*)$var);
OUTPUT
LDNS_GENERIC_STRUCT_OPT
sv_setref_pv($arg, \"${(my $ntt=$ntype)=~s/__/::/g;$ntt=~s/::Opt$//;\$ntt}\", (void*)$var);
OUTPUT
Mortal_PV
sv_setsv($arg, sv_2mortal(newSVpv($var, 0)));
free((void *)$var);