iterations results from the CPAN

DNS-LDNS

view release on metacpan or search on metacpan

}

#endif


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

INCLUDE: const-xs.inc

const char *
ldns_get_errorstr_by_id(s)
	LDNS_Status s
	ALIAS:
	errorstr_by_id = 1

Mortal_PV
ldns_rr_type2str(type)
	LDNS_RR_Type type;
	ALIAS:
	rr_type2str = 1

Mortal_PV
ldns_rr_class2str(class)
	LDNS_RR_Class class;
	ALIAS:
	rr_class2str = 1

Mortal_PV
ldns_pkt_opcode2str(opcode)
	LDNS_Pkt_Opcode opcode;
	ALIAS:
	pkt_opcode2str = 1

Mortal_PV
ldns_pkt_rcode2str(rcode)
	LDNS_Pkt_Rcode rcode;
	ALIAS:
	pkt_rcode2str = 1

LDNS_RR_Type
ldns_get_rr_type_by_name(name)
	char * name;
	ALIAS:
	rr_type_by_name = 1

LDNS_RR_Class
ldns_get_rr_class_by_name(name)
	char * name;
	ALIAS:
	rr_class_by_name = 1

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_key_algo_supported(algorithm)
	int algorithm;
	ALIAS:
	key_algorithm_supported = 1

DNS__LDNS__RR
ldns_read_anchor_file(filename)
	char * filename;
	ALIAS:
	read_anchor_file = 1

MODULE = DNS::LDNS           PACKAGE = DNS::LDNS::GC

void
ldns_zone_deep_free(zone)
	DNS__LDNS__Zone zone;
	ALIAS:
	_zone_deep_free = 1

void
ldns_rr_list_deep_free(list)
	DNS__LDNS__RRList list;
	ALIAS:
	_rrlist_deep_free = 1

void
ldns_rr_free(rr)
	DNS__LDNS__RR rr;
	ALIAS:
	_rr_free = 1

void
ldns_rdf_deep_free(rdf)
	DNS__LDNS__RData rdf;
	ALIAS:
	_rdata_deep_free = 1

void
ldns_dnssec_zone_deep_free(zone)
	DNS__LDNS__DNSSecZone zone;
	ALIAS:
	_dnssec_zone_deep_free = 1

void
ldns_dnssec_name_deep_free(name)
	DNS__LDNS__DNSSecName name;
	ALIAS:
	_dnssec_name_deep_free = 1

void

LDNS.xs view on Meta::CPAN

	FILE* fp;
	CODE:
	ldns_zone_print(fp, zone);

void
canonicalize(zone)
	DNS__LDNS__Zone zone;
	PREINIT:
	    ldns_rr_list *list;
	    size_t count;
	    size_t i;
	CODE:
	list = ldns_zone_rrs(zone);
	count = ldns_rr_list_rr_count(list);

	ldns_rr2canonical(ldns_zone_soa(zone));
	for (i = 0; i < ldns_rr_list_rr_count(ldns_zone_rrs(zone)); i++) {
	    ldns_rr2canonical(ldns_rr_list_rr(ldns_zone_rrs(zone), i));
	}

void
ldns_zone_sort(zone)
	DNS__LDNS__Zone zone;
	ALIAS:
	sort = 1

DNS__LDNS__RR
ldns_zone_soa(zone)
	DNS__LDNS__Zone zone;
	ALIAS:
	_soa = 1

void
ldns_zone_set_soa(zone, soa)
	DNS__LDNS__Zone zone;
	DNS__LDNS__RR soa;
	ALIAS:
	_set_soa = 1

DNS__LDNS__RRList
ldns_zone_rrs(zone)
	DNS__LDNS__Zone zone;
	ALIAS:
	_rrs = 1

void
ldns_zone_set_rrs(zone, list)
	DNS__LDNS__Zone zone;
	DNS__LDNS__RRList list;
	ALIAS:
	_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()
	ALIAS:
	_new = 1

DNS__LDNS__RRList
_new_hosts_from_file(fp, line_nr)
	FILE * fp;
	int line_nr;
	CODE:
	RETVAL = ldns_get_rr_list_hosts_frm_fp_l(fp, &line_nr);
	OUTPUT:
	RETVAL

