DNS-LDNS

 view release on metacpan or  search on metacpan

LDNS.xs  view on Meta::CPAN

DNS__LDNS__RR
ldns_dnssec_create_nsec(from, to, nsec_type)
	DNS__LDNS__DNSSecName from;
	DNS__LDNS__DNSSecName to;
	LDNS_RR_Type nsec_type;
	ALIAS:
	dnssec_create_nsec = 1

DNS__LDNS__RR
dnssec_create_nsec3(from, to, zone_name, algorithm, flags, iterations, salt)
	DNS__LDNS__DNSSecName from;
	DNS__LDNS__DNSSecName to;
	DNS__LDNS__RData zone_name;
	uint8_t algorithm;
	uint8_t flags;
	uint16_t iterations;
	char * salt;
	CODE:
	RETVAL = ldns_dnssec_create_nsec3(from, to, zone_name, algorithm, flags, iterations, strlen(salt), (uint8_t*)salt);
	OUTPUT:
	RETVAL

DNS__LDNS__RR
ldns_create_nsec(current, next, rrs)
	DNS__LDNS__RData current;
	DNS__LDNS__RData next;
	DNS__LDNS__RRList rrs;
	ALIAS:
	create_nsec = 1

DNS__LDNS__RR
create_nsec3(cur_owner, cur_zone, rrs, algorithm, flags, iterations, salt, emptynonterminal)
	DNS__LDNS__RData cur_owner;
	DNS__LDNS__RData cur_zone;
	DNS__LDNS__RRList rrs;
	uint8_t algorithm;
	uint8_t flags;
	uint16_t iterations;
	char * salt;
	bool emptynonterminal;
	CODE:
	RETVAL = ldns_create_nsec3(cur_owner, cur_zone, rrs, algorithm, 
	    flags, iterations, strlen(salt), (uint8_t*)salt, emptynonterminal);
	OUTPUT:
	RETVAL

LDNS_Signing_Algorithm
ldns_get_signing_algorithm_by_name(name)
	const char * name;
	ALIAS:
	signing_algorithm_by_name = 1

int

LDNS.xs  view on Meta::CPAN

	_set_rrs = 1

DNS__LDNS__Zone
ldns_zone_sign(zone, keylist)
	DNS__LDNS__Zone zone;
	DNS__LDNS__KeyList keylist;
	ALIAS:
	sign = 1

DNS__LDNS__Zone
sign_nsec3(zone, keylist, algorithm, flags, iterations, salt)
	DNS__LDNS__Zone zone;
	DNS__LDNS__KeyList keylist;
	uint8_t algorithm;
	uint8_t flags;
	uint16_t iterations;
	unsigned char * salt;
	CODE:
	RETVAL = ldns_zone_sign_nsec3(zone, keylist, algorithm, flags, iterations, strlen(salt), (uint8_t*)salt);
	OUTPUT:
	RETVAL


MODULE = DNS::LDNS		PACKAGE = DNS::LDNS::RRList

PROTOTYPES: ENABLE

DNS__LDNS__RRList
ldns_rr_list_new()

LDNS.xs  view on Meta::CPAN

	calc_keytag = 1

DNS__LDNS__RData
ldns_nsec3_hash_name_frm_nsec3(rr, name)
	DNS__LDNS__RR rr;
	DNS__LDNS__RData name;
	ALIAS:
	_hash_name_from_nsec3 = 1

DNS__LDNS__RData
_nsec3_hash_name(name, algorithm, iterations, salt)
	DNS__LDNS__RData name;
	uint8_t algorithm;
	uint16_t iterations;
	char * salt;
	CODE:
	RETVAL = ldns_nsec3_hash_name(name, algorithm, iterations, 
	    strlen(salt), (uint8_t *)salt);
	OUTPUT:
	RETVAL

LDNS_Status
ldns_dnssec_verify_denial(rr, nsecs, rrsigs)
	DNS__LDNS__RR rr;
	DNS__LDNS__RRList nsecs;
	DNS__LDNS__RRList rrsigs;
	ALIAS:

LDNS.xs  view on Meta::CPAN

	status = ldns_dnssec_verify_denial_nsec3_match(rr, nsecs, rrsigs, 
	    packet_rcode, packet_qtype, packet_nodata, match);
	if (status == LDNS_STATUS_OK) {
	    RETVAL = *match;
	}
	OUTPUT:
	status
	RETVAL

void
nsec3_add_param_rdfs(rr, algorithm, flags, iterations, salt)
	DNS__LDNS__RR rr;
	uint8_t algorithm;
	uint8_t flags;
	uint16_t iterations;
	char * salt;
	CODE:
	ldns_nsec3_add_param_rdfs(rr, algorithm, flags, iterations, strlen(salt), (uint8_t*)salt);

uint8_t
ldns_nsec3_algorithm(nsec3)
	DNS__LDNS__RR nsec3;
	ALIAS:
	nsec3_algorithm = 1

