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

- 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>

zonemaster-ldns/ldns/contrib/DNS-LDNS/lib/DNS/LDNS/DNSSecDataChain.pm

@@ -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

zonemaster-ldns/ldns/contrib/DNS-LDNS/lib/DNS/LDNS/DNSSecName.pm

@@ -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

zonemaster-ldns/ldns/contrib/DNS-LDNS/lib/DNS/LDNS/DNSSecRRSets.pm

@@ -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

zonemaster-ldns/ldns/contrib/DNS-LDNS/lib/DNS/LDNS/DNSSecRRs.pm

@@ -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

zonemaster-ldns/ldns/contrib/DNS-LDNS/lib/DNS/LDNS/DNSSecTrustTree.pm

@@ -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

zonemaster-ldns/ldns/contrib/DNS-LDNS/lib/DNS/LDNS/DNSSecZone.pm

@@ -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

zonemaster-ldns/ldns/contrib/DNS-LDNS/lib/DNS/LDNS/GC.pm

@@ -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

zonemaster-ldns/ldns/contrib/DNS-LDNS/lib/DNS/LDNS/Key.pm

@@ -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

zonemaster-ldns/ldns/contrib/DNS-LDNS/lib/DNS/LDNS/KeyList.pm

@@ -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

zonemaster-ldns/ldns/contrib/DNS-LDNS/lib/DNS/LDNS/Packet.pm

@@ -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

zonemaster-ldns/ldns/contrib/DNS-LDNS/lib/DNS/LDNS/RBNode.pm

@@ -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

zonemaster-ldns/ldns/contrib/DNS-LDNS/lib/DNS/LDNS/RBTree.pm

@@ -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

zonemaster-ldns/ldns/contrib/DNS-LDNS/lib/DNS/LDNS/RData.pm

@@ -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

zonemaster-ldns/ldns/contrib/DNS-LDNS/lib/DNS/LDNS/RR.pm

@@ -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

zonemaster-ldns/ldns/contrib/DNS-LDNS/lib/DNS/LDNS/RRList.pm

@@ -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

zonemaster-ldns/ldns/contrib/DNS-LDNS/lib/DNS/LDNS/Resolver.pm

@@ -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

zonemaster-ldns/ldns/contrib/DNS-LDNS/lib/DNS/LDNS/Zone.pm

@@ -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