DNS__LDNS__RRList
ldns_rr_list_clone(list)
	DNS__LDNS__RRList list;
	ALIAS:
	clone = 1

void
print(list, fp)
	DNS__LDNS__RRList list;
	FILE* fp;
	CODE:
	ldns_rr_list_print(fp, list);

Mortal_PV
ldns_rr_list2str(list)
	DNS__LDNS__RRList list;
	ALIAS:
	to_string = 1

DNS__LDNS__RR
ldns_rr_list_rr(list, i)
	DNS__LDNS__RRList list;
	size_t i;
	ALIAS:
	_rr = 1

DNS__LDNS__RR
ldns_rr_list_pop_rr(list)
	DNS__LDNS__RRList list;
	ALIAS:
	pop = 1

bool
ldns_rr_list_push_rr(list, rr)
	DNS__LDNS__RRList list;
	DNS__LDNS__RR rr;
	ALIAS:
	_push = 1

LDNS.xs view on Meta::CPAN


DNS__LDNS__RData
ldns_rr_dnskey_flags(rr)
	DNS__LDNS__RR rr;
	ALIAS:
	_dnskey_flags = 1

bool
ldns_rr_dnskey_set_flags(rr, rdf)
	DNS__LDNS__RR rr;
	DNS__LDNS__RData rdf;
	ALIAS:
	_dnskey_set_flags = 1

DNS__LDNS__RData
ldns_rr_dnskey_protocol(rr)
	DNS__LDNS__RR rr;
	ALIAS:
	_dnskey_protocol = 1

bool
ldns_rr_dnskey_set_protocol(rr, rdf)
	DNS__LDNS__RR rr;
	DNS__LDNS__RData rdf;
	ALIAS:
	_dnskey_set_protocol = 1

DNS__LDNS__RData
ldns_rr_dnskey_key(rr)
	DNS__LDNS__RR rr;
	ALIAS:
	_dnskey_key = 1

bool
ldns_rr_dnskey_set_key(rr, rdf)
	DNS__LDNS__RR rr;
	DNS__LDNS__RData rdf;
	ALIAS:
	_dnskey_set_key = 1

size_t
ldns_rr_dnskey_key_size(rr)
	DNS__LDNS__RR rr;
	ALIAS:
	dnskey_key_size = 1

uint16_t
ldns_calc_keytag(key)
	DNS__LDNS__RR key;
	ALIAS:
	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:
	_verify_denial = 1

LDNS_Status
ldns_dnssec_verify_denial_nsec3(rr, nsecs, rrsigs, packet_rcode, packet_qtype, packet_nodata)
	DNS__LDNS__RR rr;
	DNS__LDNS__RRList nsecs;
	DNS__LDNS__RRList rrsigs;
	LDNS_Pkt_Rcode packet_rcode;
	LDNS_RR_Type packet_qtype;
	signed char packet_nodata;
	ALIAS:
	_verify_denial_nsec3 = 1

DNS__LDNS__RR
_verify_denial_nsec3_match(rr, nsecs, rrsigs, packet_rcode, packet_qtype, packet_nodata, status)
	DNS__LDNS__RR rr;
	DNS__LDNS__RRList nsecs;
	DNS__LDNS__RRList rrsigs;
	LDNS_Pkt_Rcode packet_rcode;
	LDNS_RR_Type packet_qtype;
	signed char packet_nodata;
	LDNS_Status status;
	PREINIT:
	    ldns_rr ** match;
	CODE:
	RETVAL = NULL;
	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;
	ALIAS:
	_nsec3_bitmap = 1

DNS__LDNS__RData
ldns_nsec3_salt(nsec3)
	DNS__LDNS__RR nsec3;
	ALIAS:
	_nsec3_salt = 1

DNS__LDNS__RR
ldns_key_rr2ds(key, hash)
        DNS__LDNS__RR key;
	LDNS_Hash hash;
	ALIAS:
	key_to_ds = 1