uint8_t
ldns_nsec3_flags(nsec3)
	DNS__LDNS__RR nsec3;
	ALIAS:
	nsec3_flags = 1

bool
ldns_nsec3_optout(nsec3)
	DNS__LDNS__RR nsec3;
	ALIAS:
	nsec3_optout = 1

uint16_t
ldns_nsec3_iterations(nsec3)
	DNS__LDNS__RR nsec3;
	ALIAS:
	nsec3_iterations = 1

DNS__LDNS__RData
ldns_nsec3_next_owner(nsec3)
	DNS__LDNS__RR nsec3;
	ALIAS:
	_nsec3_next_owner = 1

DNS__LDNS__RData
ldns_nsec3_bitmap(nsec3)
	DNS__LDNS__RR nsec3;

LDNS.xs  view on Meta::CPAN

	    ldns_rr_list * new_rrs;
	CODE:
	new_rrs = ldns_rr_list_new();
	RETVAL = ldns_dnssec_zone_sign_flg(zone, new_rrs, key_list, 
	    sign_policy, (void*)&policy, flags);
	ldns_rr_list_free(new_rrs);
	OUTPUT:
	RETVAL

LDNS_Status
_sign_nsec3(zone, key_list, policy, algorithm, flags, iterations, salt, signflags)
	DNS__LDNS__DNSSecZone zone;
	DNS__LDNS__KeyList key_list;
	uint16_t policy;
	uint8_t algorithm;
	uint8_t flags;
	uint16_t iterations;
	char * salt;
	int signflags;
	PREINIT:
	     ldns_rr_list * new_rrs;
	CODE:
	new_rrs = ldns_rr_list_new();
	RETVAL = ldns_dnssec_zone_sign_nsec3_flg(zone, new_rrs, key_list, 
	    sign_policy, (void*)&policy, algorithm, flags, iterations, 
	    strlen(salt), (uint8_t*)salt, signflags);
	ldns_rr_list_free(new_rrs);
	OUTPUT:
	RETVAL

LDNS_Status
create_nsecs(zone)
	DNS__LDNS__DNSSecZone zone;
	PREINIT:
	    ldns_rr_list * new_rrs;
	CODE:
	new_rrs = ldns_rr_list_new();
	RETVAL = ldns_dnssec_zone_create_nsecs(zone, new_rrs);
	ldns_rr_list_free(new_rrs);
	OUTPUT:
	RETVAL

LDNS_Status
create_nsec3s(zone, algorithm, flags, iterations, salt)
	DNS__LDNS__DNSSecZone zone;
	uint8_t algorithm;
	uint8_t flags;
	uint8_t iterations;
	char * salt;
	PREINIT:
	    ldns_rr_list * new_rrs;
	CODE:
	new_rrs = ldns_rr_list_new();
	RETVAL = ldns_dnssec_zone_create_nsec3s(zone, new_rrs, algorithm,
	    flags, iterations, strlen(salt), (uint8_t*)salt);
	ldns_rr_list_free(new_rrs);
	OUTPUT:
	RETVAL

LDNS_Status
create_rrsigs(zone, key_list, policy, flags)
	DNS__LDNS__DNSSecZone zone;
	DNS__LDNS__KeyList key_list;
	uint16_t policy;
	int flags;

lib/DNS/LDNS.pm  view on Meta::CPAN

  str = rr_type2str(type)
  str = rr_class2str(class)
  type = rr_type_by_name(str)
  class = rr_class_by_name(str)
  str = pkt_opcode2str(opcode)
  str = pkt_rcode2str(rcode)
  error = errorstr_by_id(status)
  str = DNS::LDNS::last_error
  status = DNS::LDNS::last_status
  rr = dnssec_create_nsec(from, to, type)
  rr = dnssec_create_nsec3(from, to, algorithm, flags, iterations, salt)
  rr = create_nsec(current, next, rrs)
  rr = create_nsec3(cur_owner, cur_zone, algorithm, flags,
                    iterations, salt, empty_nonterminals)
  algo = signing_algorithm_by_name(name)
  bool = key_algorithm_supported(algorithm)
  rr = read_anchor_file(filename)

=head2 Object references and cloning

Since some of the objects are found as sub objects within other
objects, it  is important to know how the wrapper classes handle
object references,  dependencies and cloning. The general rule is that
accessor methods just  return a reference to the object while methods

lib/DNS/LDNS/DNSSecZone.pm  view on Meta::CPAN

}

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]);

lib/DNS/LDNS/DNSSecZone.pm  view on Meta::CPAN

  my z = DNS::LDNS::DNSSecZone->new

  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

lib/DNS/LDNS/RData.pm  view on Meta::CPAN

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

lib/DNS/LDNS/RData.pm  view on Meta::CPAN

  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

lib/DNS/LDNS/RR.pm  view on Meta::CPAN

  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)

lib/DNS/LDNS/Zone.pm  view on Meta::CPAN

  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