bool
ldns_rr_is_question(rr)
        DNS__LDNS__RR rr;
	ALIAS:
	is_question = 1

uint8_t
ldns_rr_label_count(rr)
        DNS__LDNS__RR rr;
	ALIAS:
	label_count = 1

MODULE = DNS::LDNS		PACKAGE = DNS::LDNS::RData

PROTOTYPES: ENABLE

DNS__LDNS__RData
ldns_rdf_new_frm_str(type, str)
	LDNS_RDF_Type type;
	const char *str;
	ALIAS:
	_new = 1

DNS__LDNS__RData
ldns_rdf_clone(rdf)
	DNS__LDNS__RData rdf;
	ALIAS:
	clone = 1

Mortal_PV
ldns_rdf2str(rdf)
	DNS__LDNS__RData rdf;
	ALIAS:
	to_string = 1

LDNS.xs view on Meta::CPAN

LDNS_Status
ldns_dnssec_zone_add_rr(zone, rr)
	DNS__LDNS__DNSSecZone zone;
	DNS__LDNS__RR	 rr;
	ALIAS:
	_add_rr = 1

LDNS_Status
ldns_dnssec_zone_add_empty_nonterminals(zone)
	DNS__LDNS__DNSSecZone zone;
	ALIAS:
	_add_empty_nonterminals = 1

LDNS_Status
ldns_dnssec_zone_mark_glue(zone)
	DNS__LDNS__DNSSecZone zone;
	ALIAS:
	_mark_glue = 1

DNS__LDNS__DNSSecName
_soa(zone)
	DNS__LDNS__DNSSecZone zone;
	CODE:
	RETVAL = zone->soa;
	OUTPUT:
	RETVAL

DNS__LDNS__RBTree
_names(zone)
	DNS__LDNS__DNSSecZone zone;
	CODE:
	RETVAL = zone->names;
	OUTPUT:
	RETVAL

DNS__LDNS__DNSSecRRSets
ldns_dnssec_zone_find_rrset(zone, rdf, type)
	DNS__LDNS__DNSSecZone zone;
	DNS__LDNS__RData rdf;
	LDNS_RR_Type type;
	ALIAS:
	_find_rrset = 1

LDNS_Status
_sign(zone, key_list, policy, flags)
	DNS__LDNS__DNSSecZone zone;
	DNS__LDNS__KeyList key_list;
	uint16_t policy;
	int flags;
	PREINIT:
	    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;
	PREINIT:
	     ldns_rr_list * new_rrs;
	CODE:
	new_rrs = ldns_rr_list_new();
	RETVAL = ldns_dnssec_zone_create_rrsigs_flg(zone, new_rrs, key_list, 
	    sign_policy, (void*)&policy, flags);
	ldns_rr_list_free(new_rrs);
	OUTPUT:
	RETVAL


MODULE = DNS::LDNS		PACKAGE = DNS::LDNS::DNSSecRRSets

DNS__LDNS__DNSSecRRs
_rrs(rrsets)
	DNS__LDNS__DNSSecRRSets rrsets;
	CODE:
	RETVAL = rrsets->rrs;
	OUTPUT:
	RETVAL

DNS__LDNS__DNSSecRRs
_signatures(rrsets)
	DNS__LDNS__DNSSecRRSets rrsets;
	CODE:
	RETVAL = rrsets->signatures;
	OUTPUT:
	RETVAL

bool
ldns_dnssec_rrsets_contains_type(rrsets, type)
	DNS__LDNS__DNSSecRRSets rrsets;
	LDNS_RR_Type type;
	ALIAS:
	contains_type = 1

LDNS_RR_Type
ldns_dnssec_rrsets_type(rrsets)
	DNS__LDNS__DNSSecRRSets rrsets;
	ALIAS:
	type = 1

LDNS_Status
ldns_dnssec_rrsets_set_type(rrsets, type)
	DNS__LDNS__DNSSecRRSets rrsets;
	LDNS_RR_Type type;
	ALIAS:
	_set_type = 1

DNS__LDNS__DNSSecRRSets

( run in 3.684 seconds using v1.01-cache-2.11-cpan-364913b4093 )