diff options
Diffstat (limited to 'contrib/DNS-LDNS')
41 files changed, 21191 insertions, 0 deletions
diff --git a/contrib/DNS-LDNS/Changes b/contrib/DNS-LDNS/Changes new file mode 100644 index 0000000000000..b718c30222e61 --- /dev/null +++ b/contrib/DNS-LDNS/Changes @@ -0,0 +1,23 @@ +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 diff --git a/contrib/DNS-LDNS/LDNS.xs b/contrib/DNS-LDNS/LDNS.xs new file mode 100644 index 0000000000000..83f09ddee777b --- /dev/null +++ b/contrib/DNS-LDNS/LDNS.xs @@ -0,0 +1,3363 @@ +#include "EXTERN.h" +#include "perl.h" +#include "XSUB.h" + +#include "ppport.h" + +#include "ldns/ldns.h" +#include "ldns/error.h" +#include "ldns/rr.h" +#include "ldns/keys.h" +#include "ldns/dname.h" +#include "ldns/host2str.h" +#include "ldns/rdata.h" +#include "ldns/rbtree.h" +#include "ldns/resolver.h" +#include "ldns/packet.h" +#include "ldns/dnssec.h" + +#include "ldns/dnssec_zone.h" +#include "ldns/dnssec_verify.h" +#include "ldns/dnssec_sign.h" +#include "ldns/rr_functions.h" + +#if LDNS_REVISION < ((1<<16)|(6<<8)|(17)) + #define LDNS_RDF_TYPE_HIP LDNS_RDF_TYPE_TSIG +#endif + +#include "const-c.inc" + +typedef ldns_zone * DNS__LDNS__Zone; +typedef ldns_rr_list * DNS__LDNS__RRList; +typedef ldns_rr * DNS__LDNS__RR; +typedef ldns_rr * DNS__LDNS__RR__Opt; +typedef ldns_rdf * DNS__LDNS__RData; +typedef ldns_rdf * DNS__LDNS__RData__Opt; +typedef ldns_dnssec_zone * DNS__LDNS__DNSSecZone; +typedef ldns_dnssec_rrsets * DNS__LDNS__DNSSecRRSets; +typedef ldns_dnssec_rrs * DNS__LDNS__DNSSecRRs; +typedef ldns_dnssec_name * DNS__LDNS__DNSSecName; +typedef ldns_rbtree_t * DNS__LDNS__RBTree; +typedef ldns_rbnode_t * DNS__LDNS__RBNode; +typedef ldns_resolver * DNS__LDNS__Resolver; +typedef ldns_pkt * DNS__LDNS__Packet; +typedef ldns_key * DNS__LDNS__Key; +typedef ldns_key_list * DNS__LDNS__KeyList; +typedef ldns_dnssec_data_chain * DNS__LDNS__DNSSecDataChain; +typedef ldns_dnssec_trust_tree * DNS__LDNS__DNSSecTrustTree; +typedef const char * Mortal_PV; + +typedef ldns_pkt_opcode LDNS_Pkt_Opcode; +typedef ldns_pkt_rcode LDNS_Pkt_Rcode; +typedef ldns_pkt_section LDNS_Pkt_Section; +typedef ldns_pkt_type LDNS_Pkt_Type; +typedef ldns_rr_type LDNS_RR_Type; +typedef ldns_rr_class LDNS_RR_Class; +typedef ldns_rdf_type LDNS_RDF_Type; +typedef ldns_hash LDNS_Hash; +typedef ldns_status LDNS_Status; +typedef ldns_signing_algorithm LDNS_Signing_Algorithm; + +/* callback function used by the signing methods */ +int sign_policy(ldns_rr *sig, void *n) { + return *(uint16_t*)n; +} + +/* utility methods */ +void add_cloned_rrs_to_list(ldns_rr_list * list, ldns_rr_list * add) { + size_t count; + size_t i; + + count = ldns_rr_list_rr_count(add); + + for(i = 0; i < count; i++) { + ldns_rr_list_push_rr(list, ldns_rr_clone(ldns_rr_list_rr(add, i))); + } +} + + +#if LDNS_REVISION < ((1<<16)|(6<<8)|(12)) +ldns_dnssec_trust_tree *ldns_dnssec_derive_trust_tree_time( + ldns_dnssec_data_chain *data_chain, + ldns_rr *rr, time_t check_time); +ldns_rr_list *ldns_fetch_valid_domain_keys_time(const ldns_resolver * res, + const ldns_rdf * domain, const ldns_rr_list * keys, + time_t check_time, ldns_status *status); +ldns_rr_list *ldns_validate_domain_dnskey_time( + const ldns_resolver *res, const ldns_rdf *domain, + const ldns_rr_list *keys, time_t check_time); +ldns_rr_list *ldns_validate_domain_ds_time( + const ldns_resolver *res, const ldns_rdf *domain, + const ldns_rr_list * keys, time_t check_time); + +ldns_dnssec_trust_tree *ldns_dnssec_derive_trust_tree_time( + ldns_dnssec_data_chain *data_chain, + ldns_rr *rr, time_t check_time) { + Perl_croak(aTHX_ "function ldns_dnssec_derive_trust_tree_time is not implemented in this version of ldns"); +} + +ldns_rr_list *ldns_fetch_valid_domain_keys_time(const ldns_resolver * res, + const ldns_rdf * domain, const ldns_rr_list * keys, + time_t check_time, ldns_status *status) { + Perl_croak(aTHX_ "function ldns_fetch_valid_domain_keys_time is not implemented in this version of ldns"); +} + +ldns_rr_list *ldns_validate_domain_dnskey_time( + const ldns_resolver *res, const ldns_rdf *domain, + const ldns_rr_list *keys, time_t check_time) { + Perl_croak(aTHX_ "function ldns_validate_domain_dnskey_time is not implemented in this version of ldns"); +} + +ldns_rr_list *ldns_validate_domain_ds_time( + const ldns_resolver *res, const ldns_rdf *domain, + const ldns_rr_list * keys, time_t check_time) { + Perl_croak(aTHX_ "function ldns_validate_domain_ds_time is not implemented in this version of ldns"); +} + + +#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_resolver_deep_free(resolver) + DNS__LDNS__Resolver resolver; + ALIAS: + _resolver_deep_free = 1 + +void +ldns_pkt_free(pkt) + DNS__LDNS__Packet pkt; + ALIAS: + _packet_free = 1 + +void +ldns_key_deep_free(key) + DNS__LDNS__Key key; + ALIAS: + _key_deep_free = 1 + +void +ldns_key_list_free(keylist) + DNS__LDNS__KeyList keylist; + ALIAS: + _keylist_free = 1 + +void +ldns_dnssec_data_chain_deep_free(chain) + DNS__LDNS__DNSSecDataChain chain; + ALIAS: + _dnssec_datachain_deep_free = 1 + +void +ldns_dnssec_trust_tree_free(tree) + DNS__LDNS__DNSSecTrustTree tree; + ALIAS: + _dnssec_trusttree_free = 1 + +MODULE = DNS::LDNS PACKAGE = DNS::LDNS::Zone + +PROTOTYPES: ENABLE + +DNS__LDNS__Zone +ldns_zone_new() + ALIAS: + _new = 1 + +DNS__LDNS__Zone +_new_from_file(fp, origin, ttl, c, s, line_nr) + FILE* fp; + DNS__LDNS__RData__Opt origin; + uint32_t ttl; + LDNS_RR_Class c; + LDNS_Status s; + int line_nr; + PREINIT: + ldns_zone *z; + CODE: + if (ttl == 0) { ttl = 0; } + RETVAL = NULL; + s = ldns_zone_new_frm_fp_l(&z, fp, origin, ttl, c, &line_nr); + + if (s == LDNS_STATUS_OK) { + RETVAL = z; + } + + OUTPUT: + RETVAL + s + line_nr + +void +print(zone, fp) + DNS__LDNS__Zone zone; + 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 + +size_t +ldns_rr_list_rr_count(list) + DNS__LDNS__RRList list; + ALIAS: + rr_count = 1 + +int +ldns_rr_list_compare(list, otherlist) + DNS__LDNS__RRList list; + DNS__LDNS__RRList otherlist; + ALIAS: + compare = 1 + +DNS__LDNS__RRList +ldns_rr_list_subtype_by_rdf(list, rdf, pos) + DNS__LDNS__RRList list; + DNS__LDNS__RData rdf; + size_t pos; + ALIAS: + subtype_by_rdata = 1 + +DNS__LDNS__RRList +ldns_rr_list_pop_rrset(list) + DNS__LDNS__RRList list; + ALIAS: + pop_rrset = 1 + +bool +ldns_is_rrset(list) + DNS__LDNS__RRList list; + ALIAS: + is_rrset = 1 + +bool +ldns_rr_list_contains_rr(list, rr) + DNS__LDNS__RRList list; + DNS__LDNS__RR rr; + ALIAS: + contains_rr = 1 + +DNS__LDNS__RRList +ldns_rr_list_pop_rr_list(list, count) + DNS__LDNS__RRList list; + size_t count; + ALIAS: + pop_list = 1 + +bool +_push_list(list, otherlist) + DNS__LDNS__RRList list; + DNS__LDNS__RRList otherlist; + PREINIT: + bool ret; + CODE: + ret = ldns_rr_list_push_rr_list(list, otherlist); + if (ret) { + ldns_rr_list_free(otherlist); + } + OUTPUT: + RETVAL + +LDNS_Status +_verify_rrsig_keylist(rrset, rrsig, keys, good_keys) + DNS__LDNS__RRList rrset; + DNS__LDNS__RR rrsig; + DNS__LDNS__RRList keys; + DNS__LDNS__RRList good_keys; + PREINIT: + DNS__LDNS__RRList gk; + CODE: + gk = ldns_rr_list_new(); + RETVAL = ldns_verify_rrsig_keylist(rrset, rrsig, keys, good_keys); + add_cloned_rrs_to_list(good_keys, gk); + ldns_rr_list_free(gk); + OUTPUT: + RETVAL + +LDNS_Status +_verify_rrsig_keylist_time(rrset, rrsig, keys, check_time, good_keys) + DNS__LDNS__RRList rrset; + DNS__LDNS__RR rrsig; + DNS__LDNS__RRList keys; + time_t check_time; + DNS__LDNS__RRList good_keys; + PREINIT: + DNS__LDNS__RRList gk; + CODE: + gk = ldns_rr_list_new(); + RETVAL = ldns_verify_rrsig_keylist_time( + rrset, rrsig, keys, check_time, good_keys); + add_cloned_rrs_to_list(good_keys, gk); + ldns_rr_list_free(gk); + OUTPUT: + RETVAL + +LDNS_Status +_verify_rrsig_keylist_notime(rrset, rrsig, keys, good_keys) + DNS__LDNS__RRList rrset; + DNS__LDNS__RR rrsig; + DNS__LDNS__RRList keys; + DNS__LDNS__RRList good_keys; + PREINIT: + DNS__LDNS__RRList gk; + CODE: + gk = ldns_rr_list_new(); + RETVAL = ldns_verify_rrsig_keylist_notime(rrset, rrsig, keys, NULL); + add_cloned_rrs_to_list(good_keys, gk); + ldns_rr_list_free(gk); + OUTPUT: + RETVAL + +LDNS_Status +ldns_verify_rrsig(rrset, rrsig, key) + DNS__LDNS__RRList rrset; + DNS__LDNS__RR rrsig; + DNS__LDNS__RR key; + ALIAS: + _verify_rrsig = 1 + +LDNS_Status +ldns_verify_rrsig_time(rrset, rrsig, key, check_time) + DNS__LDNS__RRList rrset; + DNS__LDNS__RR rrsig; + DNS__LDNS__RR key; + time_t check_time; + ALIAS: + _verify_rrsig_time = 1 + +LDNS_Status +_verify(rrset, rrsig, keys, good_keys) + DNS__LDNS__RRList rrset; + DNS__LDNS__RRList rrsig; + DNS__LDNS__RRList keys; + DNS__LDNS__RRList good_keys; + PREINIT: + DNS__LDNS__RRList gk; + CODE: + gk = ldns_rr_list_new(); + RETVAL = ldns_verify(rrset, rrsig, keys, gk); + add_cloned_rrs_to_list(good_keys, gk); + ldns_rr_list_free(gk); + OUTPUT: + RETVAL + +LDNS_Status +_verify_time(rrset, rrsig, keys, check_time, good_keys) + DNS__LDNS__RRList rrset; + DNS__LDNS__RRList rrsig; + DNS__LDNS__RRList keys; + time_t check_time; + DNS__LDNS__RRList good_keys; + PREINIT: + DNS__LDNS__RRList gk; + CODE: + gk = ldns_rr_list_new(); + RETVAL = ldns_verify_time(rrset, rrsig, keys, check_time, gk); + add_cloned_rrs_to_list(good_keys, gk); + ldns_rr_list_free(gk); + OUTPUT: + RETVAL + +LDNS_Status +_verify_notime(rrset, rrsig, keys, good_keys) + DNS__LDNS__RRList rrset; + DNS__LDNS__RRList rrsig; + DNS__LDNS__RRList keys; + DNS__LDNS__RRList good_keys; + PREINIT: + DNS__LDNS__RRList gk; + CODE: + gk = ldns_rr_list_new(); + RETVAL = ldns_verify_notime(rrset, rrsig, keys, gk); + add_cloned_rrs_to_list(good_keys, gk); + ldns_rr_list_free(gk); + OUTPUT: + RETVAL + +DNS__LDNS__RR +ldns_create_empty_rrsig(rrset, current_key) + DNS__LDNS__RRList rrset; + DNS__LDNS__Key current_key; + ALIAS: + create_empty_rrsig = 1 + +DNS__LDNS__RRList +ldns_sign_public(rrset, keys) + DNS__LDNS__RRList rrset; + DNS__LDNS__KeyList keys; + ALIAS: + sign_public = 1 + +void +ldns_rr_list_sort(list) + DNS__LDNS__RRList list; + ALIAS: + sort = 1 + +void +ldns_rr_list_sort_nsec3(list) + DNS__LDNS__RRList list; + ALIAS: + sort_nsec3 = 1 + +void +ldns_rr_list2canonical(list) + DNS__LDNS__RRList list; + ALIAS: + canonicalize = 1 + +DNS__LDNS__RR +ldns_dnssec_get_dnskey_for_rrsig(rr, rrlist) + DNS__LDNS__RR rr; + DNS__LDNS__RRList rrlist; + ALIAS: + _get_dnskey_for_rrsig = 1 + +DNS__LDNS__RR +ldns_dnssec_get_rrsig_for_name_and_type(name, type, rrsigs) + DNS__LDNS__RData name; + LDNS_RR_Type type; + DNS__LDNS__RRList rrsigs; + ALIAS: + _get_rrsig_for_name_and_type = 1 + + +MODULE = DNS::LDNS PACKAGE = DNS::LDNS::RR + +PROTOTYPES: ENABLE + +DNS__LDNS__RR +ldns_rr_new() + ALIAS: + _new = 1 + +DNS__LDNS__RR +ldns_rr_new_frm_type(t) + LDNS_RR_Type t; + ALIAS: + _new_from_type = 1 + +DNS__LDNS__RR +_new_from_str(str, default_ttl, origin, s) + const char* str; + uint32_t default_ttl; + DNS__LDNS__RData__Opt origin; + LDNS_Status s; + PREINIT: + DNS__LDNS__RR rr = NULL; + CODE: + s = ldns_rr_new_frm_str(&rr, str, default_ttl, origin, NULL); + if (s == LDNS_STATUS_OK) { + RETVAL = rr; + } + OUTPUT: + RETVAL + s + +DNS__LDNS__RR +_new_from_file(fp, origin, default_ttl, s, line_nr) + FILE* fp; + DNS__LDNS__RData__Opt origin; + uint32_t default_ttl; + LDNS_Status s; + int line_nr; + PREINIT: + ldns_rr *rr; + ldns_rdf *oclone = NULL; + CODE: + RETVAL = NULL; + /* Clone the origin object because the call may change/replace it and + then it must be freed */ + if (origin) { + oclone = ldns_rdf_clone(origin); + } + s = ldns_rr_new_frm_fp_l(&rr, fp, &default_ttl, &oclone, NULL, + &line_nr); + + if (oclone) { + ldns_rdf_deep_free(oclone); + } + + if (s == LDNS_STATUS_OK) { + RETVAL = rr; + } + + OUTPUT: + RETVAL + s + line_nr + +DNS__LDNS__RR +ldns_rr_clone(rr) + DNS__LDNS__RR rr; + ALIAS: + clone = 1 + +void +ldns_rr_set_owner(rr, owner) + DNS__LDNS__RR rr; + DNS__LDNS__RData owner; + ALIAS: + _set_owner = 1 + +void +ldns_rr_set_ttl(rr, ttl) + DNS__LDNS__RR rr; + uint32_t ttl; + ALIAS: + set_ttl = 1 + +void +ldns_rr_set_type(rr, type) + DNS__LDNS__RR rr; + LDNS_RR_Type type; + ALIAS: + set_type = 1 + +void +ldns_rr_set_class(rr, class) + DNS__LDNS__RR rr; + LDNS_RR_Class class; + ALIAS: + set_class = 1 + +void +print(rr, fp) + DNS__LDNS__RR rr; + FILE* fp; + CODE: + ldns_rr_print(fp, rr); + +Mortal_PV +ldns_rr2str(rr) + DNS__LDNS__RR rr; + ALIAS: + to_string = 1 + +int +ldns_rr_compare(rr, otherrr) + DNS__LDNS__RR rr; + DNS__LDNS__RR otherrr; + ALIAS: + compare = 1 + +int +ldns_rr_compare_no_rdata(rr, otherrr) + DNS__LDNS__RR rr; + DNS__LDNS__RR otherrr; + ALIAS: + compare_no_rdata = 1 + +int +ldns_rr_compare_ds(rr, otherrr) + DNS__LDNS__RR rr; + DNS__LDNS__RR otherrr; + ALIAS: + compare_ds = 1 + +int +compare_dname(rr, otherrr) + DNS__LDNS__RR rr; + DNS__LDNS__RR otherrr; + CODE: + RETVAL = ldns_dname_compare( + ldns_rr_owner(rr), ldns_rr_owner(otherrr)); + OUTPUT: + RETVAL + +DNS__LDNS__RData +ldns_rr_owner(rr) + DNS__LDNS__RR rr; + ALIAS: + _owner = 1 + +size_t +ldns_rr_rd_count(rr); + DNS__LDNS__RR rr; + ALIAS: + rd_count = 1 + +DNS__LDNS__RData +ldns_rr_rdf(rr, i) + DNS__LDNS__RR rr; + size_t i; + ALIAS: + _rdata = 1 + +DNS__LDNS__RData +ldns_rr_set_rdf(rr, rdf, i) + DNS__LDNS__RR rr; + DNS__LDNS__RData rdf; + size_t i; + ALIAS: + _set_rdata = 1 + +uint32_t +ldns_rr_ttl(rr) + DNS__LDNS__RR rr; + ALIAS: + ttl = 1 + +LDNS_RR_Class +ldns_rr_get_class(rr) + DNS__LDNS__RR rr; + ALIAS: + class = 1 + +LDNS_RR_Type +ldns_rr_get_type(rr) + DNS__LDNS__RR rr; + ALIAS: + type = 1 + +DNS__LDNS__RData +ldns_rr_pop_rdf(rr) + DNS__LDNS__RR rr; + ALIAS: + pop_rdata = 1 + +bool +ldns_rr_push_rdf(rr, rdf) + DNS__LDNS__RR rr; + DNS__LDNS__RData rdf; + ALIAS: + _push_rdata = 1 + +DNS__LDNS__RData +ldns_rr_rrsig_typecovered(rr) + DNS__LDNS__RR rr; + ALIAS: + _rrsig_typecovered = 1 + +bool +ldns_rr_rrsig_set_typecovered(rr, rdf) + DNS__LDNS__RR rr; + DNS__LDNS__RData rdf; + ALIAS: + _rrsig_set_typecovered = 1 + +DNS__LDNS__RData +ldns_rr_rrsig_algorithm(rr) + DNS__LDNS__RR rr; + ALIAS: + _rrsig_algorithm = 1 + +bool +ldns_rr_rrsig_set_algorithm(rr, rdf) + DNS__LDNS__RR rr; + DNS__LDNS__RData rdf; + ALIAS: + _rrsig_set_algorithm = 1 + +DNS__LDNS__RData +ldns_rr_rrsig_expiration(rr) + DNS__LDNS__RR rr; + ALIAS: + _rrsig_expiration = 1 + +bool +ldns_rr_rrsig_set_expiration(rr, rdf) + DNS__LDNS__RR rr; + DNS__LDNS__RData rdf; + ALIAS: + _rrsig_set_expiration = 1 + +DNS__LDNS__RData +ldns_rr_rrsig_inception(rr) + DNS__LDNS__RR rr; + ALIAS: + _rrsig_inception = 1 + +bool +ldns_rr_rrsig_set_inception(rr, rdf) + DNS__LDNS__RR rr; + DNS__LDNS__RData rdf; + ALIAS: + _rrsig_set_inception = 1 + +DNS__LDNS__RData +ldns_rr_rrsig_keytag(rr) + DNS__LDNS__RR rr; + ALIAS: + _rrsig_keytag = 1 + +bool +ldns_rr_rrsig_set_keytag(rr, rdf) + DNS__LDNS__RR rr; + DNS__LDNS__RData rdf; + ALIAS: + _rrsig_set_keytag = 1 + +DNS__LDNS__RData +ldns_rr_rrsig_sig(rr) + DNS__LDNS__RR rr; + ALIAS: + _rrsig_sig = 1 + +bool +ldns_rr_rrsig_set_sig(rr, rdf) + DNS__LDNS__RR rr; + DNS__LDNS__RData rdf; + ALIAS: + _rrsig_set_sig = 1 + +DNS__LDNS__RData +ldns_rr_rrsig_labels(rr) + DNS__LDNS__RR rr; + ALIAS: + _rrsig_labels = 1 + +bool +ldns_rr_rrsig_set_labels(rr, rdf) + DNS__LDNS__RR rr; + DNS__LDNS__RData rdf; + ALIAS: + _rrsig_set_labels = 1 + +DNS__LDNS__RData +ldns_rr_rrsig_origttl(rr) + DNS__LDNS__RR rr; + ALIAS: + _rrsig_origttl = 1 + +bool +ldns_rr_rrsig_set_origttl(rr, rdf) + DNS__LDNS__RR rr; + DNS__LDNS__RData rdf; + ALIAS: + _rrsig_set_origttl = 1 + +DNS__LDNS__RData +ldns_rr_rrsig_signame(rr) + DNS__LDNS__RR rr; + ALIAS: + _rrsig_signame = 1 + +bool +ldns_rr_rrsig_set_signame(rr, rdf) + DNS__LDNS__RR rr; + DNS__LDNS__RData rdf; + ALIAS: + _rrsig_set_signame = 1 + +DNS__LDNS__RData +ldns_rr_dnskey_algorithm(rr) + DNS__LDNS__RR rr; + ALIAS: + _dnskey_algorithm = 1 + +bool +ldns_rr_dnskey_set_algorithm(rr, rdf) + DNS__LDNS__RR rr; + DNS__LDNS__RData rdf; + ALIAS: + _dnskey_set_algorithm = 1 + +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 + +const char* +ldns_rdf2str(rdf) + DNS__LDNS__RData rdf; + ALIAS: + to_string = 1 + +void +print(rdf, fp) + DNS__LDNS__RData rdf; + FILE* fp; + CODE: + ldns_rdf_print(fp, rdf); + +LDNS_RDF_Type +ldns_rdf_get_type(rdf) + DNS__LDNS__RData rdf; + ALIAS: + type = 1 + +void +ldns_rdf_set_type(rdf, type) + DNS__LDNS__RData rdf; + LDNS_RDF_Type type + ALIAS: + set_type = 1 + +int +ldns_rdf_compare(rd1, rd2) + DNS__LDNS__RData rd1; + DNS__LDNS__RData rd2; + ALIAS: + compare = 1 + +DNS__LDNS__RData +ldns_rdf_address_reverse(rdf) + DNS__LDNS__RData rdf; + ALIAS: + address_reverse = 1 + +uint8_t +ldns_dname_label_count(rdf) + DNS__LDNS__RData rdf; + ALIAS: + label_count = 1 + +DNS__LDNS__RData +ldns_dname_label(rdf, labelpos) + DNS__LDNS__RData rdf; + uint8_t labelpos; + ALIAS: + label = 1 + +int +ldns_dname_is_wildcard(rdf) + DNS__LDNS__RData rdf; + ALIAS: + is_wildcard = 1 + +int +ldns_dname_match_wildcard(rdf, wildcard) + DNS__LDNS__RData rdf; + DNS__LDNS__RData wildcard; + ALIAS: + matches_wildcard = 1 + +signed char +ldns_dname_is_subdomain(rdf, parent) + DNS__LDNS__RData rdf; + DNS__LDNS__RData parent; + ALIAS: + is_subdomain = 1 + +DNS__LDNS__RData +ldns_dname_left_chop(rdf) + DNS__LDNS__RData rdf + ALIAS: + left_chop = 1 + +LDNS_Status +ldns_dname_cat(rdata, otherrd) + DNS__LDNS__RData rdata; + DNS__LDNS__RData otherrd; + ALIAS: + _cat = 1 + +int +ldns_dname_compare(dname, otherdname) + DNS__LDNS__RData dname; + DNS__LDNS__RData otherdname; + ALIAS: + compare = 1 + +LDNS_RR_Type +ldns_rdf2rr_type(rdf) + DNS__LDNS__RData rdf; + ALIAS: + to_rr_type = 1 + +DNS__LDNS__RData +ldns_dname_reverse(rdf) + DNS__LDNS__RData rdf; + ALIAS: + dname_reverse = 1 + +void +ldns_dname2canonical(rdf) + DNS__LDNS__RData rdf; + ALIAS: + dname2canonical = 1 + +time_t +ldns_rdf2native_time_t(rdf) + DNS__LDNS__RData rdf; + ALIAS: + to_unix_time = 1 + 2native_time_t = 2 + + +MODULE = DNS::LDNS PACKAGE = DNS::LDNS::DNSSecZone + +PROTOTYPES: ENABLE + +DNS__LDNS__DNSSecZone +ldns_dnssec_zone_new() + ALIAS: + _new = 1 + +DNS__LDNS__DNSSecZone +_new_from_file(fp, origin, ttl, c, s, line_nr) + FILE* fp; + DNS__LDNS__RData__Opt origin; + uint32_t ttl; + LDNS_RR_Class c; + LDNS_Status s; + int line_nr; + PREINIT: + ldns_dnssec_zone *z; + CODE: + RETVAL = NULL; +#if LDNS_REVISION < ((1<<16)|(6<<8)|(13)) + Perl_croak(aTHX_ "function ldns_dnssec_zone_new_frm_fp_l is not implemented in this version of ldns"); +#else + s = ldns_dnssec_zone_new_frm_fp_l(&z, fp, origin, ttl, c, &line_nr); +#endif + + if (s == LDNS_STATUS_OK) { + RETVAL = z; + } + + OUTPUT: + RETVAL + s + line_nr + +LDNS_Status +create_from_zone(dnssec_zone, zone) + DNS__LDNS__DNSSecZone dnssec_zone; + DNS__LDNS__Zone zone; + PREINIT: + size_t i; + ldns_rr *cur_rr; + ldns_status status; + ldns_rr_list *failed_nsec3s; + ldns_rr_list *failed_nsec3_rrsigs; + ldns_status result = LDNS_STATUS_OK; + CODE: + failed_nsec3s = ldns_rr_list_new(); + failed_nsec3_rrsigs = ldns_rr_list_new(); + + status = ldns_dnssec_zone_add_rr(dnssec_zone, + ldns_rr_clone(ldns_zone_soa(zone))); + if (result == LDNS_STATUS_OK) { + result = status; + } + + for (i = 0; i < ldns_rr_list_rr_count(ldns_zone_rrs(zone)); i++) { + cur_rr = ldns_rr_list_rr(ldns_zone_rrs(zone), i); + status = ldns_dnssec_zone_add_rr(dnssec_zone, + ldns_rr_clone(cur_rr)); + if (status != LDNS_STATUS_OK) { + if (LDNS_STATUS_DNSSEC_NSEC3_ORIGINAL_NOT_FOUND == status) { + if (ldns_rr_get_type(cur_rr) == LDNS_RR_TYPE_RRSIG + && ldns_rdf2rr_type(ldns_rr_rrsig_typecovered(cur_rr)) + == LDNS_RR_TYPE_NSEC3) { + ldns_rr_list_push_rr(failed_nsec3_rrsigs, cur_rr); + } else { + ldns_rr_list_push_rr(failed_nsec3s, cur_rr); + } + } + if (result == LDNS_STATUS_OK) { + result = status; + } + } + } + + if (ldns_rr_list_rr_count(failed_nsec3s) > 0) { + (void) ldns_dnssec_zone_add_empty_nonterminals(dnssec_zone); + for (i = 0; i < ldns_rr_list_rr_count(failed_nsec3s); i++) { + cur_rr = ldns_rr_list_rr(failed_nsec3s, i); + status = ldns_dnssec_zone_add_rr(dnssec_zone, + ldns_rr_clone(cur_rr)); + if (result == LDNS_STATUS_OK) { + result = status; + } + } + for (i = 0; i < ldns_rr_list_rr_count(failed_nsec3_rrsigs); i++) { + cur_rr = ldns_rr_list_rr(failed_nsec3_rrsigs, i); + status = ldns_dnssec_zone_add_rr(dnssec_zone, + ldns_rr_clone(cur_rr)); + if (result == LDNS_STATUS_OK) { + result = status; + } + } + } + + ldns_rr_list_free(failed_nsec3_rrsigs); + ldns_rr_list_free(failed_nsec3s); + RETVAL = result; + OUTPUT: + RETVAL + +void +print(zone, fp) + DNS__LDNS__DNSSecZone zone; + FILE* fp; + CODE: + ldns_dnssec_zone_print(fp, zone); + +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 +_next(rrsets) + DNS__LDNS__DNSSecRRSets rrsets; + CODE: + RETVAL = rrsets->next; + OUTPUT: + RETVAL + +LDNS_Status +ldns_dnssec_rrsets_add_rr(rrsets, rr) + DNS__LDNS__DNSSecRRSets rrsets; + DNS__LDNS__RR rr; + ALIAS: + _add_rr = 1 + + +MODULE = DNS::LDNS PACKAGE = DNS::LDNS::DNSSecRRs + +DNS__LDNS__DNSSecRRs +ldns_dnssec_rrs_new() + ALIAS: + _new = 1 + +DNS__LDNS__RR +_rr(rrs) + DNS__LDNS__DNSSecRRs rrs; + CODE: + RETVAL = rrs->rr; + OUTPUT: + RETVAL + +DNS__LDNS__DNSSecRRs +_next(rrs) + DNS__LDNS__DNSSecRRs rrs; + CODE: + RETVAL = rrs->next; + OUTPUT: + RETVAL + +LDNS_Status +ldns_dnssec_rrs_add_rr(rrs, rr) + DNS__LDNS__DNSSecRRs rrs; + DNS__LDNS__RR rr; + ALIAS: + _add_rr = 1 + + +MODULE = DNS::LDNS PACKAGE = DNS::LDNS::DNSSecName + +DNS__LDNS__DNSSecName +ldns_dnssec_name_new() + ALIAS: + _new = 1 + +DNS__LDNS__RData +ldns_dnssec_name_name(name) + DNS__LDNS__DNSSecName name; + ALIAS: + _name = 1 + +bool +ldns_dnssec_name_is_glue(name) + DNS__LDNS__DNSSecName name; + ALIAS: + is_glue = 1 + +DNS__LDNS__DNSSecRRSets +_rrsets(name) + DNS__LDNS__DNSSecName name; + CODE: + RETVAL = name->rrsets; + OUTPUT: + RETVAL + +DNS__LDNS__RR +_nsec(name) + DNS__LDNS__DNSSecName name; + CODE: + RETVAL = name->nsec; + OUTPUT: + RETVAL + +DNS__LDNS__RData +_hashed_name(name) + DNS__LDNS__DNSSecName name; + CODE: + RETVAL = name->hashed_name; + OUTPUT: + RETVAL + +DNS__LDNS__DNSSecRRs +_nsec_signatures(name) + DNS__LDNS__DNSSecName name; + CODE: + RETVAL = name->nsec_signatures; + OUTPUT: + RETVAL + +void +ldns_dnssec_name_set_name(name, dname) + DNS__LDNS__DNSSecName name; + DNS__LDNS__RData dname; + ALIAS: + _set_name = 1 + +void +ldns_dnssec_name_set_nsec(name, nsec) + DNS__LDNS__DNSSecName name; + DNS__LDNS__RR nsec; + ALIAS: + _set_nsec = 1 + +int +ldns_dnssec_name_cmp(a, b) + DNS__LDNS__DNSSecName a; + DNS__LDNS__DNSSecName b; + ALIAS: + compare = 1 + +LDNS_Status +ldns_dnssec_name_add_rr(name, rr) + DNS__LDNS__DNSSecName name; + DNS__LDNS__RR rr; + ALIAS: + _add_rr = 1 + + +MODULE = DNS::LDNS PACKAGE = DNS::LDNS::RBTree + +DNS__LDNS__RBNode +ldns_rbtree_first(tree) + DNS__LDNS__RBTree tree; + ALIAS: + _first = 1 + +DNS__LDNS__RBNode +ldns_rbtree_last(tree) + DNS__LDNS__RBTree tree; + ALIAS: + _last = 1 + + +MODULE = DNS::LDNS PACKAGE = DNS::LDNS::RBNode + +DNS__LDNS__RBNode +ldns_rbtree_next(node) + DNS__LDNS__RBNode node; + ALIAS: + _next = 1 + +DNS__LDNS__RBNode +ldns_rbtree_previous(node) + DNS__LDNS__RBNode node; + ALIAS: + _previous = 1 + +DNS__LDNS__RBNode +ldns_dnssec_name_node_next_nonglue(node) + DNS__LDNS__RBNode node; + ALIAS: + _next_nonglue = 1 + +bool +is_null(node) + DNS__LDNS__RBNode node; + CODE: + RETVAL = (node == LDNS_RBTREE_NULL); + OUTPUT: + RETVAL + +DNS__LDNS__DNSSecName +_name(node) + DNS__LDNS__RBNode node; + CODE: + RETVAL = (ldns_dnssec_name*)node->data; + OUTPUT: + RETVAL + + +MODULE = DNS::LDNS PACKAGE = DNS::LDNS::Resolver + +DNS__LDNS__Resolver +_new_from_file(fp, s) + FILE* fp; + LDNS_Status s; + PREINIT: + ldns_resolver *r; + CODE: + RETVAL = NULL; + s = ldns_resolver_new_frm_fp(&r, fp); + if (s == LDNS_STATUS_OK) { + RETVAL = r; + } + OUTPUT: + RETVAL + s + +DNS__LDNS__Resolver +ldns_resolver_new() + ALIAS: + _new = 1 + +bool +ldns_resolver_dnssec(resolver) + DNS__LDNS__Resolver resolver; + ALIAS: + dnssec = 1 + +void +ldns_resolver_set_dnssec(resolver, d) + DNS__LDNS__Resolver resolver; + bool d; + ALIAS: + set_dnssec = 1 + +bool +ldns_resolver_dnssec_cd(resolver) + DNS__LDNS__Resolver resolver; + ALIAS: + dnssec_cd = 1 + +void +ldns_resolver_set_dnssec_cd(resolver, d) + DNS__LDNS__Resolver resolver; + bool d; + ALIAS: + set_dnssec_cd = 1 + +uint16_t +ldns_resolver_port(resolver) + DNS__LDNS__Resolver resolver; + ALIAS: + port = 1 + +void +ldns_resolver_set_port(resolver, port) + DNS__LDNS__Resolver resolver; + uint16_t port; + ALIAS: + set_port = 1 + +bool +ldns_resolver_recursive(resolver) + DNS__LDNS__Resolver resolver; + ALIAS: + recursive = 1 + +void +ldns_resolver_set_recursive(resolver, b) + DNS__LDNS__Resolver resolver; + bool b; + ALIAS: + set_recursive = 1 + +bool +ldns_resolver_debug(resolver) + DNS__LDNS__Resolver resolver; + ALIAS: + debug = 1 + +void +ldns_resolver_set_debug(resolver, b) + DNS__LDNS__Resolver resolver; + bool b; + ALIAS: + set_debug = 1 + +uint8_t +ldns_resolver_retry(resolver) + DNS__LDNS__Resolver resolver; + ALIAS: + retry = 1 + +void +ldns_resolver_set_retry(resolver, re) + DNS__LDNS__Resolver resolver; + uint8_t re; + ALIAS: + set_retry = 1 + +uint8_t +ldns_resolver_retrans(resolver) + DNS__LDNS__Resolver resolver; + ALIAS: + retrans = 1 + +void +ldns_resolver_set_retrans(resolver, re) + DNS__LDNS__Resolver resolver; + uint8_t re; + ALIAS: + set_retrans = 1 + +bool +ldns_resolver_fallback(resolver) + DNS__LDNS__Resolver resolver; + ALIAS: + fallback = 1 + +void +ldns_resolver_set_fallback(resolver, f) + DNS__LDNS__Resolver resolver; + bool f; + ALIAS: + set_fallback = 1 + +uint8_t +ldns_resolver_ip6(resolver) + DNS__LDNS__Resolver resolver; + ALIAS: + ip6 = 1 + +void +ldns_resolver_set_ip6(resolver, i) + DNS__LDNS__Resolver resolver; + uint8_t i; + ALIAS: + set_ip6 = 1 + +uint16_t +ldns_resolver_edns_udp_size(resolver) + DNS__LDNS__Resolver resolver; + ALIAS: + edns_udp_size = 1 + +void +ldns_resolver_set_edns_udp_size(resolver, s) + DNS__LDNS__Resolver resolver; + uint16_t s; + ALIAS: + set_edns_udp_size = 1 + +bool +ldns_resolver_usevc(resolver) + DNS__LDNS__Resolver resolver; + ALIAS: + usevc = 1 + +void +ldns_resolver_set_usevc(resolver, b) + DNS__LDNS__Resolver resolver; + bool b; + ALIAS: + set_usevc = 1 + +bool +ldns_resolver_fail(resolver) + DNS__LDNS__Resolver resolver; + ALIAS: + fail = 1 + +void +ldns_resolver_set_fail(resolver, b) + DNS__LDNS__Resolver resolver; + bool b; + ALIAS: + set_fail = 1 + +bool +ldns_resolver_defnames(resolver) + DNS__LDNS__Resolver resolver; + ALIAS: + defnames = 1 + +void +ldns_resolver_set_defnames(resolver, b) + DNS__LDNS__Resolver resolver; + bool b; + ALIAS: + set_defnames = 1 + +bool +ldns_resolver_dnsrch(resolver) + DNS__LDNS__Resolver resolver; + ALIAS: + dnsrch = 1 + +void +ldns_resolver_set_dnsrch(resolver, b) + DNS__LDNS__Resolver resolver; + bool b; + ALIAS: + set_dnsrch = 1 + +bool +ldns_resolver_igntc(resolver) + DNS__LDNS__Resolver resolver; + ALIAS: + igntc = 1 + +void +ldns_resolver_set_igntc(resolver, b) + DNS__LDNS__Resolver resolver; + bool b; + ALIAS: + set_igntc = 1 + +bool +ldns_resolver_random(resolver) + DNS__LDNS__Resolver resolver; + ALIAS: + random = 1 + +void +ldns_resolver_set_random(resolver, b) + DNS__LDNS__Resolver resolver; + bool b; + ALIAS: + set_random = 1 + +bool +ldns_resolver_trusted_key(resolver, keys, trusted_key) + DNS__LDNS__Resolver resolver; + DNS__LDNS__RRList keys; + DNS__LDNS__RRList trusted_key; + ALIAS: + trusted_key = 1 + +DNS__LDNS__RRList +ldns_resolver_dnssec_anchors(resolver) + DNS__LDNS__Resolver resolver; + ALIAS: + _dnssec_anchors = 1 + +void +ldns_resolver_set_dnssec_anchors(resolver, list) + DNS__LDNS__Resolver resolver; + DNS__LDNS__RRList list; + ALIAS: + _set_dnssec_anchors = 1 + +void +ldns_resolver_push_dnssec_anchor(resolver, rr) + DNS__LDNS__Resolver resolver; + DNS__LDNS__RR rr; + ALIAS: + _push_dnssec_anchor = 1 + +DNS__LDNS__RData +ldns_resolver_domain(resolver) + DNS__LDNS__Resolver resolver; + ALIAS: + _domain = 1 + +void +ldns_resolver_set_domain(resolver, rd) + DNS__LDNS__Resolver resolver; + DNS__LDNS__RData rd; + ALIAS: + _set_domain = 1 + +AV * +_nameservers(resolver) + DNS__LDNS__Resolver resolver; + PREINIT: + ldns_rdf** list; + AV * result; + int i; + SV * elem; + CODE: + result = (AV *)sv_2mortal((SV *)newAV()); + list = ldns_resolver_nameservers(resolver); + + /* FIXME: Make a typemap for this ? */ + for (i = 0; i < ldns_resolver_nameserver_count(resolver); i++) { + elem = newSVpv(0, 0); + sv_setref_pv(elem, "LDNS::RData", list[i]); + av_push(result, elem); + } + RETVAL = result; + OUTPUT: + RETVAL + +size_t +ldns_resolver_nameserver_count(resolver) + DNS__LDNS__Resolver resolver; + ALIAS: + nameserver_count = 1 + +LDNS_Status +ldns_resolver_push_nameserver(resolver, n) + DNS__LDNS__Resolver resolver; + DNS__LDNS__RData n; + ALIAS: + _push_nameserver = 1 + +DNS__LDNS__RData +ldns_resolver_pop_nameserver(resolver) + DNS__LDNS__Resolver resolver; + ALIAS: + _pop_nameserver = 1 + +void +ldns_resolver_nameservers_randomize(resolver) + DNS__LDNS__Resolver resolver; + ALIAS: + nameservers_randomize = 1 + +char* +ldns_resolver_tsig_keyname(resolver) + DNS__LDNS__Resolver resolver; + ALIAS: + tsig_keyname = 1 + +void +ldns_resolver_set_tsig_keyname(resolver, tsig_keyname) + DNS__LDNS__Resolver resolver; + char* tsig_keyname; + ALIAS: + set_tsig_keyname = 1 + +char* +ldns_resolver_tsig_algorithm(resolver) + DNS__LDNS__Resolver resolver; + ALIAS: + tsig_algorithm = 1 + +void +ldns_resolver_set_tsig_algorithm(resolver, tsig_algorithm) + DNS__LDNS__Resolver resolver; + char* tsig_algorithm; + ALIAS: + set_tsig_algorithm = 1 + +char* +ldns_resolver_tsig_keydata(resolver) + DNS__LDNS__Resolver resolver; + ALIAS: + tsig_keydata = 1 + +void +ldns_resolver_set_tsig_keydata(resolver, tsig_keydata) + DNS__LDNS__Resolver resolver; + char* tsig_keydata; + ALIAS: + set_tsig_keydata = 1 + +size_t +ldns_resolver_searchlist_count(resolver) + DNS__LDNS__Resolver resolver; + ALIAS: + searchlist_count = 1 + +void +ldns_resolver_push_searchlist(resolver, rd) + DNS__LDNS__Resolver resolver; + DNS__LDNS__RData rd; + ALIAS: + _push_searchlist = 1 + +AV * +_searchlist(resolver) + DNS__LDNS__Resolver resolver; + PREINIT: + ldns_rdf** list; + AV * result; + int i; + SV * elem; + CODE: + result = (AV *)sv_2mortal((SV *)newAV()); + list = ldns_resolver_searchlist(resolver); + + /* FIXME: Make a typemap for this ? */ + for (i = 0; i < ldns_resolver_searchlist_count(resolver); i++) { + elem = newSVpv(0, 0); + sv_setref_pv(elem, "LDNS::RData", list[i]); + av_push(result, elem); + } + RETVAL = result; + OUTPUT: + RETVAL + +size_t +ldns_resolver_nameserver_rtt(resolver, pos) + DNS__LDNS__Resolver resolver; + size_t pos; + ALIAS: + nameserver_rtt = 1 + +void +ldns_resolver_set_nameserver_rtt(resolver, pos, val) + DNS__LDNS__Resolver resolver; + size_t pos; + size_t val; + ALIAS: + set_nameserver_rtt = 1 + +AV * +_timeout(resolver) + DNS__LDNS__Resolver resolver; + PREINIT: + struct timeval t; + AV * result; + CODE: + t = ldns_resolver_timeout(resolver); + result = (AV *)sv_2mortal((SV *)newAV()); + av_push(result, newSVuv(t.tv_sec)); + av_push(result, newSVuv(t.tv_usec)); + RETVAL = result; + OUTPUT: + RETVAL + +void +set_timeout(resolver, sec, usec) + DNS__LDNS__Resolver resolver; + uint32_t sec; + uint32_t usec; + PREINIT: + struct timeval t; + CODE: + t.tv_sec = sec; + t.tv_usec = usec; + ldns_resolver_set_timeout(resolver, t); + +void +_set_rtt(resolver, rtt) + DNS__LDNS__Resolver resolver; + AV * rtt; + PREINIT: + size_t *buff; + int i; + SV** elem; + CODE: + buff = malloc(sizeof(size_t)*(av_len(rtt)+1)); + for (i = 0; i <= av_len(rtt); i++) { + elem = av_fetch(rtt, i, 0); + buff[i] = SvUV(*elem); + } + ldns_resolver_set_rtt(resolver, buff); + +AV * +_rtt(resolver) + DNS__LDNS__Resolver resolver; + PREINIT: + int i; + size_t *rtt; + AV * result; + CODE: + result = (AV *)sv_2mortal((SV *)newAV()); + rtt = ldns_resolver_rtt(resolver); + + for (i = 0; i < ldns_resolver_nameserver_count(resolver); i++) { + av_push(result, newSVuv(rtt[i])); + } + RETVAL = result; + OUTPUT: + RETVAL + +DNS__LDNS__RRList +ldns_validate_domain_ds(resolver, domain, keys) + DNS__LDNS__Resolver resolver; + DNS__LDNS__RData domain; + DNS__LDNS__RRList keys; + ALIAS: + validate_domain_ds = 1 + +DNS__LDNS__RRList +ldns_validate_domain_ds_time(resolver, domain, keys, check_time) + DNS__LDNS__Resolver resolver; + DNS__LDNS__RData domain; + DNS__LDNS__RRList keys; + time_t check_time; + ALIAS: + validate_domain_ds_time = 1 + +DNS__LDNS__RRList +ldns_validate_domain_dnskey(resolver, domain, keys) + DNS__LDNS__Resolver resolver; + DNS__LDNS__RData domain; + DNS__LDNS__RRList keys; + ALIAS: + validate_domain_dnskey = 1 + +DNS__LDNS__RRList +ldns_validate_domain_dnskey_time(resolver, domain, keys, check_time) + DNS__LDNS__Resolver resolver; + DNS__LDNS__RData domain; + DNS__LDNS__RRList keys; + time_t check_time; + ALIAS: + validate_domain_dnskey_time = 1 + +LDNS_Status +ldns_verify_trusted(resolver, rrset, rrsigs, validating_keys) + DNS__LDNS__Resolver resolver; + DNS__LDNS__RRList rrset; + DNS__LDNS__RRList rrsigs; + DNS__LDNS__RRList validating_keys; + ALIAS: + _verify_trusted = 1 + +LDNS_Status +ldns_verify_trusted_time(resolver, rrset, rrsigs, check_time, validating_keys) + DNS__LDNS__Resolver resolver; + DNS__LDNS__RRList rrset; + DNS__LDNS__RRList rrsigs; + time_t check_time; + DNS__LDNS__RRList validating_keys; + ALIAS: + _verify_trusted_time = 1 + +DNS__LDNS__RRList +_fetch_valid_domain_keys(resolver, domain, keys, s) + DNS__LDNS__Resolver resolver; + DNS__LDNS__RData domain; + DNS__LDNS__RRList keys; + LDNS_Status s; + PREINIT: + DNS__LDNS__RRList trusted; + DNS__LDNS__RRList ret; + size_t i; + CODE: + RETVAL = NULL; + trusted = ldns_fetch_valid_domain_keys(resolver, domain, keys, &s); + if (s == LDNS_STATUS_OK) { + RETVAL = ldns_rr_list_clone(trusted); + ldns_rr_list_free(trusted); + } + OUTPUT: + RETVAL + s + +DNS__LDNS__RRList +_fetch_valid_domain_keys_time(resolver, domain, keys, check_time, s) + DNS__LDNS__Resolver resolver; + DNS__LDNS__RData domain; + DNS__LDNS__RRList keys; + time_t check_time; + LDNS_Status s; + PREINIT: + DNS__LDNS__RRList trusted; + DNS__LDNS__RRList ret; + size_t i; + CODE: + RETVAL = NULL; + trusted = ldns_fetch_valid_domain_keys_time( + resolver, domain, keys, check_time, &s); + if (s == LDNS_STATUS_OK) { + RETVAL = ldns_rr_list_clone(trusted); + ldns_rr_list_free(trusted); + } + OUTPUT: + RETVAL + s + +DNS__LDNS__Packet +ldns_resolver_query(resolver, name, type, class, flags) + DNS__LDNS__Resolver resolver; + DNS__LDNS__RData name; + LDNS_RR_Type type; + LDNS_RR_Class class; + uint16_t flags; + ALIAS: + query = 1 + +DNS__LDNS__Packet +_send(resolver, name, type, class, flags, s) + DNS__LDNS__Resolver resolver; + DNS__LDNS__RData name; + LDNS_RR_Type type; + LDNS_RR_Class class; + uint16_t flags; + LDNS_Status s; + PREINIT: + DNS__LDNS__Packet packet; + CODE: + s = ldns_resolver_send(&packet, resolver, name, type, class, flags); + if (s == LDNS_STATUS_OK) { + RETVAL = packet; + } + OUTPUT: + RETVAL + s + +DNS__LDNS__Packet +_send_pkt(resolver, packet, s) + DNS__LDNS__Resolver resolver; + DNS__LDNS__Packet packet; + LDNS_Status s; + PREINIT: + DNS__LDNS__Packet answer; + CODE: + s = ldns_resolver_send_pkt(&answer, resolver, packet); + if (s == LDNS_STATUS_OK) { + RETVAL = answer; + } + OUTPUT: + RETVAL + s + +DNS__LDNS__Packet +_prepare_query_pkt(resolver, name, type, class, flags, s) + DNS__LDNS__Resolver resolver; + DNS__LDNS__RData name; + LDNS_RR_Type type; + LDNS_RR_Class class; + uint16_t flags; + LDNS_Status s; + PREINIT: + DNS__LDNS__Packet packet; + CODE: + s = ldns_resolver_prepare_query_pkt(&packet, resolver, name, type, class, flags); + if (s == LDNS_STATUS_OK) { + RETVAL = packet; + } + OUTPUT: + RETVAL + s + +DNS__LDNS__Packet +ldns_resolver_search(resolver, name, type, class, flags) + DNS__LDNS__Resolver resolver; + DNS__LDNS__RData name; + LDNS_RR_Type type; + LDNS_RR_Class class; + uint16_t flags; + ALIAS: + search = 1 + +DNS__LDNS__DNSSecDataChain +build_data_chain(res, qflags, data_set, pkt, orig_rr) + DNS__LDNS__Resolver res; + uint16_t qflags; + DNS__LDNS__RRList data_set; + DNS__LDNS__Packet pkt; + DNS__LDNS__RR__Opt orig_rr; + CODE: + RETVAL = ldns_dnssec_build_data_chain(res, qflags, data_set, pkt, orig_rr); + OUTPUT: + RETVAL + +DNS__LDNS__RRList +ldns_get_rr_list_addr_by_name(res, name, class, flags) + DNS__LDNS__Resolver res; + DNS__LDNS__RData name; + LDNS_RR_Class class; + uint16_t flags; + ALIAS: + get_rr_list_addr_by_name = 1 + +DNS__LDNS__RRList +ldns_get_rr_list_name_by_addr(res, addr, class, flags) + DNS__LDNS__Resolver res; + DNS__LDNS__RData addr; + LDNS_RR_Class class; + uint16_t flags; + ALIAS: + get_rr_list_addr_by_addr = 1 + + +MODULE = DNS::LDNS PACKAGE = DNS::LDNS::Packet + +Mortal_PV +ldns_pkt2str(pkt) + DNS__LDNS__Packet pkt; + ALIAS: + to_string = 1 + +DNS__LDNS__RRList +ldns_pkt_question(pkt) + DNS__LDNS__Packet pkt; + ALIAS: + _question = 1 + +void +ldns_pkt_set_question(pkt, l) + DNS__LDNS__Packet pkt; + DNS__LDNS__RRList l; + ALIAS: + _set_question = 1 + +DNS__LDNS__RRList +ldns_pkt_answer(pkt) + DNS__LDNS__Packet pkt; + ALIAS: + _answer = 1 + +void +ldns_pkt_set_answer(pkt, l) + DNS__LDNS__Packet pkt; + DNS__LDNS__RRList l; + ALIAS: + _set_answer = 1 + +DNS__LDNS__RRList +ldns_pkt_authority(pkt) + DNS__LDNS__Packet pkt; + ALIAS: + _authority = 1 + +void +ldns_pkt_set_authority(pkt, l) + DNS__LDNS__Packet pkt; + DNS__LDNS__RRList l; + ALIAS: + _set_authority = 1 + +DNS__LDNS__RRList +ldns_pkt_additional(pkt) + DNS__LDNS__Packet pkt; + ALIAS: + _additional = 1 + +void +ldns_pkt_set_additional(pkt, l) + DNS__LDNS__Packet pkt; + DNS__LDNS__RRList l; + ALIAS: + _set_additional = 1 + +DNS__LDNS__RRList +ldns_pkt_all(pkt) + DNS__LDNS__Packet pkt; + ALIAS: + all = 1 + +DNS__LDNS__RRList +ldns_pkt_all_noquestion(pkt) + DNS__LDNS__Packet pkt; + ALIAS: + all_noquestion = 1 + +signed char +ldns_pkt_qr(pkt) + DNS__LDNS__Packet pkt; + ALIAS: + qr = 1 + +void +ldns_pkt_set_qr(pkt, b) + DNS__LDNS__Packet pkt; + signed char b; + ALIAS: + set_qr = 1 + +signed char +ldns_pkt_aa(pkt) + DNS__LDNS__Packet pkt; + ALIAS: + aa = 1 + +void +ldns_pkt_set_aa(pkt, b) + DNS__LDNS__Packet pkt; + signed char b; + ALIAS: + set_aa = 1 + +signed char +ldns_pkt_tc(pkt) + DNS__LDNS__Packet pkt; + ALIAS: + tc = 1 + +void +ldns_pkt_set_tc(pkt, b) + DNS__LDNS__Packet pkt; + signed char b; + ALIAS: + set_tc = 1 + +signed char +ldns_pkt_rd(pkt) + DNS__LDNS__Packet pkt; + ALIAS: + rd = 1 + +void +ldns_pkt_set_rd(pkt, b) + DNS__LDNS__Packet pkt; + signed char b; + ALIAS: + set_rd = 1 + +bool +ldns_pkt_cd(pkt) + DNS__LDNS__Packet pkt; + ALIAS: + cd = 1 + +void +ldns_pkt_set_cd(pkt, b) + DNS__LDNS__Packet pkt; + signed char b; + ALIAS: + set_cd = 1 + +signed char +ldns_pkt_ra(pkt) + DNS__LDNS__Packet pkt; + ALIAS: + ra = 1 + +void +ldns_pkt_set_ra(pkt, b) + DNS__LDNS__Packet pkt; + signed char b; + ALIAS: + set_ra = 1 + +signed char +ldns_pkt_ad(pkt) + DNS__LDNS__Packet pkt; + ALIAS: + ad = 1 + +void +ldns_pkt_set_ad(pkt, b) + DNS__LDNS__Packet pkt; + signed char b; + ALIAS: + set_ad = 1 + +uint16_t +ldns_pkt_id(pkt) + DNS__LDNS__Packet pkt; + ALIAS: + id = 1 + +void +ldns_pkt_set_id(pkt, id) + DNS__LDNS__Packet pkt; + uint16_t id; + ALIAS: + set_id = 1 + +void +ldns_pkt_set_random_id(pkt) + DNS__LDNS__Packet pkt; + ALIAS: + set_random_id = 1 + +uint16_t +ldns_pkt_qdcount(pkt) + DNS__LDNS__Packet pkt; + ALIAS: + qdcount = 1 + +uint16_t +ldns_pkt_ancount(pkt) + DNS__LDNS__Packet pkt; + ALIAS: + ancount = 1 + +uint16_t +ldns_pkt_nscount(pkt) + DNS__LDNS__Packet pkt; + ALIAS: + nscount = 1 + +uint16_t +ldns_pkt_arcount(pkt) + DNS__LDNS__Packet pkt; + ALIAS: + arcount = 1 + +LDNS_Pkt_Opcode +ldns_pkt_get_opcode(pkt) + DNS__LDNS__Packet pkt; + ALIAS: + opcode = 1 + +void +ldns_pkt_set_opcode(pkt, c) + DNS__LDNS__Packet pkt; + LDNS_Pkt_Opcode c; + ALIAS: + set_opcode = 1 + +uint8_t +ldns_pkt_get_rcode(pkt) + DNS__LDNS__Packet pkt; + ALIAS: + rcode = 1 + +void +ldns_pkt_set_rcode(pkt, r) + DNS__LDNS__Packet pkt; + uint8_t r; + ALIAS: + set_rcode = 1 + +size_t +ldns_pkt_size(pkt) + DNS__LDNS__Packet pkt; + ALIAS: + size = 1 + +uint32_t +ldns_pkt_querytime(pkt) + DNS__LDNS__Packet pkt; + ALIAS: + querytime = 1 + +void +ldns_pkt_set_querytime(pkt, t) + DNS__LDNS__Packet pkt; + uint32_t t; + ALIAS: + set_querytime = 1 + +DNS__LDNS__RData +ldns_pkt_answerfrom(pkt) + DNS__LDNS__Packet pkt; + ALIAS: + _answerfrom = 1 + +AV * +_timestamp(pkt) + DNS__LDNS__Packet pkt; + PREINIT: + struct timeval t; + AV * result; + CODE: + t = ldns_pkt_timestamp(pkt); + result = (AV *)sv_2mortal((SV *)newAV()); + av_push(result, newSVuv(t.tv_sec)); + av_push(result, newSVuv(t.tv_usec)); + RETVAL = result; + OUTPUT: + RETVAL + +void +set_timestamp(pkt, sec, usec) + DNS__LDNS__Packet pkt; + uint32_t sec; + uint32_t usec; + PREINIT: + struct timeval t; + CODE: + t.tv_sec = sec; + t.tv_usec = usec; + ldns_pkt_set_timestamp(pkt, t); + +void +ldns_pkt_set_answerfrom(pkt, a) + DNS__LDNS__Packet pkt; + DNS__LDNS__RData a; + ALIAS: + _set_answerfrom = 1 + +bool +ldns_pkt_set_flags(pkt, f) + DNS__LDNS__Packet pkt; + uint16_t f; + ALIAS: + set_flags = 1 + +DNS__LDNS__RRList +ldns_pkt_rr_list_by_name(pkt, name, sec) + DNS__LDNS__Packet pkt; + DNS__LDNS__RData name; + LDNS_Pkt_Section sec; + ALIAS: + rr_list_by_name = 1 + +DNS__LDNS__RRList +ldns_pkt_rr_list_by_type(pkt, type, sec) + DNS__LDNS__Packet pkt; + LDNS_RR_Type type; + LDNS_Pkt_Section sec; + ALIAS: + rr_list_by_type = 1 + +DNS__LDNS__RRList +ldns_pkt_rr_list_by_name_and_type(pkt, name, type, sec) + DNS__LDNS__Packet pkt; + DNS__LDNS__RData name; + LDNS_RR_Type type; + LDNS_Pkt_Section sec; + ALIAS: + rr_list_by_name_and_type = 1 + +bool +ldns_pkt_rr(pkt, sec, rr) + DNS__LDNS__Packet pkt; + LDNS_Pkt_Section sec; + DNS__LDNS__RR rr; + ALIAS: + rr = 1 + +bool +ldns_pkt_push_rr(pkt, sec, rr) + DNS__LDNS__Packet pkt; + LDNS_Pkt_Section sec; + DNS__LDNS__RR rr; + ALIAS: + _push_rr = 1 + +bool +ldns_pkt_safe_push_rr(pkt, sec, rr) + DNS__LDNS__Packet pkt; + LDNS_Pkt_Section sec; + DNS__LDNS__RR rr; + ALIAS: + _safe_push_rr = 1 + +uint16_t +ldns_pkt_section_count(pkt, sec) + DNS__LDNS__Packet pkt; + LDNS_Pkt_Section sec; + ALIAS: + section_count = 1 + +signed char +ldns_pkt_empty(pkt) + DNS__LDNS__Packet pkt; + ALIAS: + empty = 1 + +DNS__LDNS__RR +ldns_pkt_tsig(pkt) + DNS__LDNS__Packet pkt; + ALIAS: + _tsig = 1 + +void +ldns_pkt_set_tsig(pkt, rr) + DNS__LDNS__Packet pkt; + DNS__LDNS__RR rr; + ALIAS: + _set_tsig = 1 + +DNS__LDNS__Packet +ldns_pkt_clone(pkt) + DNS__LDNS__Packet pkt; + ALIAS: + clone = 1 + +LDNS_Pkt_Type +ldns_pkt_reply_type(pkt) + DNS__LDNS__Packet pkt; + ALIAS: + reply_type = 1 + +DNS__LDNS__Packet +ldns_pkt_new() + ALIAS: + _new = 1 + +DNS__LDNS__Packet +ldns_pkt_query_new(name, type, class, flags) + DNS__LDNS__RData name; + LDNS_RR_Type type; + LDNS_RR_Class class; + uint16_t flags; + ALIAS: + _query_new = 1 + +DNS__LDNS__RRList +ldns_dnssec_pkt_get_rrsigs_for_name_and_type(pkt, name, type) + DNS__LDNS__Packet pkt; + DNS__LDNS__RData name; + LDNS_RR_Type type; + ALIAS: + get_rrsigs_for_name_and_type = 1 + +DNS__LDNS__RRList +ldns_dnssec_pkt_get_rrsigs_for_type(pkt, type) + DNS__LDNS__Packet pkt; + LDNS_RR_Type type; + ALIAS: + get_rrsigs_for_type = 1 + +uint16_t +ldns_pkt_edns_udp_size(pkt) + DNS__LDNS__Packet pkt; + ALIAS: + edns_udp_size = 1 + +void +ldns_pkt_set_edns_udp_size(pkt, s) + DNS__LDNS__Packet pkt; + uint16_t s; + ALIAS: + set_edns_udp_size = 1 + +uint8_t +ldns_pkt_edns_extended_rcode(pkt) + DNS__LDNS__Packet pkt; + ALIAS: + edns_extended_rcode = 1 + +void +ldns_pkt_set_edns_extended_rcode(pkt, c) + DNS__LDNS__Packet pkt; + uint8_t c; + ALIAS: + set_edns_extended_rcode = 1 + +uint8_t +ldns_pkt_edns_version(pkt) + DNS__LDNS__Packet pkt; + ALIAS: + edns_version = 1 + +void +ldns_pkt_set_edns_version(pkt, v) + DNS__LDNS__Packet pkt; + uint8_t v; + ALIAS: + set_edns_version = 1 + +uint16_t +ldns_pkt_edns_z(pkt) + DNS__LDNS__Packet pkt; + ALIAS: + edns_z = 1 + +void +ldns_pkt_set_edns_z(pkt, z) + DNS__LDNS__Packet pkt; + uint16_t z; + ALIAS: + set_edns_z = 1 + +signed char +ldns_pkt_edns_do(pkt) + DNS__LDNS__Packet pkt; + ALIAS: + edns_do = 1 + +DNS__LDNS__RData +ldns_pkt_edns_data(pkt) + DNS__LDNS__Packet pkt; + ALIAS: + _edns_data = 1 + +void +ldns_pkt_set_edns_data(pkt, data) + DNS__LDNS__Packet pkt; + DNS__LDNS__RData data; + ALIAS: + _set_edns_data = 1 + +void +ldns_pkt_set_edns_do(pkt, val) + DNS__LDNS__Packet pkt; + signed char val; + ALIAS: + set_edns_do = 1 + +bool +ldns_pkt_edns(pkt) + DNS__LDNS__Packet pkt; + ALIAS: + edns = 1 + + +MODULE = DNS::LDNS PACKAGE = DNS::LDNS::Key + +DNS__LDNS__Key +_new_from_file(fp, line_nr, s) + FILE* fp; + int line_nr; + LDNS_Status s; + PREINIT: + ldns_key *key; + CODE: + RETVAL = NULL; + s = ldns_key_new_frm_fp_l(&key, fp, &line_nr); + + if (s == LDNS_STATUS_OK) { + RETVAL = key; + } + OUTPUT: + RETVAL + s + line_nr + +DNS__LDNS__Key +ldns_key_new() + ALIAS: + _new = 1 + +void +print(key, fp) + DNS__LDNS__Key key; + FILE* fp; + CODE: + ldns_key_print(fp, key); + +Mortal_PV +ldns_key2str(key) + DNS__LDNS__Key key; + ALIAS: + to_string = 1 + +void +ldns_key_set_algorithm(key, algorithm) + DNS__LDNS__Key key; + LDNS_Signing_Algorithm algorithm; + ALIAS: + set_algorithm = 1 + +LDNS_Signing_Algorithm +ldns_key_algorithm(key) + DNS__LDNS__Key key; + ALIAS: + algorithm = 1 + +void +ldns_key_set_flags(key, flags) + DNS__LDNS__Key key; + uint16_t flags; + ALIAS: + set_flags = 1 + +uint16_t +ldns_key_flags(key) + DNS__LDNS__Key key; + ALIAS: + flags = 1 + +void +ldns_key_set_hmac_key(key, hmac) + DNS__LDNS__Key key; + unsigned char* hmac; + ALIAS: + set_hmac_key = 1 + +unsigned char * +ldns_key_hmac_key(key) + DNS__LDNS__Key key; + ALIAS: + hmac_key = 1 + +void +ldns_key_set_hmac_size(key, size) + DNS__LDNS__Key key; + size_t size; + ALIAS: + set_hmac_size = 1 + +size_t +ldns_key_hmac_size(key) + DNS__LDNS__Key key; + ALIAS: + hmac_size = 1 + +void +ldns_key_set_origttl(key, t) + DNS__LDNS__Key key; + uint32_t t; + ALIAS: + set_origttl = 1 + +uint32_t +ldns_key_origttl(key) + DNS__LDNS__Key key; + ALIAS: + origttl = 1 + +void +ldns_key_set_inception(key, i) + DNS__LDNS__Key key; + uint32_t i; + ALIAS: + set_inception = 1 + +uint32_t +ldns_key_inception(key) + DNS__LDNS__Key key; + ALIAS: + inception = 1 + +void +ldns_key_set_expiration(key, e) + DNS__LDNS__Key key; + uint32_t e; + ALIAS: + set_expiration = 1 + +uint32_t +ldns_key_expiration(key) + DNS__LDNS__Key key; + ALIAS: + expiration = 1 + +void +ldns_key_set_pubkey_owner(key, r) + DNS__LDNS__Key key; + DNS__LDNS__RData r; + ALIAS: + _set_pubkey_owner = 1 + +DNS__LDNS__RData +ldns_key_pubkey_owner(key) + DNS__LDNS__Key key; + ALIAS: + _pubkey_owner = 1 + +void +ldns_key_set_keytag(key, tag) + DNS__LDNS__Key key; + uint16_t tag; + ALIAS: + set_keytag = 1 + +uint16_t +ldns_key_keytag(key) + DNS__LDNS__Key key; + ALIAS: + keytag = 1 + +void +ldns_key_set_use(key, v) + DNS__LDNS__Key key; + signed char v; + ALIAS: + set_use = 1 + +signed char +ldns_key_use(key) + DNS__LDNS__Key key; + ALIAS: + use = 1 + +char * +ldns_key_get_file_base_name(key) + DNS__LDNS__Key key; + ALIAS: + get_file_base_name = 1 + +DNS__LDNS__RR +ldns_key2rr(key) + DNS__LDNS__Key key; + ALIAS: + to_rr = 1 + + +MODULE = DNS::LDNS PACKAGE = DNS::LDNS::KeyList + +DNS__LDNS__KeyList +ldns_key_list_new() + ALIAS: + _new = 1 + +void +ldns_key_list_set_use(keys, v) + DNS__LDNS__KeyList keys; + bool v; + ALIAS: + set_use = 1 + +DNS__LDNS__Key +ldns_key_list_pop_key(keylist) + DNS__LDNS__KeyList keylist; + ALIAS: + pop = 1 + +void +ldns_key_list_push_key(keylist, key) + DNS__LDNS__KeyList keylist; + DNS__LDNS__Key key; + ALIAS: + _push = 1 + +size_t +ldns_key_list_key_count(keylist) + DNS__LDNS__KeyList keylist; + ALIAS: + count = 1 + +DNS__LDNS__Key +ldns_key_list_key(keylist, nr) + DNS__LDNS__KeyList keylist; + size_t nr; + ALIAS: + _key = 1 + + +MODULE = DNS::LDNS PACKAGE = DNS::LDNS::DNSSecDataChain + +DNS__LDNS__DNSSecDataChain +ldns_dnssec_data_chain_new() + ALIAS: + _new = 1 + +void +print(chain, fp) + DNS__LDNS__DNSSecDataChain chain; + FILE* fp; + CODE: + ldns_dnssec_data_chain_print(fp, chain); + +DNS__LDNS__DNSSecTrustTree +ldns_dnssec_derive_trust_tree(chain, rr) + DNS__LDNS__DNSSecDataChain chain; + DNS__LDNS__RR rr; + ALIAS: + _derive_trust_tree = 1 + +DNS__LDNS__DNSSecTrustTree +ldns_dnssec_derive_trust_tree_time(chain, rr, check_time) + DNS__LDNS__DNSSecDataChain chain; + DNS__LDNS__RR rr; + time_t check_time; + ALIAS: + _derive_trust_tree_time = 1 + +DNS__LDNS__RRList +_rrset(chain) + DNS__LDNS__DNSSecDataChain chain; + CODE: + RETVAL = chain->rrset; + OUTPUT: + RETVAL + +DNS__LDNS__RRList +_signatures(chain) + DNS__LDNS__DNSSecDataChain chain; + CODE: + RETVAL = chain->signatures; + OUTPUT: + RETVAL + +LDNS_RR_Type +parent_type(chain) + DNS__LDNS__DNSSecDataChain chain; + CODE: + RETVAL = chain->parent_type; + OUTPUT: + RETVAL + +DNS__LDNS__DNSSecDataChain +_parent(chain) + DNS__LDNS__DNSSecDataChain chain; + CODE: + RETVAL = chain->parent; + OUTPUT: + RETVAL + +LDNS_Pkt_Rcode +packet_rcode(chain) + DNS__LDNS__DNSSecDataChain chain; + CODE: + RETVAL = chain->packet_rcode; + OUTPUT: + RETVAL + +LDNS_RR_Type +packet_qtype(chain) + DNS__LDNS__DNSSecDataChain chain; + CODE: + RETVAL = chain->packet_qtype; + OUTPUT: + RETVAL + +signed char +packet_nodata(chain) + DNS__LDNS__DNSSecDataChain chain; + CODE: + RETVAL = chain->packet_nodata; + OUTPUT: + RETVAL + + +MODULE = DNS::LDNS PACKAGE = DNS::LDNS::DNSSecTrustTree + +DNS__LDNS__DNSSecTrustTree +ldns_dnssec_trust_tree_new() + ALIAS: + _new = 1 + +void +print(tree, fp, tabs, extended) + DNS__LDNS__DNSSecTrustTree tree; + FILE* fp; + size_t tabs; + bool extended; + CODE: + ldns_dnssec_trust_tree_print(fp, tree, tabs, extended); + +size_t +ldns_dnssec_trust_tree_depth(tree) + DNS__LDNS__DNSSecTrustTree tree; + ALIAS: + depth = 1 + +LDNS_Status +ldns_dnssec_trust_tree_add_parent(tree, parent, signature, parent_status) + DNS__LDNS__DNSSecTrustTree tree; + DNS__LDNS__DNSSecTrustTree parent; + DNS__LDNS__RR signature; + LDNS_Status parent_status; + ALIAS: + _add_parent = 1 + +LDNS_Status +ldns_dnssec_trust_tree_contains_keys(tree, trusted_keys) + DNS__LDNS__DNSSecTrustTree tree; + DNS__LDNS__RRList trusted_keys; + ALIAS: + _contains_keys = 1 + +DNS__LDNS__RR +_rr(tree) + DNS__LDNS__DNSSecTrustTree tree; + CODE: + RETVAL = tree->rr; + OUTPUT: + RETVAL + +DNS__LDNS__RRList +_rrset(tree) + DNS__LDNS__DNSSecTrustTree tree; + CODE: + RETVAL = tree->rrset; + OUTPUT: + RETVAL + +DNS__LDNS__DNSSecTrustTree +_parent(tree, i) + DNS__LDNS__DNSSecTrustTree tree; + size_t i; + CODE: + RETVAL = tree->parents[i]; + OUTPUT: + RETVAL + +LDNS_Status +_parent_status(tree, i) + DNS__LDNS__DNSSecTrustTree tree; + size_t i; + CODE: + RETVAL = tree->parent_status[i]; + OUTPUT: + RETVAL + +DNS__LDNS__RR +_parent_signature(tree, i) + DNS__LDNS__DNSSecTrustTree tree; + size_t i; + CODE: + RETVAL = tree->parent_signature[i]; + OUTPUT: + RETVAL + +size_t +parent_count(tree) + DNS__LDNS__DNSSecTrustTree tree; + CODE: + RETVAL = tree->parent_count; + OUTPUT: + RETVAL diff --git a/contrib/DNS-LDNS/MANIFEST b/contrib/DNS-LDNS/MANIFEST new file mode 100644 index 0000000000000..decbaa0d6c078 --- /dev/null +++ b/contrib/DNS-LDNS/MANIFEST @@ -0,0 +1,41 @@ +Changes +const-c.inc +const-xs.inc +fallback/const-c.inc +fallback/const-xs.inc +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 +Makefile.PL +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 diff --git a/contrib/DNS-LDNS/Makefile.PL b/contrib/DNS-LDNS/Makefile.PL new file mode 100755 index 0000000000000..2ee291ddb7659 --- /dev/null +++ b/contrib/DNS-LDNS/Makefile.PL @@ -0,0 +1,306 @@ +use 5.014002; +use ExtUtils::MakeMaker; +# See lib/ExtUtils/MakeMaker.pm for details of how to influence +# the contents of the Makefile that is written. +WriteMakefile( + NAME => 'DNS::LDNS', + VERSION_FROM => 'lib/DNS/LDNS.pm', # finds $VERSION + PREREQ_PM => {}, # e.g., Module::Name => 1.1 + ($] >= 5.005 ? ## Add these new keywords supported since 5.005 + (ABSTRACT_FROM => 'lib/DNS/LDNS.pm', # retrieve abstract from module + AUTHOR => 'Erik Pihl Ostlyngen <erik.ostlyngen@uninett.no>') : ()), + LIBS => ['-lldns'], + DEFINE => '', + INC => '-I.', + # Un-comment this if you add C files to link with later: + # OBJECT => '$(O_FILES)', # link all the C files too +); +if (eval {require ExtUtils::Constant; 1}) { + # 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', + ); + +} +else { + use File::Copy; + use File::Spec; + foreach my $file ('const-c.inc', 'const-xs.inc') { + my $fallback = File::Spec->catfile('fallback', $file); + copy ($fallback, $file) or die "Can't copy $fallback to $file: $!"; + } +} diff --git a/contrib/DNS-LDNS/README b/contrib/DNS-LDNS/README new file mode 100644 index 0000000000000..9f68303236555 --- /dev/null +++ b/contrib/DNS-LDNS/README @@ -0,0 +1,36 @@ +DNS::LDNS version 0.06 +====================== + +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. diff --git a/contrib/DNS-LDNS/const-c.inc b/contrib/DNS-LDNS/const-c.inc new file mode 100644 index 0000000000000..4b794458f9b4a --- /dev/null +++ b/contrib/DNS-LDNS/const-c.inc @@ -0,0 +1,2852 @@ +#define PERL_constant_NOTFOUND 1 +#define PERL_constant_NOTDEF 2 +#define PERL_constant_ISIV 3 +#define PERL_constant_ISNO 4 +#define PERL_constant_ISNV 5 +#define PERL_constant_ISPV 6 +#define PERL_constant_ISPVN 7 +#define PERL_constant_ISSV 8 +#define PERL_constant_ISUNDEF 9 +#define PERL_constant_ISUV 10 +#define PERL_constant_ISYES 11 + +#ifndef NVTYPE +typedef double NV; /* 5.6 and later define NVTYPE, and typedef NV to it. */ +#endif +#ifndef aTHX_ +#define aTHX_ /* 5.6 or later define this for threading support. */ +#endif +#ifndef pTHX_ +#define pTHX_ /* 5.6 or later define this for threading support. */ +#endif + +static int +constant_7 (pTHX_ const char *name, IV *iv_return) { + /* When generated this function returned values for the list of names given + here. However, subsequent manual editing may have added or removed some. + LDNS_AA LDNS_AD LDNS_CD LDNS_DH LDNS_QR LDNS_RA LDNS_RD LDNS_TC */ + /* Offset 5 gives the best switch position. */ + switch (name[5]) { + case 'A': + if (memEQ(name, "LDNS_AA", 7)) { + /* ^ */ +#ifdef LDNS_AA + *iv_return = LDNS_AA; + return PERL_constant_ISIV; +#else + return PERL_constant_NOTDEF; +#endif + } + if (memEQ(name, "LDNS_AD", 7)) { + /* ^ */ +#ifdef LDNS_AD + *iv_return = LDNS_AD; + return PERL_constant_ISIV; +#else + return PERL_constant_NOTDEF; +#endif + } + break; + case 'C': + if (memEQ(name, "LDNS_CD", 7)) { + /* ^ */ +#ifdef LDNS_CD + *iv_return = LDNS_CD; + return PERL_constant_ISIV; +#else + return PERL_constant_NOTDEF; +#endif + } + break; + case 'D': + if (memEQ(name, "LDNS_DH", 7)) { + /* ^ */ + *iv_return = LDNS_DH; + return PERL_constant_ISIV; + } + break; + case 'Q': + if (memEQ(name, "LDNS_QR", 7)) { + /* ^ */ +#ifdef LDNS_QR + *iv_return = LDNS_QR; + return PERL_constant_ISIV; +#else + return PERL_constant_NOTDEF; +#endif + } + break; + case 'R': + if (memEQ(name, "LDNS_RA", 7)) { + /* ^ */ +#ifdef LDNS_RA + *iv_return = LDNS_RA; + return PERL_constant_ISIV; +#else + return PERL_constant_NOTDEF; +#endif + } + if (memEQ(name, "LDNS_RD", 7)) { + /* ^ */ +#ifdef LDNS_RD + *iv_return = LDNS_RD; + return PERL_constant_ISIV; +#else + return PERL_constant_NOTDEF; +#endif + } + break; + case 'T': + if (memEQ(name, "LDNS_TC", 7)) { + /* ^ */ +#ifdef LDNS_TC + *iv_return = LDNS_TC; + return PERL_constant_ISIV; +#else + return PERL_constant_NOTDEF; +#endif + } + break; + } + return PERL_constant_NOTFOUND; +} + +static int +constant_13 (pTHX_ const char *name, IV *iv_return) { + /* When generated this function returned values for the list of names given + here. However, subsequent manual editing may have added or removed some. + LDNS_CERT_OID LDNS_CERT_PGP LDNS_CERT_URI LDNS_ECC_GOST LDNS_SIGN_DSA */ + /* Offset 12 gives the best switch position. */ + switch (name[12]) { + case 'A': + if (memEQ(name, "LDNS_SIGN_DS", 12)) { + /* A */ + *iv_return = LDNS_SIGN_DSA; + return PERL_constant_ISIV; + } + break; + case 'D': + if (memEQ(name, "LDNS_CERT_OI", 12)) { + /* D */ + *iv_return = LDNS_CERT_OID; + return PERL_constant_ISIV; + } + break; + case 'I': + if (memEQ(name, "LDNS_CERT_UR", 12)) { + /* I */ + *iv_return = LDNS_CERT_URI; + return PERL_constant_ISIV; + } + break; + case 'P': + if (memEQ(name, "LDNS_CERT_PG", 12)) { + /* P */ + *iv_return = LDNS_CERT_PGP; + return PERL_constant_ISIV; + } + break; + case 'T': + if (memEQ(name, "LDNS_ECC_GOS", 12)) { + /* T */ + *iv_return = LDNS_ECC_GOST; + return PERL_constant_ISIV; + } + break; + } + return PERL_constant_NOTFOUND; +} + +static int +constant_14 (pTHX_ const char *name, IV *iv_return) { + /* When generated this function returned values for the list of names given + here. However, subsequent manual editing may have added or removed some. + LDNS_CERT_IPGP LDNS_CERT_PKIX LDNS_CERT_SPKI LDNS_DSA_NSEC3 LDNS_HASH_GOST + LDNS_RR_TYPE_A LDNS_RSASHA256 LDNS_RSASHA512 LDNS_STATUS_OK */ + /* Offset 13 gives the best switch position. */ + switch (name[13]) { + case '2': + if (memEQ(name, "LDNS_RSASHA51", 13)) { + /* 2 */ + *iv_return = LDNS_RSASHA512; + return PERL_constant_ISIV; + } + break; + case '3': + if (memEQ(name, "LDNS_DSA_NSEC", 13)) { + /* 3 */ + *iv_return = LDNS_DSA_NSEC3; + return PERL_constant_ISIV; + } + break; + case '6': + if (memEQ(name, "LDNS_RSASHA25", 13)) { + /* 6 */ + *iv_return = LDNS_RSASHA256; + return PERL_constant_ISIV; + } + break; + case 'A': + if (memEQ(name, "LDNS_RR_TYPE_", 13)) { + /* A */ + *iv_return = LDNS_RR_TYPE_A; + return PERL_constant_ISIV; + } + break; + case 'I': + if (memEQ(name, "LDNS_CERT_SPK", 13)) { + /* I */ + *iv_return = LDNS_CERT_SPKI; + return PERL_constant_ISIV; + } + break; + case 'K': + if (memEQ(name, "LDNS_STATUS_O", 13)) { + /* K */ + *iv_return = LDNS_STATUS_OK; + return PERL_constant_ISIV; + } + break; + case 'P': + if (memEQ(name, "LDNS_CERT_IPG", 13)) { + /* P */ + *iv_return = LDNS_CERT_IPGP; + return PERL_constant_ISIV; + } + break; + case 'T': + if (memEQ(name, "LDNS_HASH_GOS", 13)) { + /* T */ + *iv_return = LDNS_HASH_GOST; + return PERL_constant_ISIV; + } + break; + case 'X': + if (memEQ(name, "LDNS_CERT_PKI", 13)) { + /* X */ + *iv_return = LDNS_CERT_PKIX; + return PERL_constant_ISIV; + } + break; + } + return PERL_constant_NOTFOUND; +} + +static int +constant_15 (pTHX_ const char *name, IV *iv_return) { + /* When generated this function returned values for the list of names given + here. However, subsequent manual editing may have added or removed some. + LDNS_CERT_IPKIX LDNS_CERT_ISPKI LDNS_IP4ADDRLEN LDNS_IP6ADDRLEN + LDNS_MAX_KEYLEN LDNS_MAX_RDFLEN LDNS_PRIVATEDNS LDNS_PRIVATEOID + LDNS_RDF_TYPE_A LDNS_RR_TYPE_A6 LDNS_RR_TYPE_DS LDNS_RR_TYPE_KX + LDNS_RR_TYPE_MB LDNS_RR_TYPE_MD LDNS_RR_TYPE_MF LDNS_RR_TYPE_MG + LDNS_RR_TYPE_MR LDNS_RR_TYPE_MX LDNS_RR_TYPE_NS LDNS_RR_TYPE_PX + LDNS_RR_TYPE_RP LDNS_RR_TYPE_RT LDNS_STATUS_ERR */ + /* Offset 14 gives the best switch position. */ + switch (name[14]) { + case '6': + if (memEQ(name, "LDNS_RR_TYPE_A", 14)) { + /* 6 */ + *iv_return = LDNS_RR_TYPE_A6; + return PERL_constant_ISIV; + } + break; + case 'A': + if (memEQ(name, "LDNS_RDF_TYPE_", 14)) { + /* A */ + *iv_return = LDNS_RDF_TYPE_A; + return PERL_constant_ISIV; + } + break; + case 'B': + if (memEQ(name, "LDNS_RR_TYPE_M", 14)) { + /* B */ + *iv_return = LDNS_RR_TYPE_MB; + return PERL_constant_ISIV; + } + break; + case 'D': + if (memEQ(name, "LDNS_PRIVATEOI", 14)) { + /* D */ + *iv_return = LDNS_PRIVATEOID; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RR_TYPE_M", 14)) { + /* D */ + *iv_return = LDNS_RR_TYPE_MD; + return PERL_constant_ISIV; + } + break; + case 'F': + if (memEQ(name, "LDNS_RR_TYPE_M", 14)) { + /* F */ + *iv_return = LDNS_RR_TYPE_MF; + return PERL_constant_ISIV; + } + break; + case 'G': + if (memEQ(name, "LDNS_RR_TYPE_M", 14)) { + /* G */ + *iv_return = LDNS_RR_TYPE_MG; + return PERL_constant_ISIV; + } + break; + case 'I': + if (memEQ(name, "LDNS_CERT_ISPK", 14)) { + /* I */ + *iv_return = LDNS_CERT_ISPKI; + return PERL_constant_ISIV; + } + break; + case 'N': + if (memEQ(name, "LDNS_IP4ADDRLE", 14)) { + /* N */ +#ifdef LDNS_IP4ADDRLEN + *iv_return = LDNS_IP4ADDRLEN; + return PERL_constant_ISIV; +#else + return PERL_constant_NOTDEF; +#endif + } + if (memEQ(name, "LDNS_IP6ADDRLE", 14)) { + /* N */ +#ifdef LDNS_IP6ADDRLEN + *iv_return = LDNS_IP6ADDRLEN; + return PERL_constant_ISIV; +#else + return PERL_constant_NOTDEF; +#endif + } + if (memEQ(name, "LDNS_MAX_KEYLE", 14)) { + /* N */ +#ifdef LDNS_MAX_KEYLEN + *iv_return = LDNS_MAX_KEYLEN; + return PERL_constant_ISIV; +#else + return PERL_constant_NOTDEF; +#endif + } + if (memEQ(name, "LDNS_MAX_RDFLE", 14)) { + /* N */ +#ifdef LDNS_MAX_RDFLEN + *iv_return = LDNS_MAX_RDFLEN; + return PERL_constant_ISIV; +#else + return PERL_constant_NOTDEF; +#endif + } + break; + case 'P': + if (memEQ(name, "LDNS_RR_TYPE_R", 14)) { + /* P */ + *iv_return = LDNS_RR_TYPE_RP; + return PERL_constant_ISIV; + } + break; + case 'R': + if (memEQ(name, "LDNS_RR_TYPE_M", 14)) { + /* R */ + *iv_return = LDNS_RR_TYPE_MR; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_STATUS_ER", 14)) { + /* R */ + *iv_return = LDNS_STATUS_ERR; + return PERL_constant_ISIV; + } + break; + case 'S': + if (memEQ(name, "LDNS_PRIVATEDN", 14)) { + /* S */ + *iv_return = LDNS_PRIVATEDNS; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RR_TYPE_D", 14)) { + /* S */ + *iv_return = LDNS_RR_TYPE_DS; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RR_TYPE_N", 14)) { + /* S */ + *iv_return = LDNS_RR_TYPE_NS; + return PERL_constant_ISIV; + } + break; + case 'T': + if (memEQ(name, "LDNS_RR_TYPE_R", 14)) { + /* T */ + *iv_return = LDNS_RR_TYPE_RT; + return PERL_constant_ISIV; + } + break; + case 'X': + if (memEQ(name, "LDNS_CERT_IPKI", 14)) { + /* X */ + *iv_return = LDNS_CERT_IPKIX; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RR_TYPE_K", 14)) { + /* X */ + *iv_return = LDNS_RR_TYPE_KX; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RR_TYPE_M", 14)) { + /* X */ + *iv_return = LDNS_RR_TYPE_MX; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RR_TYPE_P", 14)) { + /* X */ + *iv_return = LDNS_RR_TYPE_PX; + return PERL_constant_ISIV; + } + break; + } + return PERL_constant_NOTFOUND; +} + +static int +constant_16 (pTHX_ const char *name, IV *iv_return) { + /* When generated this function returned values for the list of names given + here. However, subsequent manual editing may have added or removed some. + LDNS_CERT_ACPKIX LDNS_DEFAULT_TTL LDNS_KEY_SEP_KEY LDNS_RESOLV_INET + LDNS_RR_CLASS_CH LDNS_RR_CLASS_HS LDNS_RR_CLASS_IN LDNS_RR_COMPRESS + LDNS_RR_OVERHEAD LDNS_RR_TYPE_ANY LDNS_RR_TYPE_APL LDNS_RR_TYPE_DLV + LDNS_RR_TYPE_EID LDNS_RR_TYPE_GID LDNS_RR_TYPE_KEY LDNS_RR_TYPE_LOC + LDNS_RR_TYPE_NXT LDNS_RR_TYPE_OPT LDNS_RR_TYPE_PTR LDNS_RR_TYPE_SIG + LDNS_RR_TYPE_SOA LDNS_RR_TYPE_SPF LDNS_RR_TYPE_SRV LDNS_RR_TYPE_TXT + LDNS_RR_TYPE_UID LDNS_RR_TYPE_WKS LDNS_RR_TYPE_X25 LDNS_SECTION_ANY + LDNS_SIGN_RSAMD5 LDNS_STATUS_NULL */ + /* Offset 13 gives the best switch position. */ + switch (name[13]) { + case 'A': + if (memEQ(name, "LDNS_RR_TYPE_ANY", 16)) { + /* ^ */ + *iv_return = LDNS_RR_TYPE_ANY; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RR_TYPE_APL", 16)) { + /* ^ */ + *iv_return = LDNS_RR_TYPE_APL; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_SECTION_ANY", 16)) { + /* ^ */ + *iv_return = LDNS_SECTION_ANY; + return PERL_constant_ISIV; + } + break; + case 'D': + if (memEQ(name, "LDNS_RR_TYPE_DLV", 16)) { + /* ^ */ + *iv_return = LDNS_RR_TYPE_DLV; + return PERL_constant_ISIV; + } + break; + case 'E': + if (memEQ(name, "LDNS_RR_COMPRESS", 16)) { + /* ^ */ + *iv_return = LDNS_RR_COMPRESS; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RR_OVERHEAD", 16)) { + /* ^ */ +#ifdef LDNS_RR_OVERHEAD + *iv_return = LDNS_RR_OVERHEAD; + return PERL_constant_ISIV; +#else + return PERL_constant_NOTDEF; +#endif + } + if (memEQ(name, "LDNS_RR_TYPE_EID", 16)) { + /* ^ */ + *iv_return = LDNS_RR_TYPE_EID; + return PERL_constant_ISIV; + } + break; + case 'G': + if (memEQ(name, "LDNS_RR_TYPE_GID", 16)) { + /* ^ */ + *iv_return = LDNS_RR_TYPE_GID; + return PERL_constant_ISIV; + } + break; + case 'K': + if (memEQ(name, "LDNS_CERT_ACPKIX", 16)) { + /* ^ */ + *iv_return = LDNS_CERT_ACPKIX; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_KEY_SEP_KEY", 16)) { + /* ^ */ +#ifdef LDNS_KEY_SEP_KEY + *iv_return = LDNS_KEY_SEP_KEY; + return PERL_constant_ISIV; +#else + return PERL_constant_NOTDEF; +#endif + } + if (memEQ(name, "LDNS_RR_TYPE_KEY", 16)) { + /* ^ */ + *iv_return = LDNS_RR_TYPE_KEY; + return PERL_constant_ISIV; + } + break; + case 'L': + if (memEQ(name, "LDNS_RR_TYPE_LOC", 16)) { + /* ^ */ + *iv_return = LDNS_RR_TYPE_LOC; + return PERL_constant_ISIV; + } + break; + case 'M': + if (memEQ(name, "LDNS_SIGN_RSAMD5", 16)) { + /* ^ */ + *iv_return = LDNS_SIGN_RSAMD5; + return PERL_constant_ISIV; + } + break; + case 'N': + if (memEQ(name, "LDNS_RESOLV_INET", 16)) { + /* ^ */ +#ifdef LDNS_RESOLV_INET + *iv_return = LDNS_RESOLV_INET; + return PERL_constant_ISIV; +#else + return PERL_constant_NOTDEF; +#endif + } + if (memEQ(name, "LDNS_RR_TYPE_NXT", 16)) { + /* ^ */ + *iv_return = LDNS_RR_TYPE_NXT; + return PERL_constant_ISIV; + } + break; + case 'O': + if (memEQ(name, "LDNS_RR_TYPE_OPT", 16)) { + /* ^ */ + *iv_return = LDNS_RR_TYPE_OPT; + return PERL_constant_ISIV; + } + break; + case 'P': + if (memEQ(name, "LDNS_RR_TYPE_PTR", 16)) { + /* ^ */ + *iv_return = LDNS_RR_TYPE_PTR; + return PERL_constant_ISIV; + } + break; + case 'S': + if (memEQ(name, "LDNS_RR_TYPE_SIG", 16)) { + /* ^ */ + *iv_return = LDNS_RR_TYPE_SIG; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RR_TYPE_SOA", 16)) { + /* ^ */ + *iv_return = LDNS_RR_TYPE_SOA; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RR_TYPE_SPF", 16)) { + /* ^ */ + *iv_return = LDNS_RR_TYPE_SPF; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RR_TYPE_SRV", 16)) { + /* ^ */ + *iv_return = LDNS_RR_TYPE_SRV; + return PERL_constant_ISIV; + } + break; + case 'T': + if (memEQ(name, "LDNS_DEFAULT_TTL", 16)) { + /* ^ */ +#ifdef LDNS_DEFAULT_TTL + *iv_return = LDNS_DEFAULT_TTL; + return PERL_constant_ISIV; +#else + return PERL_constant_NOTDEF; +#endif + } + if (memEQ(name, "LDNS_RR_TYPE_TXT", 16)) { + /* ^ */ + *iv_return = LDNS_RR_TYPE_TXT; + return PERL_constant_ISIV; + } + break; + case 'U': + if (memEQ(name, "LDNS_RR_TYPE_UID", 16)) { + /* ^ */ + *iv_return = LDNS_RR_TYPE_UID; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_STATUS_NULL", 16)) { + /* ^ */ + *iv_return = LDNS_STATUS_NULL; + return PERL_constant_ISIV; + } + break; + case 'W': + if (memEQ(name, "LDNS_RR_TYPE_WKS", 16)) { + /* ^ */ + *iv_return = LDNS_RR_TYPE_WKS; + return PERL_constant_ISIV; + } + break; + case 'X': + if (memEQ(name, "LDNS_RR_TYPE_X25", 16)) { + /* ^ */ + *iv_return = LDNS_RR_TYPE_X25; + return PERL_constant_ISIV; + } + break; + case '_': + if (memEQ(name, "LDNS_RR_CLASS_CH", 16)) { + /* ^ */ + *iv_return = LDNS_RR_CLASS_CH; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RR_CLASS_HS", 16)) { + /* ^ */ + *iv_return = LDNS_RR_CLASS_HS; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RR_CLASS_IN", 16)) { + /* ^ */ + *iv_return = LDNS_RR_CLASS_IN; + return PERL_constant_ISIV; + } + break; + } + return PERL_constant_NOTFOUND; +} + +static int +constant_17 (pTHX_ const char *name, IV *iv_return) { + /* When generated this function returned values for the list of names given + here. However, subsequent manual editing may have added or removed some. + LDNS_CERT_IACPKIX LDNS_KEY_ZONE_KEY LDNS_MAX_LABELLEN LDNS_MAX_POINTERS + LDNS_PACKET_QUERY LDNS_RDF_TYPE_ALG LDNS_RDF_TYPE_APL LDNS_RDF_TYPE_B64 + LDNS_RDF_TYPE_HEX LDNS_RDF_TYPE_HIP LDNS_RDF_TYPE_LOC LDNS_RDF_TYPE_STR + LDNS_RDF_TYPE_WKS LDNS_RESOLV_INET6 LDNS_RR_CLASS_ANY LDNS_RR_TYPE_AAAA + LDNS_RR_TYPE_ATMA LDNS_RR_TYPE_AXFR LDNS_RR_TYPE_CERT LDNS_RR_TYPE_GPOS + LDNS_RR_TYPE_ISDN LDNS_RR_TYPE_IXFR LDNS_RR_TYPE_LAST LDNS_RR_TYPE_NSAP + LDNS_RR_TYPE_NSEC LDNS_RR_TYPE_NULL LDNS_RR_TYPE_SINK LDNS_RR_TYPE_TSIG + LDNS_SIGN_RSASHA1 */ + /* Offset 16 gives the best switch position. */ + switch (name[16]) { + case '1': + if (memEQ(name, "LDNS_SIGN_RSASHA", 16)) { + /* 1 */ + *iv_return = LDNS_SIGN_RSASHA1; + return PERL_constant_ISIV; + } + break; + case '4': + if (memEQ(name, "LDNS_RDF_TYPE_B6", 16)) { + /* 4 */ + *iv_return = LDNS_RDF_TYPE_B64; + return PERL_constant_ISIV; + } + break; + case '6': + if (memEQ(name, "LDNS_RESOLV_INET", 16)) { + /* 6 */ +#ifdef LDNS_RESOLV_INET6 + *iv_return = LDNS_RESOLV_INET6; + return PERL_constant_ISIV; +#else + return PERL_constant_NOTDEF; +#endif + } + break; + case 'A': + if (memEQ(name, "LDNS_RR_TYPE_AAA", 16)) { + /* A */ + *iv_return = LDNS_RR_TYPE_AAAA; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RR_TYPE_ATM", 16)) { + /* A */ + *iv_return = LDNS_RR_TYPE_ATMA; + return PERL_constant_ISIV; + } + break; + case 'C': + if (memEQ(name, "LDNS_RDF_TYPE_LO", 16)) { + /* C */ + *iv_return = LDNS_RDF_TYPE_LOC; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RR_TYPE_NSE", 16)) { + /* C */ + *iv_return = LDNS_RR_TYPE_NSEC; + return PERL_constant_ISIV; + } + break; + case 'G': + if (memEQ(name, "LDNS_RDF_TYPE_AL", 16)) { + /* G */ + *iv_return = LDNS_RDF_TYPE_ALG; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RR_TYPE_TSI", 16)) { + /* G */ + *iv_return = LDNS_RR_TYPE_TSIG; + return PERL_constant_ISIV; + } + break; + case 'K': + if (memEQ(name, "LDNS_RR_TYPE_SIN", 16)) { + /* K */ + *iv_return = LDNS_RR_TYPE_SINK; + return PERL_constant_ISIV; + } + break; + case 'L': + if (memEQ(name, "LDNS_RDF_TYPE_AP", 16)) { + /* L */ + *iv_return = LDNS_RDF_TYPE_APL; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RR_TYPE_NUL", 16)) { + /* L */ + *iv_return = LDNS_RR_TYPE_NULL; + return PERL_constant_ISIV; + } + break; + case 'N': + if (memEQ(name, "LDNS_MAX_LABELLE", 16)) { + /* N */ +#ifdef LDNS_MAX_LABELLEN + *iv_return = LDNS_MAX_LABELLEN; + return PERL_constant_ISIV; +#else + return PERL_constant_NOTDEF; +#endif + } + if (memEQ(name, "LDNS_RR_TYPE_ISD", 16)) { + /* N */ + *iv_return = LDNS_RR_TYPE_ISDN; + return PERL_constant_ISIV; + } + break; + case 'P': + if (memEQ(name, "LDNS_RDF_TYPE_HI", 16)) { + /* P */ + *iv_return = LDNS_RDF_TYPE_HIP; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RR_TYPE_NSA", 16)) { + /* P */ + *iv_return = LDNS_RR_TYPE_NSAP; + return PERL_constant_ISIV; + } + break; + case 'R': + if (memEQ(name, "LDNS_RDF_TYPE_ST", 16)) { + /* R */ + *iv_return = LDNS_RDF_TYPE_STR; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RR_TYPE_AXF", 16)) { + /* R */ + *iv_return = LDNS_RR_TYPE_AXFR; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RR_TYPE_IXF", 16)) { + /* R */ + *iv_return = LDNS_RR_TYPE_IXFR; + return PERL_constant_ISIV; + } + break; + case 'S': + if (memEQ(name, "LDNS_MAX_POINTER", 16)) { + /* S */ +#ifdef LDNS_MAX_POINTERS + *iv_return = LDNS_MAX_POINTERS; + return PERL_constant_ISIV; +#else + return PERL_constant_NOTDEF; +#endif + } + if (memEQ(name, "LDNS_RDF_TYPE_WK", 16)) { + /* S */ + *iv_return = LDNS_RDF_TYPE_WKS; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RR_TYPE_GPO", 16)) { + /* S */ + *iv_return = LDNS_RR_TYPE_GPOS; + return PERL_constant_ISIV; + } + break; + case 'T': + if (memEQ(name, "LDNS_RR_TYPE_CER", 16)) { + /* T */ + *iv_return = LDNS_RR_TYPE_CERT; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RR_TYPE_LAS", 16)) { + /* T */ + *iv_return = LDNS_RR_TYPE_LAST; + return PERL_constant_ISIV; + } + break; + case 'X': + if (memEQ(name, "LDNS_CERT_IACPKI", 16)) { + /* X */ + *iv_return = LDNS_CERT_IACPKIX; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RDF_TYPE_HE", 16)) { + /* X */ + *iv_return = LDNS_RDF_TYPE_HEX; + return PERL_constant_ISIV; + } + break; + case 'Y': + if (memEQ(name, "LDNS_KEY_ZONE_KE", 16)) { + /* Y */ +#ifdef LDNS_KEY_ZONE_KEY + *iv_return = LDNS_KEY_ZONE_KEY; + return PERL_constant_ISIV; +#else + return PERL_constant_NOTDEF; +#endif + } + if (memEQ(name, "LDNS_PACKET_QUER", 16)) { + /* Y */ + *iv_return = LDNS_PACKET_QUERY; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RR_CLASS_AN", 16)) { + /* Y */ + *iv_return = LDNS_RR_CLASS_ANY; + return PERL_constant_ISIV; + } + break; + } + return PERL_constant_NOTFOUND; +} + +static int +constant_18 (pTHX_ const char *name, IV *iv_return) { + /* When generated this function returned values for the list of names given + here. However, subsequent manual editing may have added or removed some. + LDNS_MAX_DOMAINLEN LDNS_MAX_PACKETLEN LDNS_PACKET_ANSWER + LDNS_PACKET_IQUERY LDNS_PACKET_NODATA LDNS_PACKET_NOTIFY + LDNS_PACKET_STATUS LDNS_PACKET_UPDATE LDNS_RCODE_FORMERR + LDNS_RCODE_NOERROR LDNS_RCODE_NOTAUTH LDNS_RCODE_NOTIMPL + LDNS_RCODE_NOTZONE LDNS_RCODE_NXRRSET LDNS_RCODE_REFUSED + LDNS_RCODE_YXRRSET LDNS_RDF_SIZE_BYTE LDNS_RDF_SIZE_WORD + LDNS_RDF_TYPE_AAAA LDNS_RDF_TYPE_ATMA LDNS_RDF_TYPE_INT8 + LDNS_RDF_TYPE_NONE LDNS_RDF_TYPE_NSAP LDNS_RDF_TYPE_NSEC + LDNS_RDF_TYPE_TIME LDNS_RDF_TYPE_TYPE LDNS_RESOLV_ANCHOR + LDNS_RESOLV_SEARCH LDNS_RR_CLASS_LAST LDNS_RR_CLASS_NONE + LDNS_RR_TYPE_AFSDB LDNS_RR_TYPE_CNAME LDNS_RR_TYPE_COUNT + LDNS_RR_TYPE_DHCID LDNS_RR_TYPE_DNAME LDNS_RR_TYPE_FIRST + LDNS_RR_TYPE_HINFO LDNS_RR_TYPE_MAILA LDNS_RR_TYPE_MAILB + LDNS_RR_TYPE_MINFO LDNS_RR_TYPE_NAPTR LDNS_RR_TYPE_NSEC3 + LDNS_RR_TYPE_RRSIG LDNS_RR_TYPE_SSHFP LDNS_RR_TYPE_UINFO + LDNS_RSASHA1_NSEC3 LDNS_SIGN_ECC_GOST LDNS_SIGN_HMACSHA1 */ + /* Offset 17 gives the best switch position. */ + switch (name[17]) { + case '1': + if (memEQ(name, "LDNS_SIGN_HMACSHA", 17)) { + /* 1 */ + *iv_return = LDNS_SIGN_HMACSHA1; + return PERL_constant_ISIV; + } + break; + case '3': + if (memEQ(name, "LDNS_RR_TYPE_NSEC", 17)) { + /* 3 */ + *iv_return = LDNS_RR_TYPE_NSEC3; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RSASHA1_NSEC", 17)) { + /* 3 */ + *iv_return = LDNS_RSASHA1_NSEC3; + return PERL_constant_ISIV; + } + break; + case '8': + if (memEQ(name, "LDNS_RDF_TYPE_INT", 17)) { + /* 8 */ + *iv_return = LDNS_RDF_TYPE_INT8; + return PERL_constant_ISIV; + } + break; + case 'A': + if (memEQ(name, "LDNS_PACKET_NODAT", 17)) { + /* A */ + *iv_return = LDNS_PACKET_NODATA; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RDF_TYPE_AAA", 17)) { + /* A */ + *iv_return = LDNS_RDF_TYPE_AAAA; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RDF_TYPE_ATM", 17)) { + /* A */ + *iv_return = LDNS_RDF_TYPE_ATMA; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RR_TYPE_MAIL", 17)) { + /* A */ + *iv_return = LDNS_RR_TYPE_MAILA; + return PERL_constant_ISIV; + } + break; + case 'B': + if (memEQ(name, "LDNS_RR_TYPE_AFSD", 17)) { + /* B */ + *iv_return = LDNS_RR_TYPE_AFSDB; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RR_TYPE_MAIL", 17)) { + /* B */ + *iv_return = LDNS_RR_TYPE_MAILB; + return PERL_constant_ISIV; + } + break; + case 'C': + if (memEQ(name, "LDNS_RDF_TYPE_NSE", 17)) { + /* C */ + *iv_return = LDNS_RDF_TYPE_NSEC; + return PERL_constant_ISIV; + } + break; + case 'D': + if (memEQ(name, "LDNS_RCODE_REFUSE", 17)) { + /* D */ + *iv_return = LDNS_RCODE_REFUSED; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RDF_SIZE_WOR", 17)) { + /* D */ +#ifdef LDNS_RDF_SIZE_WORD + *iv_return = LDNS_RDF_SIZE_WORD; + return PERL_constant_ISIV; +#else + return PERL_constant_NOTDEF; +#endif + } + if (memEQ(name, "LDNS_RR_TYPE_DHCI", 17)) { + /* D */ + *iv_return = LDNS_RR_TYPE_DHCID; + return PERL_constant_ISIV; + } + break; + case 'E': + if (memEQ(name, "LDNS_PACKET_UPDAT", 17)) { + /* E */ + *iv_return = LDNS_PACKET_UPDATE; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RCODE_NOTZON", 17)) { + /* E */ + *iv_return = LDNS_RCODE_NOTZONE; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RDF_SIZE_BYT", 17)) { + /* E */ +#ifdef LDNS_RDF_SIZE_BYTE + *iv_return = LDNS_RDF_SIZE_BYTE; + return PERL_constant_ISIV; +#else + return PERL_constant_NOTDEF; +#endif + } + if (memEQ(name, "LDNS_RDF_TYPE_NON", 17)) { + /* E */ + *iv_return = LDNS_RDF_TYPE_NONE; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RDF_TYPE_TIM", 17)) { + /* E */ + *iv_return = LDNS_RDF_TYPE_TIME; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RDF_TYPE_TYP", 17)) { + /* E */ + *iv_return = LDNS_RDF_TYPE_TYPE; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RR_CLASS_NON", 17)) { + /* E */ + *iv_return = LDNS_RR_CLASS_NONE; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RR_TYPE_CNAM", 17)) { + /* E */ + *iv_return = LDNS_RR_TYPE_CNAME; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RR_TYPE_DNAM", 17)) { + /* E */ + *iv_return = LDNS_RR_TYPE_DNAME; + return PERL_constant_ISIV; + } + break; + case 'G': + if (memEQ(name, "LDNS_RR_TYPE_RRSI", 17)) { + /* G */ + *iv_return = LDNS_RR_TYPE_RRSIG; + return PERL_constant_ISIV; + } + break; + case 'H': + if (memEQ(name, "LDNS_RCODE_NOTAUT", 17)) { + /* H */ + *iv_return = LDNS_RCODE_NOTAUTH; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RESOLV_SEARC", 17)) { + /* H */ +#ifdef LDNS_RESOLV_SEARCH + *iv_return = LDNS_RESOLV_SEARCH; + return PERL_constant_ISIV; +#else + return PERL_constant_NOTDEF; +#endif + } + break; + case 'L': + if (memEQ(name, "LDNS_RCODE_NOTIMP", 17)) { + /* L */ + *iv_return = LDNS_RCODE_NOTIMPL; + return PERL_constant_ISIV; + } + break; + case 'N': + if (memEQ(name, "LDNS_MAX_DOMAINLE", 17)) { + /* N */ +#ifdef LDNS_MAX_DOMAINLEN + *iv_return = LDNS_MAX_DOMAINLEN; + return PERL_constant_ISIV; +#else + return PERL_constant_NOTDEF; +#endif + } + if (memEQ(name, "LDNS_MAX_PACKETLE", 17)) { + /* N */ +#ifdef LDNS_MAX_PACKETLEN + *iv_return = LDNS_MAX_PACKETLEN; + return PERL_constant_ISIV; +#else + return PERL_constant_NOTDEF; +#endif + } + break; + case 'O': + if (memEQ(name, "LDNS_RR_TYPE_HINF", 17)) { + /* O */ + *iv_return = LDNS_RR_TYPE_HINFO; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RR_TYPE_MINF", 17)) { + /* O */ + *iv_return = LDNS_RR_TYPE_MINFO; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RR_TYPE_UINF", 17)) { + /* O */ + *iv_return = LDNS_RR_TYPE_UINFO; + return PERL_constant_ISIV; + } + break; + case 'P': + if (memEQ(name, "LDNS_RDF_TYPE_NSA", 17)) { + /* P */ + *iv_return = LDNS_RDF_TYPE_NSAP; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RR_TYPE_SSHF", 17)) { + /* P */ + *iv_return = LDNS_RR_TYPE_SSHFP; + return PERL_constant_ISIV; + } + break; + case 'R': + if (memEQ(name, "LDNS_PACKET_ANSWE", 17)) { + /* R */ + *iv_return = LDNS_PACKET_ANSWER; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RCODE_FORMER", 17)) { + /* R */ + *iv_return = LDNS_RCODE_FORMERR; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RCODE_NOERRO", 17)) { + /* R */ + *iv_return = LDNS_RCODE_NOERROR; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RESOLV_ANCHO", 17)) { + /* R */ +#ifdef LDNS_RESOLV_ANCHOR + *iv_return = LDNS_RESOLV_ANCHOR; + return PERL_constant_ISIV; +#else + return PERL_constant_NOTDEF; +#endif + } + if (memEQ(name, "LDNS_RR_TYPE_NAPT", 17)) { + /* R */ + *iv_return = LDNS_RR_TYPE_NAPTR; + return PERL_constant_ISIV; + } + break; + case 'S': + if (memEQ(name, "LDNS_PACKET_STATU", 17)) { + /* S */ + *iv_return = LDNS_PACKET_STATUS; + return PERL_constant_ISIV; + } + break; + case 'T': + if (memEQ(name, "LDNS_RCODE_NXRRSE", 17)) { + /* T */ + *iv_return = LDNS_RCODE_NXRRSET; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RCODE_YXRRSE", 17)) { + /* T */ + *iv_return = LDNS_RCODE_YXRRSET; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RR_CLASS_LAS", 17)) { + /* T */ + *iv_return = LDNS_RR_CLASS_LAST; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RR_TYPE_COUN", 17)) { + /* T */ + *iv_return = LDNS_RR_TYPE_COUNT; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RR_TYPE_FIRS", 17)) { + /* T */ + *iv_return = LDNS_RR_TYPE_FIRST; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_SIGN_ECC_GOS", 17)) { + /* T */ + *iv_return = LDNS_SIGN_ECC_GOST; + return PERL_constant_ISIV; + } + break; + case 'Y': + if (memEQ(name, "LDNS_PACKET_IQUER", 17)) { + /* Y */ + *iv_return = LDNS_PACKET_IQUERY; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_PACKET_NOTIF", 17)) { + /* Y */ + *iv_return = LDNS_PACKET_NOTIFY; + return PERL_constant_ISIV; + } + break; + } + return PERL_constant_NOTFOUND; +} + +static int +constant_19 (pTHX_ const char *name, IV *iv_return) { + /* When generated this function returned values for the list of names given + here. However, subsequent manual editing may have added or removed some. + LDNS_KEY_REVOKE_KEY LDNS_PACKET_UNKNOWN LDNS_RCODE_NXDOMAIN + LDNS_RCODE_SERVFAIL LDNS_RCODE_YXDOMAIN LDNS_RDF_TYPE_CLASS + LDNS_RDF_TYPE_DNAME LDNS_RDF_TYPE_INT16 LDNS_RDF_TYPE_INT32 + LDNS_RESOLV_INETANY LDNS_RESOLV_KEYWORD LDNS_RESOLV_OPTIONS + LDNS_RESOLV_RTT_INF LDNS_RESOLV_RTT_MIN LDNS_RR_CLASS_COUNT + LDNS_RR_CLASS_FIRST LDNS_RR_NO_COMPRESS LDNS_RR_TYPE_DNSKEY + LDNS_RR_TYPE_NIMLOC LDNS_RR_TYPE_TALINK LDNS_RR_TYPE_UNSPEC + LDNS_SECTION_ANSWER LDNS_SIGN_DSA_NSEC3 LDNS_SIGN_RSASHA256 + LDNS_SIGN_RSASHA512 LDNS_STATUS_MEM_ERR LDNS_STATUS_NO_DATA + LDNS_STATUS_SSL_ERR */ + /* Offset 14 gives the best switch position. */ + switch (name[14]) { + case 'A': + if (memEQ(name, "LDNS_RR_TYPE_TALINK", 19)) { + /* ^ */ + *iv_return = LDNS_RR_TYPE_TALINK; + return PERL_constant_ISIV; + } + break; + case 'C': + if (memEQ(name, "LDNS_RDF_TYPE_CLASS", 19)) { + /* ^ */ + *iv_return = LDNS_RDF_TYPE_CLASS; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RR_CLASS_COUNT", 19)) { + /* ^ */ + *iv_return = LDNS_RR_CLASS_COUNT; + return PERL_constant_ISIV; + } + break; + case 'D': + if (memEQ(name, "LDNS_RDF_TYPE_DNAME", 19)) { + /* ^ */ + *iv_return = LDNS_RDF_TYPE_DNAME; + return PERL_constant_ISIV; + } + break; + case 'E': + if (memEQ(name, "LDNS_KEY_REVOKE_KEY", 19)) { + /* ^ */ +#ifdef LDNS_KEY_REVOKE_KEY + *iv_return = LDNS_KEY_REVOKE_KEY; + return PERL_constant_ISIV; +#else + return PERL_constant_NOTDEF; +#endif + } + if (memEQ(name, "LDNS_RESOLV_INETANY", 19)) { + /* ^ */ +#ifdef LDNS_RESOLV_INETANY + *iv_return = LDNS_RESOLV_INETANY; + return PERL_constant_ISIV; +#else + return PERL_constant_NOTDEF; +#endif + } + break; + case 'F': + if (memEQ(name, "LDNS_RR_CLASS_FIRST", 19)) { + /* ^ */ + *iv_return = LDNS_RR_CLASS_FIRST; + return PERL_constant_ISIV; + } + break; + case 'H': + if (memEQ(name, "LDNS_SIGN_RSASHA256", 19)) { + /* ^ */ + *iv_return = LDNS_SIGN_RSASHA256; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_SIGN_RSASHA512", 19)) { + /* ^ */ + *iv_return = LDNS_SIGN_RSASHA512; + return PERL_constant_ISIV; + } + break; + case 'I': + if (memEQ(name, "LDNS_RDF_TYPE_INT16", 19)) { + /* ^ */ + *iv_return = LDNS_RDF_TYPE_INT16; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RDF_TYPE_INT32", 19)) { + /* ^ */ + *iv_return = LDNS_RDF_TYPE_INT32; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RR_TYPE_NIMLOC", 19)) { + /* ^ */ + *iv_return = LDNS_RR_TYPE_NIMLOC; + return PERL_constant_ISIV; + } + break; + case 'K': + if (memEQ(name, "LDNS_PACKET_UNKNOWN", 19)) { + /* ^ */ + *iv_return = LDNS_PACKET_UNKNOWN; + return PERL_constant_ISIV; + } + break; + case 'L': + if (memEQ(name, "LDNS_STATUS_SSL_ERR", 19)) { + /* ^ */ + *iv_return = LDNS_STATUS_SSL_ERR; + return PERL_constant_ISIV; + } + break; + case 'M': + if (memEQ(name, "LDNS_STATUS_MEM_ERR", 19)) { + /* ^ */ + *iv_return = LDNS_STATUS_MEM_ERR; + return PERL_constant_ISIV; + } + break; + case 'N': + if (memEQ(name, "LDNS_RR_TYPE_DNSKEY", 19)) { + /* ^ */ + *iv_return = LDNS_RR_TYPE_DNSKEY; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RR_TYPE_UNSPEC", 19)) { + /* ^ */ + *iv_return = LDNS_RR_TYPE_UNSPEC; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_SECTION_ANSWER", 19)) { + /* ^ */ + *iv_return = LDNS_SECTION_ANSWER; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_SIGN_DSA_NSEC3", 19)) { + /* ^ */ + *iv_return = LDNS_SIGN_DSA_NSEC3; + return PERL_constant_ISIV; + } + break; + case 'O': + if (memEQ(name, "LDNS_RCODE_NXDOMAIN", 19)) { + /* ^ */ + *iv_return = LDNS_RCODE_NXDOMAIN; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RCODE_YXDOMAIN", 19)) { + /* ^ */ + *iv_return = LDNS_RCODE_YXDOMAIN; + return PERL_constant_ISIV; + } + break; + case 'P': + if (memEQ(name, "LDNS_RR_NO_COMPRESS", 19)) { + /* ^ */ + *iv_return = LDNS_RR_NO_COMPRESS; + return PERL_constant_ISIV; + } + break; + case 'T': + if (memEQ(name, "LDNS_RESOLV_OPTIONS", 19)) { + /* ^ */ +#ifdef LDNS_RESOLV_OPTIONS + *iv_return = LDNS_RESOLV_OPTIONS; + return PERL_constant_ISIV; +#else + return PERL_constant_NOTDEF; +#endif + } + if (memEQ(name, "LDNS_RESOLV_RTT_INF", 19)) { + /* ^ */ +#ifdef LDNS_RESOLV_RTT_INF + *iv_return = LDNS_RESOLV_RTT_INF; + return PERL_constant_ISIV; +#else + return PERL_constant_NOTDEF; +#endif + } + if (memEQ(name, "LDNS_RESOLV_RTT_MIN", 19)) { + /* ^ */ +#ifdef LDNS_RESOLV_RTT_MIN + *iv_return = LDNS_RESOLV_RTT_MIN; + return PERL_constant_ISIV; +#else + return PERL_constant_NOTDEF; +#endif + } + break; + case 'V': + if (memEQ(name, "LDNS_RCODE_SERVFAIL", 19)) { + /* ^ */ + *iv_return = LDNS_RCODE_SERVFAIL; + return PERL_constant_ISIV; + } + break; + case 'Y': + if (memEQ(name, "LDNS_RESOLV_KEYWORD", 19)) { + /* ^ */ +#ifdef LDNS_RESOLV_KEYWORD + *iv_return = LDNS_RESOLV_KEYWORD; + return PERL_constant_ISIV; +#else + return PERL_constant_NOTDEF; +#endif + } + break; + case '_': + if (memEQ(name, "LDNS_STATUS_NO_DATA", 19)) { + /* ^ */ + *iv_return = LDNS_STATUS_NO_DATA; + return PERL_constant_ISIV; + } + break; + } + return PERL_constant_NOTFOUND; +} + +static int +constant_20 (pTHX_ const char *name, IV *iv_return) { + /* When generated this function returned values for the list of names given + here. However, subsequent manual editing may have added or removed some. + LDNS_DNSSEC_KEYPROTO LDNS_PACKET_NXDOMAIN LDNS_PACKET_QUESTION + LDNS_PACKET_REFERRAL LDNS_RDF_SIZE_6BYTES LDNS_RDF_TYPE_PERIOD + LDNS_RESOLV_KEYWORDS LDNS_RESOLV_SORTLIST LDNS_SIGN_HMACSHA256 + LDNS_STATUS_FILE_ERR LDNS_STATUS_NOT_IMPL */ + /* Offset 18 gives the best switch position. */ + switch (name[18]) { + case '5': + if (memEQ(name, "LDNS_SIGN_HMACSHA256", 20)) { + /* ^ */ + *iv_return = LDNS_SIGN_HMACSHA256; + return PERL_constant_ISIV; + } + break; + case 'A': + if (memEQ(name, "LDNS_PACKET_REFERRAL", 20)) { + /* ^ */ + *iv_return = LDNS_PACKET_REFERRAL; + return PERL_constant_ISIV; + } + break; + case 'D': + if (memEQ(name, "LDNS_RESOLV_KEYWORDS", 20)) { + /* ^ */ +#ifdef LDNS_RESOLV_KEYWORDS + *iv_return = LDNS_RESOLV_KEYWORDS; + return PERL_constant_ISIV; +#else + return PERL_constant_NOTDEF; +#endif + } + break; + case 'E': + if (memEQ(name, "LDNS_RDF_SIZE_6BYTES", 20)) { + /* ^ */ +#ifdef LDNS_RDF_SIZE_6BYTES + *iv_return = LDNS_RDF_SIZE_6BYTES; + return PERL_constant_ISIV; +#else + return PERL_constant_NOTDEF; +#endif + } + break; + case 'I': + if (memEQ(name, "LDNS_PACKET_NXDOMAIN", 20)) { + /* ^ */ + *iv_return = LDNS_PACKET_NXDOMAIN; + return PERL_constant_ISIV; + } + break; + case 'O': + if (memEQ(name, "LDNS_PACKET_QUESTION", 20)) { + /* ^ */ + *iv_return = LDNS_PACKET_QUESTION; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RDF_TYPE_PERIOD", 20)) { + /* ^ */ + *iv_return = LDNS_RDF_TYPE_PERIOD; + return PERL_constant_ISIV; + } + break; + case 'P': + if (memEQ(name, "LDNS_STATUS_NOT_IMPL", 20)) { + /* ^ */ + *iv_return = LDNS_STATUS_NOT_IMPL; + return PERL_constant_ISIV; + } + break; + case 'R': + if (memEQ(name, "LDNS_STATUS_FILE_ERR", 20)) { + /* ^ */ + *iv_return = LDNS_STATUS_FILE_ERR; + return PERL_constant_ISIV; + } + break; + case 'S': + if (memEQ(name, "LDNS_RESOLV_SORTLIST", 20)) { + /* ^ */ +#ifdef LDNS_RESOLV_SORTLIST + *iv_return = LDNS_RESOLV_SORTLIST; + return PERL_constant_ISIV; +#else + return PERL_constant_NOTDEF; +#endif + } + break; + case 'T': + if (memEQ(name, "LDNS_DNSSEC_KEYPROTO", 20)) { + /* ^ */ +#ifdef LDNS_DNSSEC_KEYPROTO + *iv_return = LDNS_DNSSEC_KEYPROTO; + return PERL_constant_ISIV; +#else + return PERL_constant_NOTDEF; +#endif + } + break; + } + return PERL_constant_NOTFOUND; +} + +static int +constant_21 (pTHX_ const char *name, IV *iv_return) { + /* When generated this function returned values for the list of names given + here. However, subsequent manual editing may have added or removed some. + LDNS_DEFAULT_EXP_TIME LDNS_RDF_SIZE_16BYTES LDNS_RDF_TYPE_B32_EXT + LDNS_RDF_TYPE_SERVICE LDNS_RDF_TYPE_UNKNOWN LDNS_RESOLV_DEFDOMAIN + LDNS_RR_TYPE_IPSECKEY LDNS_RR_TYPE_NSAP_PTR LDNS_SECTION_QUESTION + LDNS_STATUS_NSEC3_ERR LDNS_STATUS_RES_NO_NS LDNS_STATUS_RES_QUERY */ + /* Offset 16 gives the best switch position. */ + switch (name[16]) { + case '2': + if (memEQ(name, "LDNS_RDF_TYPE_B32_EXT", 21)) { + /* ^ */ + *iv_return = LDNS_RDF_TYPE_B32_EXT; + return PERL_constant_ISIV; + } + break; + case '3': + if (memEQ(name, "LDNS_STATUS_NSEC3_ERR", 21)) { + /* ^ */ + *iv_return = LDNS_STATUS_NSEC3_ERR; + return PERL_constant_ISIV; + } + break; + case 'B': + if (memEQ(name, "LDNS_RDF_SIZE_16BYTES", 21)) { + /* ^ */ +#ifdef LDNS_RDF_SIZE_16BYTES + *iv_return = LDNS_RDF_SIZE_16BYTES; + return PERL_constant_ISIV; +#else + return PERL_constant_NOTDEF; +#endif + } + break; + case 'E': + if (memEQ(name, "LDNS_RR_TYPE_IPSECKEY", 21)) { + /* ^ */ + *iv_return = LDNS_RR_TYPE_IPSECKEY; + return PERL_constant_ISIV; + } + break; + case 'K': + if (memEQ(name, "LDNS_RDF_TYPE_UNKNOWN", 21)) { + /* ^ */ + *iv_return = LDNS_RDF_TYPE_UNKNOWN; + return PERL_constant_ISIV; + } + break; + case 'N': + if (memEQ(name, "LDNS_STATUS_RES_NO_NS", 21)) { + /* ^ */ + *iv_return = LDNS_STATUS_RES_NO_NS; + return PERL_constant_ISIV; + } + break; + case 'O': + if (memEQ(name, "LDNS_RESOLV_DEFDOMAIN", 21)) { + /* ^ */ +#ifdef LDNS_RESOLV_DEFDOMAIN + *iv_return = LDNS_RESOLV_DEFDOMAIN; + return PERL_constant_ISIV; +#else + return PERL_constant_NOTDEF; +#endif + } + break; + case 'P': + if (memEQ(name, "LDNS_RR_TYPE_NSAP_PTR", 21)) { + /* ^ */ + *iv_return = LDNS_RR_TYPE_NSAP_PTR; + return PERL_constant_ISIV; + } + break; + case 'Q': + if (memEQ(name, "LDNS_STATUS_RES_QUERY", 21)) { + /* ^ */ + *iv_return = LDNS_STATUS_RES_QUERY; + return PERL_constant_ISIV; + } + break; + case 'R': + if (memEQ(name, "LDNS_RDF_TYPE_SERVICE", 21)) { + /* ^ */ + *iv_return = LDNS_RDF_TYPE_SERVICE; + return PERL_constant_ISIV; + } + break; + case 'S': + if (memEQ(name, "LDNS_SECTION_QUESTION", 21)) { + /* ^ */ + *iv_return = LDNS_SECTION_QUESTION; + return PERL_constant_ISIV; + } + break; + case '_': + if (memEQ(name, "LDNS_DEFAULT_EXP_TIME", 21)) { + /* ^ */ +#ifdef LDNS_DEFAULT_EXP_TIME + *iv_return = LDNS_DEFAULT_EXP_TIME; + return PERL_constant_ISIV; +#else + return PERL_constant_NOTDEF; +#endif + } + break; + } + return PERL_constant_NOTFOUND; +} + +static int +constant_22 (pTHX_ const char *name, IV *iv_return) { + /* When generated this function returned values for the list of names given + here. However, subsequent manual editing may have added or removed some. + LDNS_RDF_TYPE_CERT_ALG LDNS_RDF_TYPE_IPSECKEY LDNS_RDF_TYPE_TSIGTIME + LDNS_RESOLV_NAMESERVER LDNS_SECTION_AUTHORITY LDNS_STATUS_SYNTAX_ERR + LDNS_STATUS_SYNTAX_TTL */ + /* Offset 14 gives the best switch position. */ + switch (name[14]) { + case 'C': + if (memEQ(name, "LDNS_RDF_TYPE_CERT_ALG", 22)) { + /* ^ */ + *iv_return = LDNS_RDF_TYPE_CERT_ALG; + return PERL_constant_ISIV; + } + break; + case 'I': + if (memEQ(name, "LDNS_RDF_TYPE_IPSECKEY", 22)) { + /* ^ */ + *iv_return = LDNS_RDF_TYPE_IPSECKEY; + return PERL_constant_ISIV; + } + break; + case 'M': + if (memEQ(name, "LDNS_RESOLV_NAMESERVER", 22)) { + /* ^ */ +#ifdef LDNS_RESOLV_NAMESERVER + *iv_return = LDNS_RESOLV_NAMESERVER; + return PERL_constant_ISIV; +#else + return PERL_constant_NOTDEF; +#endif + } + break; + case 'N': + if (memEQ(name, "LDNS_STATUS_SYNTAX_ERR", 22)) { + /* ^ */ + *iv_return = LDNS_STATUS_SYNTAX_ERR; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_STATUS_SYNTAX_TTL", 22)) { + /* ^ */ + *iv_return = LDNS_STATUS_SYNTAX_TTL; + return PERL_constant_ISIV; + } + break; + case 'T': + if (memEQ(name, "LDNS_RDF_TYPE_TSIGTIME", 22)) { + /* ^ */ + *iv_return = LDNS_RDF_TYPE_TSIGTIME; + return PERL_constant_ISIV; + } + break; + case 'U': + if (memEQ(name, "LDNS_SECTION_AUTHORITY", 22)) { + /* ^ */ + *iv_return = LDNS_SECTION_AUTHORITY; + return PERL_constant_ISIV; + } + break; + } + return PERL_constant_NOTFOUND; +} + +static int +constant_23 (pTHX_ const char *name, IV *iv_return) { + /* When generated this function returned values for the list of names given + here. However, subsequent manual editing may have added or removed some. + LDNS_RR_TYPE_NSEC3PARAM LDNS_SECTION_ADDITIONAL LDNS_SIGN_RSASHA1_NSEC3 + LDNS_STATUS_ADDRESS_ERR LDNS_STATUS_EMPTY_LABEL LDNS_STATUS_INVALID_B64 + LDNS_STATUS_INVALID_HEX LDNS_STATUS_INVALID_INT LDNS_STATUS_INVALID_IP4 + LDNS_STATUS_INVALID_IP6 LDNS_STATUS_INVALID_STR LDNS_STATUS_NETWORK_ERR */ + /* Offset 21 gives the best switch position. */ + switch (name[21]) { + case '6': + if (memEQ(name, "LDNS_STATUS_INVALID_B64", 23)) { + /* ^ */ + *iv_return = LDNS_STATUS_INVALID_B64; + return PERL_constant_ISIV; + } + break; + case 'A': + if (memEQ(name, "LDNS_RR_TYPE_NSEC3PARAM", 23)) { + /* ^ */ + *iv_return = LDNS_RR_TYPE_NSEC3PARAM; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_SECTION_ADDITIONAL", 23)) { + /* ^ */ + *iv_return = LDNS_SECTION_ADDITIONAL; + return PERL_constant_ISIV; + } + break; + case 'C': + if (memEQ(name, "LDNS_SIGN_RSASHA1_NSEC3", 23)) { + /* ^ */ + *iv_return = LDNS_SIGN_RSASHA1_NSEC3; + return PERL_constant_ISIV; + } + break; + case 'E': + if (memEQ(name, "LDNS_STATUS_EMPTY_LABEL", 23)) { + /* ^ */ + *iv_return = LDNS_STATUS_EMPTY_LABEL; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_STATUS_INVALID_HEX", 23)) { + /* ^ */ + *iv_return = LDNS_STATUS_INVALID_HEX; + return PERL_constant_ISIV; + } + break; + case 'N': + if (memEQ(name, "LDNS_STATUS_INVALID_INT", 23)) { + /* ^ */ + *iv_return = LDNS_STATUS_INVALID_INT; + return PERL_constant_ISIV; + } + break; + case 'P': + if (memEQ(name, "LDNS_STATUS_INVALID_IP4", 23)) { + /* ^ */ + *iv_return = LDNS_STATUS_INVALID_IP4; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_STATUS_INVALID_IP6", 23)) { + /* ^ */ + *iv_return = LDNS_STATUS_INVALID_IP6; + return PERL_constant_ISIV; + } + break; + case 'R': + if (memEQ(name, "LDNS_STATUS_ADDRESS_ERR", 23)) { + /* ^ */ + *iv_return = LDNS_STATUS_ADDRESS_ERR; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_STATUS_NETWORK_ERR", 23)) { + /* ^ */ + *iv_return = LDNS_STATUS_NETWORK_ERR; + return PERL_constant_ISIV; + } + break; + case 'T': + if (memEQ(name, "LDNS_STATUS_INVALID_STR", 23)) { + /* ^ */ + *iv_return = LDNS_STATUS_INVALID_STR; + return PERL_constant_ISIV; + } + break; + } + return PERL_constant_NOTFOUND; +} + +static int +constant_24 (pTHX_ const char *name, IV *iv_return) { + /* When generated this function returned values for the list of names given + here. However, subsequent manual editing may have added or removed some. + LDNS_RDF_SIZE_DOUBLEWORD LDNS_RDF_TYPE_INT16_DATA LDNS_RDF_TYPE_NSEC3_SALT + LDNS_RR_TYPE_NSEC3PARAMS LDNS_STATUS_CRYPTO_BOGUS LDNS_STATUS_CRYPTO_NO_DS + LDNS_STATUS_DDD_OVERFLOW LDNS_STATUS_INTERNAL_ERR LDNS_STATUS_INVALID_TIME + LDNS_STATUS_SOCKET_ERROR LDNS_STATUS_SYNTAX_EMPTY LDNS_STATUS_UNKNOWN_INET + */ + /* Offset 17 gives the best switch position. */ + switch (name[17]) { + case '1': + if (memEQ(name, "LDNS_RDF_TYPE_INT16_DATA", 24)) { + /* ^ */ + *iv_return = LDNS_RDF_TYPE_INT16_DATA; + return PERL_constant_ISIV; + } + break; + case '3': + if (memEQ(name, "LDNS_RR_TYPE_NSEC3PARAMS", 24)) { + /* ^ */ + *iv_return = LDNS_RR_TYPE_NSEC3PARAMS; + return PERL_constant_ISIV; + } + break; + case 'B': + if (memEQ(name, "LDNS_RDF_SIZE_DOUBLEWORD", 24)) { + /* ^ */ +#ifdef LDNS_RDF_SIZE_DOUBLEWORD + *iv_return = LDNS_RDF_SIZE_DOUBLEWORD; + return PERL_constant_ISIV; +#else + return PERL_constant_NOTDEF; +#endif + } + break; + case 'C': + if (memEQ(name, "LDNS_RDF_TYPE_NSEC3_SALT", 24)) { + /* ^ */ + *iv_return = LDNS_RDF_TYPE_NSEC3_SALT; + return PERL_constant_ISIV; + } + break; + case 'I': + if (memEQ(name, "LDNS_STATUS_INVALID_TIME", 24)) { + /* ^ */ + *iv_return = LDNS_STATUS_INVALID_TIME; + return PERL_constant_ISIV; + } + break; + case 'N': + if (memEQ(name, "LDNS_STATUS_INTERNAL_ERR", 24)) { + /* ^ */ + *iv_return = LDNS_STATUS_INTERNAL_ERR; + return PERL_constant_ISIV; + } + break; + case 'O': + if (memEQ(name, "LDNS_STATUS_CRYPTO_BOGUS", 24)) { + /* ^ */ + *iv_return = LDNS_STATUS_CRYPTO_BOGUS; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_STATUS_CRYPTO_NO_DS", 24)) { + /* ^ */ + *iv_return = LDNS_STATUS_CRYPTO_NO_DS; + return PERL_constant_ISIV; + } + break; + case 'T': + if (memEQ(name, "LDNS_STATUS_SOCKET_ERROR", 24)) { + /* ^ */ + *iv_return = LDNS_STATUS_SOCKET_ERROR; + return PERL_constant_ISIV; + } + break; + case 'V': + if (memEQ(name, "LDNS_STATUS_DDD_OVERFLOW", 24)) { + /* ^ */ + *iv_return = LDNS_STATUS_DDD_OVERFLOW; + return PERL_constant_ISIV; + } + break; + case 'W': + if (memEQ(name, "LDNS_STATUS_UNKNOWN_INET", 24)) { + /* ^ */ + *iv_return = LDNS_STATUS_UNKNOWN_INET; + return PERL_constant_ISIV; + } + break; + case 'X': + if (memEQ(name, "LDNS_STATUS_SYNTAX_EMPTY", 24)) { + /* ^ */ + *iv_return = LDNS_STATUS_SYNTAX_EMPTY; + return PERL_constant_ISIV; + } + break; + } + return PERL_constant_NOTFOUND; +} + +static int +constant_26 (pTHX_ const char *name, IV *iv_return) { + /* When generated this function returned values for the list of names given + here. However, subsequent manual editing may have added or removed some. + LDNS_STATUS_LABEL_OVERFLOW LDNS_STATUS_SYNTAX_ALG_ERR + LDNS_STATUS_SYNTAX_INCLUDE LDNS_STATUS_SYNTAX_TTL_ERR */ + /* Offset 20 gives the best switch position. */ + switch (name[20]) { + case 'E': + if (memEQ(name, "LDNS_STATUS_LABEL_OVERFLOW", 26)) { + /* ^ */ + *iv_return = LDNS_STATUS_LABEL_OVERFLOW; + return PERL_constant_ISIV; + } + break; + case 'L': + if (memEQ(name, "LDNS_STATUS_SYNTAX_ALG_ERR", 26)) { + /* ^ */ + *iv_return = LDNS_STATUS_SYNTAX_ALG_ERR; + return PERL_constant_ISIV; + } + break; + case 'N': + if (memEQ(name, "LDNS_STATUS_SYNTAX_INCLUDE", 26)) { + /* ^ */ + *iv_return = LDNS_STATUS_SYNTAX_INCLUDE; + return PERL_constant_ISIV; + } + break; + case 'T': + if (memEQ(name, "LDNS_STATUS_SYNTAX_TTL_ERR", 26)) { + /* ^ */ + *iv_return = LDNS_STATUS_SYNTAX_TTL_ERR; + return PERL_constant_ISIV; + } + break; + } + return PERL_constant_NOTFOUND; +} + +static int +constant_27 (pTHX_ const char *name, IV *iv_return) { + /* When generated this function returned values for the list of names given + here. However, subsequent manual editing may have added or removed some. + LDNS_NSEC3_VARS_OPTOUT_MASK LDNS_SECTION_ANY_NOQUESTION + LDNS_SIGNATURE_LEAVE_NO_ADD LDNS_STATUS_CRYPTO_NO_RRSIG + LDNS_STATUS_CRYPTO_TSIG_ERR LDNS_STATUS_INVALID_B32_EXT + LDNS_STATUS_INVALID_POINTER LDNS_STATUS_PACKET_OVERFLOW + LDNS_STATUS_SYNTAX_TYPE_ERR */ + /* Offset 20 gives the best switch position. */ + switch (name[20]) { + case 'B': + if (memEQ(name, "LDNS_STATUS_INVALID_B32_EXT", 27)) { + /* ^ */ + *iv_return = LDNS_STATUS_INVALID_B32_EXT; + return PERL_constant_ISIV; + } + break; + case 'O': + if (memEQ(name, "LDNS_STATUS_CRYPTO_NO_RRSIG", 27)) { + /* ^ */ + *iv_return = LDNS_STATUS_CRYPTO_NO_RRSIG; + return PERL_constant_ISIV; + } + break; + case 'P': + if (memEQ(name, "LDNS_STATUS_INVALID_POINTER", 27)) { + /* ^ */ + *iv_return = LDNS_STATUS_INVALID_POINTER; + return PERL_constant_ISIV; + } + break; + case 'S': + if (memEQ(name, "LDNS_STATUS_CRYPTO_TSIG_ERR", 27)) { + /* ^ */ + *iv_return = LDNS_STATUS_CRYPTO_TSIG_ERR; + return PERL_constant_ISIV; + } + break; + case 'U': + if (memEQ(name, "LDNS_NSEC3_VARS_OPTOUT_MASK", 27)) { + /* ^ */ +#ifdef LDNS_NSEC3_VARS_OPTOUT_MASK + *iv_return = LDNS_NSEC3_VARS_OPTOUT_MASK; + return PERL_constant_ISIV; +#else + return PERL_constant_NOTDEF; +#endif + } + if (memEQ(name, "LDNS_SECTION_ANY_NOQUESTION", 27)) { + /* ^ */ + *iv_return = LDNS_SECTION_ANY_NOQUESTION; + return PERL_constant_ISIV; + } + break; + case 'V': + if (memEQ(name, "LDNS_STATUS_PACKET_OVERFLOW", 27)) { + /* ^ */ + *iv_return = LDNS_STATUS_PACKET_OVERFLOW; + return PERL_constant_ISIV; + } + break; + case 'Y': + if (memEQ(name, "LDNS_STATUS_SYNTAX_TYPE_ERR", 27)) { + /* ^ */ + *iv_return = LDNS_STATUS_SYNTAX_TYPE_ERR; + return PERL_constant_ISIV; + } + break; + case '_': + if (memEQ(name, "LDNS_SIGNATURE_LEAVE_NO_ADD", 27)) { + /* ^ */ +#ifdef LDNS_SIGNATURE_LEAVE_NO_ADD + *iv_return = LDNS_SIGNATURE_LEAVE_NO_ADD; + return PERL_constant_ISIV; +#else + return PERL_constant_NOTDEF; +#endif + } + break; + } + return PERL_constant_NOTFOUND; +} + +static int +constant_28 (pTHX_ const char *name, IV *iv_return) { + /* When generated this function returned values for the list of names given + here. However, subsequent manual editing may have added or removed some. + LDNS_SIGNATURE_LEAVE_ADD_NEW LDNS_SIGNATURE_REMOVE_NO_ADD + LDNS_STATUS_CRYPTO_NO_DNSKEY LDNS_STATUS_CRYPTO_VALIDATED + LDNS_STATUS_SYNTAX_CLASS_ERR LDNS_STATUS_SYNTAX_DNAME_ERR + LDNS_STATUS_SYNTAX_RDATA_ERR */ + /* Offset 20 gives the best switch position. */ + switch (name[20]) { + case 'A': + if (memEQ(name, "LDNS_STATUS_CRYPTO_VALIDATED", 28)) { + /* ^ */ + *iv_return = LDNS_STATUS_CRYPTO_VALIDATED; + return PERL_constant_ISIV; + } + break; + case 'D': + if (memEQ(name, "LDNS_STATUS_SYNTAX_RDATA_ERR", 28)) { + /* ^ */ + *iv_return = LDNS_STATUS_SYNTAX_RDATA_ERR; + return PERL_constant_ISIV; + } + break; + case 'E': + if (memEQ(name, "LDNS_SIGNATURE_REMOVE_NO_ADD", 28)) { + /* ^ */ +#ifdef LDNS_SIGNATURE_REMOVE_NO_ADD + *iv_return = LDNS_SIGNATURE_REMOVE_NO_ADD; + return PERL_constant_ISIV; +#else + return PERL_constant_NOTDEF; +#endif + } + break; + case 'L': + if (memEQ(name, "LDNS_STATUS_SYNTAX_CLASS_ERR", 28)) { + /* ^ */ + *iv_return = LDNS_STATUS_SYNTAX_CLASS_ERR; + return PERL_constant_ISIV; + } + break; + case 'N': + if (memEQ(name, "LDNS_STATUS_SYNTAX_DNAME_ERR", 28)) { + /* ^ */ + *iv_return = LDNS_STATUS_SYNTAX_DNAME_ERR; + return PERL_constant_ISIV; + } + break; + case 'O': + if (memEQ(name, "LDNS_STATUS_CRYPTO_NO_DNSKEY", 28)) { + /* ^ */ + *iv_return = LDNS_STATUS_CRYPTO_NO_DNSKEY; + return PERL_constant_ISIV; + } + break; + case '_': + if (memEQ(name, "LDNS_SIGNATURE_LEAVE_ADD_NEW", 28)) { + /* ^ */ +#ifdef LDNS_SIGNATURE_LEAVE_ADD_NEW + *iv_return = LDNS_SIGNATURE_LEAVE_ADD_NEW; + return PERL_constant_ISIV; +#else + return PERL_constant_NOTDEF; +#endif + } + break; + } + return PERL_constant_NOTFOUND; +} + +static int +constant_29 (pTHX_ const char *name, IV *iv_return) { + /* When generated this function returned values for the list of names given + here. However, subsequent manual editing may have added or removed some. + LDNS_SIGNATURE_REMOVE_ADD_NEW LDNS_STATUS_CRYPTO_TSIG_BOGUS + LDNS_STATUS_SYNTAX_BAD_ESCAPE */ + /* Offset 15 gives the best switch position. */ + switch (name[15]) { + case 'P': + if (memEQ(name, "LDNS_STATUS_CRYPTO_TSIG_BOGUS", 29)) { + /* ^ */ + *iv_return = LDNS_STATUS_CRYPTO_TSIG_BOGUS; + return PERL_constant_ISIV; + } + break; + case 'R': + if (memEQ(name, "LDNS_SIGNATURE_REMOVE_ADD_NEW", 29)) { + /* ^ */ +#ifdef LDNS_SIGNATURE_REMOVE_ADD_NEW + *iv_return = LDNS_SIGNATURE_REMOVE_ADD_NEW; + return PERL_constant_ISIV; +#else + return PERL_constant_NOTDEF; +#endif + } + break; + case 'T': + if (memEQ(name, "LDNS_STATUS_SYNTAX_BAD_ESCAPE", 29)) { + /* ^ */ + *iv_return = LDNS_STATUS_SYNTAX_BAD_ESCAPE; + return PERL_constant_ISIV; + } + break; + } + return PERL_constant_NOTFOUND; +} + +static int +constant_30 (pTHX_ const char *name, IV *iv_return) { + /* When generated this function returned values for the list of names given + here. However, subsequent manual editing may have added or removed some. + LDNS_RDF_TYPE_NSEC3_NEXT_OWNER LDNS_STATUS_CERT_BAD_ALGORITHM + LDNS_STATUS_CRYPTO_SIG_EXPIRED LDNS_STATUS_SYNTAX_KEYWORD_ERR + LDNS_STATUS_SYNTAX_VERSION_ERR */ + /* Offset 25 gives the best switch position. */ + switch (name[25]) { + case 'D': + if (memEQ(name, "LDNS_STATUS_SYNTAX_KEYWORD_ERR", 30)) { + /* ^ */ + *iv_return = LDNS_STATUS_SYNTAX_KEYWORD_ERR; + return PERL_constant_ISIV; + } + break; + case 'N': + if (memEQ(name, "LDNS_STATUS_SYNTAX_VERSION_ERR", 30)) { + /* ^ */ + *iv_return = LDNS_STATUS_SYNTAX_VERSION_ERR; + return PERL_constant_ISIV; + } + break; + case 'O': + if (memEQ(name, "LDNS_RDF_TYPE_NSEC3_NEXT_OWNER", 30)) { + /* ^ */ + *iv_return = LDNS_RDF_TYPE_NSEC3_NEXT_OWNER; + return PERL_constant_ISIV; + } + break; + case 'P': + if (memEQ(name, "LDNS_STATUS_CRYPTO_SIG_EXPIRED", 30)) { + /* ^ */ + *iv_return = LDNS_STATUS_CRYPTO_SIG_EXPIRED; + return PERL_constant_ISIV; + } + break; + case 'R': + if (memEQ(name, "LDNS_STATUS_CERT_BAD_ALGORITHM", 30)) { + /* ^ */ + *iv_return = LDNS_STATUS_CERT_BAD_ALGORITHM; + return PERL_constant_ISIV; + } + break; + } + return PERL_constant_NOTFOUND; +} + +static int +constant_32 (pTHX_ const char *name, IV *iv_return) { + /* When generated this function returned values for the list of names given + here. However, subsequent manual editing may have added or removed some. + LDNS_STATUS_CRYPTO_ALGO_NOT_IMPL LDNS_STATUS_CRYPTO_NO_TRUSTED_DS + LDNS_STATUS_DOMAINNAME_UNDERFLOW */ + /* Offset 20 gives the best switch position. */ + switch (name[20]) { + case 'L': + if (memEQ(name, "LDNS_STATUS_CRYPTO_ALGO_NOT_IMPL", 32)) { + /* ^ */ + *iv_return = LDNS_STATUS_CRYPTO_ALGO_NOT_IMPL; + return PERL_constant_ISIV; + } + break; + case 'M': + if (memEQ(name, "LDNS_STATUS_DOMAINNAME_UNDERFLOW", 32)) { + /* ^ */ + *iv_return = LDNS_STATUS_DOMAINNAME_UNDERFLOW; + return PERL_constant_ISIV; + } + break; + case 'O': + if (memEQ(name, "LDNS_STATUS_CRYPTO_NO_TRUSTED_DS", 32)) { + /* ^ */ + *iv_return = LDNS_STATUS_CRYPTO_NO_TRUSTED_DS; + return PERL_constant_ISIV; + } + break; + } + return PERL_constant_NOTFOUND; +} + +static int +constant_35 (pTHX_ const char *name, IV *iv_return) { + /* When generated this function returned values for the list of names given + here. However, subsequent manual editing may have added or removed some. + LDNS_RDATA_FIELD_DESCRIPTORS_COMMON LDNS_STATUS_CRYPTO_SIG_NOT_INCEPTED + LDNS_STATUS_CRYPTO_TYPE_COVERED_ERR LDNS_STATUS_DNSSEC_EXISTENCE_DENIED + LDNS_STATUS_SYNTAX_INTEGER_OVERFLOW */ + /* Offset 21 gives the best switch position. */ + switch (name[21]) { + case 'G': + if (memEQ(name, "LDNS_STATUS_CRYPTO_SIG_NOT_INCEPTED", 35)) { + /* ^ */ + *iv_return = LDNS_STATUS_CRYPTO_SIG_NOT_INCEPTED; + return PERL_constant_ISIV; + } + break; + case 'I': + if (memEQ(name, "LDNS_STATUS_DNSSEC_EXISTENCE_DENIED", 35)) { + /* ^ */ + *iv_return = LDNS_STATUS_DNSSEC_EXISTENCE_DENIED; + return PERL_constant_ISIV; + } + break; + case 'P': + if (memEQ(name, "LDNS_STATUS_CRYPTO_TYPE_COVERED_ERR", 35)) { + /* ^ */ + *iv_return = LDNS_STATUS_CRYPTO_TYPE_COVERED_ERR; + return PERL_constant_ISIV; + } + break; + case 'R': + if (memEQ(name, "LDNS_RDATA_FIELD_DESCRIPTORS_COMMON", 35)) { + /* ^ */ +#ifdef LDNS_RDATA_FIELD_DESCRIPTORS_COMMON + *iv_return = LDNS_RDATA_FIELD_DESCRIPTORS_COMMON; + return PERL_constant_ISIV; +#else + return PERL_constant_NOTDEF; +#endif + } + break; + case 'T': + if (memEQ(name, "LDNS_STATUS_SYNTAX_INTEGER_OVERFLOW", 35)) { + /* ^ */ + *iv_return = LDNS_STATUS_SYNTAX_INTEGER_OVERFLOW; + return PERL_constant_ISIV; + } + break; + } + return PERL_constant_NOTFOUND; +} + +static int +constant_36 (pTHX_ const char *name, IV *iv_return) { + /* When generated this function returned values for the list of names given + here. However, subsequent manual editing may have added or removed some. + LDNS_STATUS_CRYPTO_NO_TRUSTED_DNSKEY LDNS_STATUS_MISSING_RDATA_FIELDS_KEY + LDNS_STATUS_SYNTAX_MISSING_VALUE_ERR LDNS_STATUS_WIRE_INCOMPLETE_QUESTION + */ + /* Offset 14 gives the best switch position. */ + switch (name[14]) { + case 'N': + if (memEQ(name, "LDNS_STATUS_SYNTAX_MISSING_VALUE_ERR", 36)) { + /* ^ */ + *iv_return = LDNS_STATUS_SYNTAX_MISSING_VALUE_ERR; + return PERL_constant_ISIV; + } + break; + case 'R': + if (memEQ(name, "LDNS_STATUS_WIRE_INCOMPLETE_QUESTION", 36)) { + /* ^ */ + *iv_return = LDNS_STATUS_WIRE_INCOMPLETE_QUESTION; + return PERL_constant_ISIV; + } + break; + case 'S': + if (memEQ(name, "LDNS_STATUS_MISSING_RDATA_FIELDS_KEY", 36)) { + /* ^ */ + *iv_return = LDNS_STATUS_MISSING_RDATA_FIELDS_KEY; + return PERL_constant_ISIV; + } + break; + case 'Y': + if (memEQ(name, "LDNS_STATUS_CRYPTO_NO_TRUSTED_DNSKEY", 36)) { + /* ^ */ + *iv_return = LDNS_STATUS_CRYPTO_NO_TRUSTED_DNSKEY; + return PERL_constant_ISIV; + } + break; + } + return PERL_constant_NOTFOUND; +} + +static int +constant_38 (pTHX_ const char *name, IV *iv_return) { + /* When generated this function returned values for the list of names given + here. However, subsequent manual editing may have added or removed some. + LDNS_STATUS_DNSSEC_NSEC_RR_NOT_COVERED + LDNS_STATUS_MISSING_RDATA_FIELDS_RRSIG + LDNS_STATUS_SYNTAX_INCLUDE_ERR_NOTIMPL + LDNS_STATUS_SYNTAX_ITERATIONS_OVERFLOW + LDNS_STATUS_WIRE_INCOMPLETE_ADDITIONAL */ + /* Offset 20 gives the best switch position. */ + switch (name[20]) { + case 'N': + if (memEQ(name, "LDNS_STATUS_SYNTAX_INCLUDE_ERR_NOTIMPL", 38)) { + /* ^ */ + *iv_return = LDNS_STATUS_SYNTAX_INCLUDE_ERR_NOTIMPL; + return PERL_constant_ISIV; + } + break; + case 'O': + if (memEQ(name, "LDNS_STATUS_WIRE_INCOMPLETE_ADDITIONAL", 38)) { + /* ^ */ + *iv_return = LDNS_STATUS_WIRE_INCOMPLETE_ADDITIONAL; + return PERL_constant_ISIV; + } + break; + case 'R': + if (memEQ(name, "LDNS_STATUS_MISSING_RDATA_FIELDS_RRSIG", 38)) { + /* ^ */ + *iv_return = LDNS_STATUS_MISSING_RDATA_FIELDS_RRSIG; + return PERL_constant_ISIV; + } + break; + case 'S': + if (memEQ(name, "LDNS_STATUS_DNSSEC_NSEC_RR_NOT_COVERED", 38)) { + /* ^ */ + *iv_return = LDNS_STATUS_DNSSEC_NSEC_RR_NOT_COVERED; + return PERL_constant_ISIV; + } + break; + case 'T': + if (memEQ(name, "LDNS_STATUS_SYNTAX_ITERATIONS_OVERFLOW", 38)) { + /* ^ */ + *iv_return = LDNS_STATUS_SYNTAX_ITERATIONS_OVERFLOW; + return PERL_constant_ISIV; + } + break; + } + return PERL_constant_NOTFOUND; +} + +static int +constant (pTHX_ const char *name, STRLEN len, IV *iv_return) { + /* Initially switch on the length of the name. */ + /* When generated this function returned values for the list of names given + in this section of perl code. Rather than manually editing these functions + to add or remove constants, which would result in this comment and section + of code becoming inaccurate, we recommend that you edit this section of + code, and use it to regenerate a new set of constant functions which you + then use to replace the originals. + + Regenerate these constant functions by feeding this entire source file to + perl -x + +#!/usr/bin/perl -w +use ExtUtils::Constant qw (constant_types C_constant XS_constant); + +my $types = {map {($_, 1)} qw(IV)}; +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", type=>"IV", macro=>"1"}, + {name=>"LDNS_CERT_IACPKIX", type=>"IV", macro=>"1"}, + {name=>"LDNS_CERT_IPGP", type=>"IV", macro=>"1"}, + {name=>"LDNS_CERT_IPKIX", type=>"IV", macro=>"1"}, + {name=>"LDNS_CERT_ISPKI", type=>"IV", macro=>"1"}, + {name=>"LDNS_CERT_OID", type=>"IV", macro=>"1"}, + {name=>"LDNS_CERT_PGP", type=>"IV", macro=>"1"}, + {name=>"LDNS_CERT_PKIX", type=>"IV", macro=>"1"}, + {name=>"LDNS_CERT_SPKI", type=>"IV", macro=>"1"}, + {name=>"LDNS_CERT_URI", type=>"IV", macro=>"1"}, + {name=>"LDNS_DH", type=>"IV", macro=>"1"}, + {name=>"LDNS_DSA", type=>"IV", macro=>"1"}, + {name=>"LDNS_DSA_NSEC3", type=>"IV", macro=>"1"}, + {name=>"LDNS_ECC", type=>"IV", macro=>"1"}, + {name=>"LDNS_ECC_GOST", type=>"IV", macro=>"1"}, + {name=>"LDNS_HASH_GOST", type=>"IV", macro=>"1"}, + {name=>"LDNS_PACKET_ANSWER", type=>"IV", macro=>"1"}, + {name=>"LDNS_PACKET_IQUERY", type=>"IV", macro=>"1"}, + {name=>"LDNS_PACKET_NODATA", type=>"IV", macro=>"1"}, + {name=>"LDNS_PACKET_NOTIFY", type=>"IV", macro=>"1"}, + {name=>"LDNS_PACKET_NXDOMAIN", type=>"IV", macro=>"1"}, + {name=>"LDNS_PACKET_QUERY", type=>"IV", macro=>"1"}, + {name=>"LDNS_PACKET_QUESTION", type=>"IV", macro=>"1"}, + {name=>"LDNS_PACKET_REFERRAL", type=>"IV", macro=>"1"}, + {name=>"LDNS_PACKET_STATUS", type=>"IV", macro=>"1"}, + {name=>"LDNS_PACKET_UNKNOWN", type=>"IV", macro=>"1"}, + {name=>"LDNS_PACKET_UPDATE", type=>"IV", macro=>"1"}, + {name=>"LDNS_PRIVATEDNS", type=>"IV", macro=>"1"}, + {name=>"LDNS_PRIVATEOID", type=>"IV", macro=>"1"}, + {name=>"LDNS_RCODE_FORMERR", type=>"IV", macro=>"1"}, + {name=>"LDNS_RCODE_NOERROR", type=>"IV", macro=>"1"}, + {name=>"LDNS_RCODE_NOTAUTH", type=>"IV", macro=>"1"}, + {name=>"LDNS_RCODE_NOTIMPL", type=>"IV", macro=>"1"}, + {name=>"LDNS_RCODE_NOTZONE", type=>"IV", macro=>"1"}, + {name=>"LDNS_RCODE_NXDOMAIN", type=>"IV", macro=>"1"}, + {name=>"LDNS_RCODE_NXRRSET", type=>"IV", macro=>"1"}, + {name=>"LDNS_RCODE_REFUSED", type=>"IV", macro=>"1"}, + {name=>"LDNS_RCODE_SERVFAIL", type=>"IV", macro=>"1"}, + {name=>"LDNS_RCODE_YXDOMAIN", type=>"IV", macro=>"1"}, + {name=>"LDNS_RCODE_YXRRSET", type=>"IV", macro=>"1"}, + {name=>"LDNS_RDF_TYPE_A", type=>"IV", macro=>"1"}, + {name=>"LDNS_RDF_TYPE_AAAA", type=>"IV", macro=>"1"}, + {name=>"LDNS_RDF_TYPE_ALG", type=>"IV", macro=>"1"}, + {name=>"LDNS_RDF_TYPE_APL", type=>"IV", macro=>"1"}, + {name=>"LDNS_RDF_TYPE_ATMA", type=>"IV", macro=>"1"}, + {name=>"LDNS_RDF_TYPE_B32_EXT", type=>"IV", macro=>"1"}, + {name=>"LDNS_RDF_TYPE_B64", type=>"IV", macro=>"1"}, + {name=>"LDNS_RDF_TYPE_CERT_ALG", type=>"IV", macro=>"1"}, + {name=>"LDNS_RDF_TYPE_CLASS", type=>"IV", macro=>"1"}, + {name=>"LDNS_RDF_TYPE_DNAME", type=>"IV", macro=>"1"}, + {name=>"LDNS_RDF_TYPE_HEX", type=>"IV", macro=>"1"}, + {name=>"LDNS_RDF_TYPE_HIP", type=>"IV", macro=>"1"}, + {name=>"LDNS_RDF_TYPE_INT16", type=>"IV", macro=>"1"}, + {name=>"LDNS_RDF_TYPE_INT16_DATA", type=>"IV", macro=>"1"}, + {name=>"LDNS_RDF_TYPE_INT32", type=>"IV", macro=>"1"}, + {name=>"LDNS_RDF_TYPE_INT8", type=>"IV", macro=>"1"}, + {name=>"LDNS_RDF_TYPE_IPSECKEY", type=>"IV", macro=>"1"}, + {name=>"LDNS_RDF_TYPE_LOC", type=>"IV", macro=>"1"}, + {name=>"LDNS_RDF_TYPE_NONE", type=>"IV", macro=>"1"}, + {name=>"LDNS_RDF_TYPE_NSAP", type=>"IV", macro=>"1"}, + {name=>"LDNS_RDF_TYPE_NSEC", type=>"IV", macro=>"1"}, + {name=>"LDNS_RDF_TYPE_NSEC3_NEXT_OWNER", type=>"IV", macro=>"1"}, + {name=>"LDNS_RDF_TYPE_NSEC3_SALT", type=>"IV", macro=>"1"}, + {name=>"LDNS_RDF_TYPE_PERIOD", type=>"IV", macro=>"1"}, + {name=>"LDNS_RDF_TYPE_SERVICE", type=>"IV", macro=>"1"}, + {name=>"LDNS_RDF_TYPE_STR", type=>"IV", macro=>"1"}, + {name=>"LDNS_RDF_TYPE_TIME", type=>"IV", macro=>"1"}, + {name=>"LDNS_RDF_TYPE_TSIGTIME", type=>"IV", macro=>"1"}, + {name=>"LDNS_RDF_TYPE_TYPE", type=>"IV", macro=>"1"}, + {name=>"LDNS_RDF_TYPE_UNKNOWN", type=>"IV", macro=>"1"}, + {name=>"LDNS_RDF_TYPE_WKS", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_CLASS_ANY", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_CLASS_CH", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_CLASS_COUNT", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_CLASS_FIRST", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_CLASS_HS", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_CLASS_IN", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_CLASS_LAST", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_CLASS_NONE", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_COMPRESS", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_NO_COMPRESS", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_A", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_A6", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_AAAA", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_AFSDB", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_ANY", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_APL", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_ATMA", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_AXFR", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_CERT", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_CNAME", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_COUNT", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_DHCID", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_DLV", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_DNAME", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_DNSKEY", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_DS", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_EID", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_FIRST", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_GID", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_GPOS", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_HINFO", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_IPSECKEY", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_ISDN", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_IXFR", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_KEY", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_KX", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_LAST", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_LOC", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_MAILA", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_MAILB", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_MB", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_MD", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_MF", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_MG", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_MINFO", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_MR", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_MX", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_NAPTR", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_NIMLOC", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_NS", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_NSAP", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_NSAP_PTR", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_NSEC", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_NSEC3", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_NSEC3PARAM", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_NSEC3PARAMS", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_NULL", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_NXT", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_OPT", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_PTR", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_PX", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_RP", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_RRSIG", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_RT", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_SIG", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_SINK", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_SOA", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_SPF", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_SRV", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_SSHFP", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_TALINK", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_TSIG", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_TXT", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_UID", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_UINFO", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_UNSPEC", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_WKS", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_X25", type=>"IV", macro=>"1"}, + {name=>"LDNS_RSAMD5", type=>"IV", macro=>"1"}, + {name=>"LDNS_RSASHA1", type=>"IV", macro=>"1"}, + {name=>"LDNS_RSASHA1_NSEC3", type=>"IV", macro=>"1"}, + {name=>"LDNS_RSASHA256", type=>"IV", macro=>"1"}, + {name=>"LDNS_RSASHA512", type=>"IV", macro=>"1"}, + {name=>"LDNS_SECTION_ADDITIONAL", type=>"IV", macro=>"1"}, + {name=>"LDNS_SECTION_ANSWER", type=>"IV", macro=>"1"}, + {name=>"LDNS_SECTION_ANY", type=>"IV", macro=>"1"}, + {name=>"LDNS_SECTION_ANY_NOQUESTION", type=>"IV", macro=>"1"}, + {name=>"LDNS_SECTION_AUTHORITY", type=>"IV", macro=>"1"}, + {name=>"LDNS_SECTION_QUESTION", type=>"IV", macro=>"1"}, + {name=>"LDNS_SHA1", type=>"IV", macro=>"1"}, + {name=>"LDNS_SHA256", type=>"IV", macro=>"1"}, + {name=>"LDNS_SIGN_DSA", type=>"IV", macro=>"1"}, + {name=>"LDNS_SIGN_DSA_NSEC3", type=>"IV", macro=>"1"}, + {name=>"LDNS_SIGN_ECC_GOST", type=>"IV", macro=>"1"}, + {name=>"LDNS_SIGN_HMACSHA1", type=>"IV", macro=>"1"}, + {name=>"LDNS_SIGN_HMACSHA256", type=>"IV", macro=>"1"}, + {name=>"LDNS_SIGN_RSAMD5", type=>"IV", macro=>"1"}, + {name=>"LDNS_SIGN_RSASHA1", type=>"IV", macro=>"1"}, + {name=>"LDNS_SIGN_RSASHA1_NSEC3", type=>"IV", macro=>"1"}, + {name=>"LDNS_SIGN_RSASHA256", type=>"IV", macro=>"1"}, + {name=>"LDNS_SIGN_RSASHA512", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_ADDRESS_ERR", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_CERT_BAD_ALGORITHM", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_CRYPTO_ALGO_NOT_IMPL", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_CRYPTO_BOGUS", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_CRYPTO_EXPIRATION_BEFORE_INCEPTION", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_CRYPTO_NO_DNSKEY", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_CRYPTO_NO_DS", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_CRYPTO_NO_MATCHING_KEYTAG_DNSKEY", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_CRYPTO_NO_RRSIG", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_CRYPTO_NO_TRUSTED_DNSKEY", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_CRYPTO_NO_TRUSTED_DS", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_CRYPTO_SIG_EXPIRED", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_CRYPTO_SIG_NOT_INCEPTED", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_CRYPTO_TSIG_BOGUS", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_CRYPTO_TSIG_ERR", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_CRYPTO_TYPE_COVERED_ERR", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_CRYPTO_UNKNOWN_ALGO", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_CRYPTO_VALIDATED", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_DDD_OVERFLOW", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_DNSSEC_EXISTENCE_DENIED", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_DNSSEC_NSEC3_ORIGINAL_NOT_FOUND", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_DNSSEC_NSEC_RR_NOT_COVERED", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_DNSSEC_NSEC_WILDCARD_NOT_COVERED", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_DOMAINNAME_OVERFLOW", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_DOMAINNAME_UNDERFLOW", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_EMPTY_LABEL", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_ENGINE_KEY_NOT_LOADED", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_ERR", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_FILE_ERR", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_INTERNAL_ERR", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_INVALID_B32_EXT", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_INVALID_B64", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_INVALID_HEX", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_INVALID_INT", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_INVALID_IP4", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_INVALID_IP6", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_INVALID_POINTER", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_INVALID_STR", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_INVALID_TIME", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_LABEL_OVERFLOW", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_MEM_ERR", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_MISSING_RDATA_FIELDS_KEY", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_MISSING_RDATA_FIELDS_RRSIG", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_NETWORK_ERR", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_NOT_IMPL", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_NO_DATA", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_NSEC3_ERR", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_NULL", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_OK", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_PACKET_OVERFLOW", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_RES_NO_NS", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_RES_QUERY", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_SOCKET_ERROR", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_SSL_ERR", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_SYNTAX_ALG_ERR", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_SYNTAX_BAD_ESCAPE", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_SYNTAX_CLASS_ERR", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_SYNTAX_DNAME_ERR", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_SYNTAX_EMPTY", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_SYNTAX_ERR", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_SYNTAX_INCLUDE", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_SYNTAX_INCLUDE_ERR_NOTIMPL", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_SYNTAX_INTEGER_OVERFLOW", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_SYNTAX_ITERATIONS_OVERFLOW", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_SYNTAX_KEYWORD_ERR", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_SYNTAX_MISSING_VALUE_ERR", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_SYNTAX_ORIGIN", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_SYNTAX_RDATA_ERR", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_SYNTAX_TTL", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_SYNTAX_TTL_ERR", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_SYNTAX_TYPE_ERR", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_SYNTAX_VERSION_ERR", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_UNKNOWN_INET", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_WIRE_INCOMPLETE_ADDITIONAL", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_WIRE_INCOMPLETE_ANSWER", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_WIRE_INCOMPLETE_AUTHORITY", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_WIRE_INCOMPLETE_HEADER", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_WIRE_INCOMPLETE_QUESTION", type=>"IV", macro=>"1"}); + +print constant_types(), "\n"; # macro defs +foreach (C_constant ("LDNS", 'constant', 'IV', $types, undef, 3, @names) ) { + print $_, "\n"; # C constant subs +} +print "\n#### XS Section:\n"; +print XS_constant ("LDNS", $types); +__END__ + */ + + switch (len) { + case 7: + return constant_7 (aTHX_ name, iv_return); + break; + case 8: + /* Names all of length 8. */ + /* LDNS_DSA LDNS_ECC */ + /* Offset 5 gives the best switch position. */ + switch (name[5]) { + case 'D': + if (memEQ(name, "LDNS_DSA", 8)) { + /* ^ */ + *iv_return = LDNS_DSA; + return PERL_constant_ISIV; + } + break; + case 'E': + if (memEQ(name, "LDNS_ECC", 8)) { + /* ^ */ + *iv_return = LDNS_ECC; + return PERL_constant_ISIV; + } + break; + } + break; + case 9: + /* Names all of length 9. */ + /* LDNS_PORT LDNS_SHA1 */ + /* Offset 5 gives the best switch position. */ + switch (name[5]) { + case 'P': + if (memEQ(name, "LDNS_PORT", 9)) { + /* ^ */ +#ifdef LDNS_PORT + *iv_return = LDNS_PORT; + return PERL_constant_ISIV; +#else + return PERL_constant_NOTDEF; +#endif + } + break; + case 'S': + if (memEQ(name, "LDNS_SHA1", 9)) { + /* ^ */ + *iv_return = LDNS_SHA1; + return PERL_constant_ISIV; + } + break; + } + break; + case 11: + /* Names all of length 11. */ + /* LDNS_RSAMD5 LDNS_SHA256 */ + /* Offset 10 gives the best switch position. */ + switch (name[10]) { + case '5': + if (memEQ(name, "LDNS_RSAMD", 10)) { + /* 5 */ + *iv_return = LDNS_RSAMD5; + return PERL_constant_ISIV; + } + break; + case '6': + if (memEQ(name, "LDNS_SHA25", 10)) { + /* 6 */ + *iv_return = LDNS_SHA256; + return PERL_constant_ISIV; + } + break; + } + break; + case 12: + if (memEQ(name, "LDNS_RSASHA1", 12)) { + *iv_return = LDNS_RSASHA1; + return PERL_constant_ISIV; + } + break; + case 13: + return constant_13 (aTHX_ name, iv_return); + break; + case 14: + return constant_14 (aTHX_ name, iv_return); + break; + case 15: + return constant_15 (aTHX_ name, iv_return); + break; + case 16: + return constant_16 (aTHX_ name, iv_return); + break; + case 17: + return constant_17 (aTHX_ name, iv_return); + break; + case 18: + return constant_18 (aTHX_ name, iv_return); + break; + case 19: + return constant_19 (aTHX_ name, iv_return); + break; + case 20: + return constant_20 (aTHX_ name, iv_return); + break; + case 21: + return constant_21 (aTHX_ name, iv_return); + break; + case 22: + return constant_22 (aTHX_ name, iv_return); + break; + case 23: + return constant_23 (aTHX_ name, iv_return); + break; + case 24: + return constant_24 (aTHX_ name, iv_return); + break; + case 25: + /* Names all of length 25. */ + /* LDNS_NSEC3_MAX_ITERATIONS LDNS_STATUS_SYNTAX_ORIGIN */ + /* Offset 6 gives the best switch position. */ + switch (name[6]) { + case 'S': + if (memEQ(name, "LDNS_NSEC3_MAX_ITERATIONS", 25)) { + /* ^ */ +#ifdef LDNS_NSEC3_MAX_ITERATIONS + *iv_return = LDNS_NSEC3_MAX_ITERATIONS; + return PERL_constant_ISIV; +#else + return PERL_constant_NOTDEF; +#endif + } + break; + case 'T': + if (memEQ(name, "LDNS_STATUS_SYNTAX_ORIGIN", 25)) { + /* ^ */ + *iv_return = LDNS_STATUS_SYNTAX_ORIGIN; + return PERL_constant_ISIV; + } + break; + } + break; + case 26: + return constant_26 (aTHX_ name, iv_return); + break; + case 27: + return constant_27 (aTHX_ name, iv_return); + break; + case 28: + return constant_28 (aTHX_ name, iv_return); + break; + case 29: + return constant_29 (aTHX_ name, iv_return); + break; + case 30: + return constant_30 (aTHX_ name, iv_return); + break; + case 31: + /* Names all of length 31. */ + /* LDNS_STATUS_CRYPTO_UNKNOWN_ALGO LDNS_STATUS_DOMAINNAME_OVERFLOW */ + /* Offset 12 gives the best switch position. */ + switch (name[12]) { + case 'C': + if (memEQ(name, "LDNS_STATUS_CRYPTO_UNKNOWN_ALGO", 31)) { + /* ^ */ + *iv_return = LDNS_STATUS_CRYPTO_UNKNOWN_ALGO; + return PERL_constant_ISIV; + } + break; + case 'D': + if (memEQ(name, "LDNS_STATUS_DOMAINNAME_OVERFLOW", 31)) { + /* ^ */ + *iv_return = LDNS_STATUS_DOMAINNAME_OVERFLOW; + return PERL_constant_ISIV; + } + break; + } + break; + case 32: + return constant_32 (aTHX_ name, iv_return); + break; + case 33: + if (memEQ(name, "LDNS_STATUS_ENGINE_KEY_NOT_LOADED", 33)) { + *iv_return = LDNS_STATUS_ENGINE_KEY_NOT_LOADED; + return PERL_constant_ISIV; + } + break; + case 34: + /* Names all of length 34. */ + /* LDNS_STATUS_WIRE_INCOMPLETE_ANSWER LDNS_STATUS_WIRE_INCOMPLETE_HEADER */ + /* Offset 28 gives the best switch position. */ + switch (name[28]) { + case 'A': + if (memEQ(name, "LDNS_STATUS_WIRE_INCOMPLETE_ANSWER", 34)) { + /* ^ */ + *iv_return = LDNS_STATUS_WIRE_INCOMPLETE_ANSWER; + return PERL_constant_ISIV; + } + break; + case 'H': + if (memEQ(name, "LDNS_STATUS_WIRE_INCOMPLETE_HEADER", 34)) { + /* ^ */ + *iv_return = LDNS_STATUS_WIRE_INCOMPLETE_HEADER; + return PERL_constant_ISIV; + } + break; + } + break; + case 35: + return constant_35 (aTHX_ name, iv_return); + break; + case 36: + return constant_36 (aTHX_ name, iv_return); + break; + case 37: + if (memEQ(name, "LDNS_STATUS_WIRE_INCOMPLETE_AUTHORITY", 37)) { + *iv_return = LDNS_STATUS_WIRE_INCOMPLETE_AUTHORITY; + return PERL_constant_ISIV; + } + break; + case 38: + return constant_38 (aTHX_ name, iv_return); + break; + case 43: + if (memEQ(name, "LDNS_STATUS_DNSSEC_NSEC3_ORIGINAL_NOT_FOUND", 43)) { + *iv_return = LDNS_STATUS_DNSSEC_NSEC3_ORIGINAL_NOT_FOUND; + return PERL_constant_ISIV; + } + break; + case 44: + /* Names all of length 44. */ + /* LDNS_STATUS_CRYPTO_NO_MATCHING_KEYTAG_DNSKEY + LDNS_STATUS_DNSSEC_NSEC_WILDCARD_NOT_COVERED */ + /* Offset 12 gives the best switch position. */ + switch (name[12]) { + case 'C': + if (memEQ(name, "LDNS_STATUS_CRYPTO_NO_MATCHING_KEYTAG_DNSKEY", 44)) { + /* ^ */ + *iv_return = LDNS_STATUS_CRYPTO_NO_MATCHING_KEYTAG_DNSKEY; + return PERL_constant_ISIV; + } + break; + case 'D': + if (memEQ(name, "LDNS_STATUS_DNSSEC_NSEC_WILDCARD_NOT_COVERED", 44)) { + /* ^ */ + *iv_return = LDNS_STATUS_DNSSEC_NSEC_WILDCARD_NOT_COVERED; + return PERL_constant_ISIV; + } + break; + } + break; + case 46: + if (memEQ(name, "LDNS_STATUS_CRYPTO_EXPIRATION_BEFORE_INCEPTION", 46)) { + *iv_return = LDNS_STATUS_CRYPTO_EXPIRATION_BEFORE_INCEPTION; + return PERL_constant_ISIV; + } + break; + } + return PERL_constant_NOTFOUND; +} + diff --git a/contrib/DNS-LDNS/const-xs.inc b/contrib/DNS-LDNS/const-xs.inc new file mode 100644 index 0000000000000..1738df2243a75 --- /dev/null +++ b/contrib/DNS-LDNS/const-xs.inc @@ -0,0 +1,90 @@ +void +constant(sv) + PREINIT: +#ifdef dXSTARG + dXSTARG; /* Faster if we have it. */ +#else + dTARGET; +#endif + STRLEN len; + int type; + IV iv; + /* NV nv; Uncomment this if you need to return NVs */ + /* const char *pv; Uncomment this if you need to return PVs */ + INPUT: + SV * sv; + const char * s = SvPV(sv, len); + PPCODE: + /* Change this to constant(aTHX_ s, len, &iv, &nv); + if you need to return both NVs and IVs */ + type = constant(aTHX_ s, len, &iv); + /* Return 1 or 2 items. First is error message, or undef if no error. + Second, if present, is found value */ + switch (type) { + case PERL_constant_NOTFOUND: + sv = + sv_2mortal(newSVpvf("%s is not a valid LDNS macro", s)); + PUSHs(sv); + break; + case PERL_constant_NOTDEF: + sv = sv_2mortal(newSVpvf( + "Your vendor has not defined LDNS macro %s, used", + s)); + PUSHs(sv); + break; + case PERL_constant_ISIV: + EXTEND(SP, 1); + PUSHs(&PL_sv_undef); + PUSHi(iv); + break; + /* Uncomment this if you need to return NOs + case PERL_constant_ISNO: + EXTEND(SP, 1); + PUSHs(&PL_sv_undef); + PUSHs(&PL_sv_no); + break; */ + /* Uncomment this if you need to return NVs + case PERL_constant_ISNV: + EXTEND(SP, 1); + PUSHs(&PL_sv_undef); + PUSHn(nv); + break; */ + /* Uncomment this if you need to return PVs + case PERL_constant_ISPV: + EXTEND(SP, 1); + PUSHs(&PL_sv_undef); + PUSHp(pv, strlen(pv)); + break; */ + /* Uncomment this if you need to return PVNs + case PERL_constant_ISPVN: + EXTEND(SP, 1); + PUSHs(&PL_sv_undef); + PUSHp(pv, iv); + break; */ + /* Uncomment this if you need to return SVs + case PERL_constant_ISSV: + EXTEND(SP, 1); + PUSHs(&PL_sv_undef); + PUSHs(sv); + break; */ + /* Uncomment this if you need to return UNDEFs + case PERL_constant_ISUNDEF: + break; */ + /* Uncomment this if you need to return UVs + case PERL_constant_ISUV: + EXTEND(SP, 1); + PUSHs(&PL_sv_undef); + PUSHu((UV)iv); + break; */ + /* Uncomment this if you need to return YESs + case PERL_constant_ISYES: + EXTEND(SP, 1); + PUSHs(&PL_sv_undef); + PUSHs(&PL_sv_yes); + break; */ + default: + sv = sv_2mortal(newSVpvf( + "Unexpected return type %d while processing LDNS macro %s, used", + type, s)); + PUSHs(sv); + } diff --git a/contrib/DNS-LDNS/fallback/const-c.inc b/contrib/DNS-LDNS/fallback/const-c.inc new file mode 100644 index 0000000000000..6456baa182b2e --- /dev/null +++ b/contrib/DNS-LDNS/fallback/const-c.inc @@ -0,0 +1,2798 @@ +#define PERL_constant_NOTFOUND 1 +#define PERL_constant_NOTDEF 2 +#define PERL_constant_ISIV 3 +#define PERL_constant_ISNO 4 +#define PERL_constant_ISNV 5 +#define PERL_constant_ISPV 6 +#define PERL_constant_ISPVN 7 +#define PERL_constant_ISSV 8 +#define PERL_constant_ISUNDEF 9 +#define PERL_constant_ISUV 10 +#define PERL_constant_ISYES 11 + +#ifndef NVTYPE +typedef double NV; /* 5.6 and later define NVTYPE, and typedef NV to it. */ +#endif +#ifndef aTHX_ +#define aTHX_ /* 5.6 or later define this for threading support. */ +#endif +#ifndef pTHX_ +#define pTHX_ /* 5.6 or later define this for threading support. */ +#endif + +static int +constant_7 (pTHX_ const char *name, IV *iv_return) { + /* When generated this function returned values for the list of names given + here. However, subsequent manual editing may have added or removed some. + LDNS_AA LDNS_AD LDNS_CD LDNS_DH LDNS_QR LDNS_RA LDNS_RD LDNS_TC */ + /* Offset 5 gives the best switch position. */ + switch (name[5]) { + case 'A': + if (memEQ(name, "LDNS_AA", 7)) { + /* ^ */ +#ifdef LDNS_AA + *iv_return = LDNS_AA; + return PERL_constant_ISIV; +#else + return PERL_constant_NOTDEF; +#endif + } + if (memEQ(name, "LDNS_AD", 7)) { + /* ^ */ +#ifdef LDNS_AD + *iv_return = LDNS_AD; + return PERL_constant_ISIV; +#else + return PERL_constant_NOTDEF; +#endif + } + break; + case 'C': + if (memEQ(name, "LDNS_CD", 7)) { + /* ^ */ +#ifdef LDNS_CD + *iv_return = LDNS_CD; + return PERL_constant_ISIV; +#else + return PERL_constant_NOTDEF; +#endif + } + break; + case 'D': + if (memEQ(name, "LDNS_DH", 7)) { + /* ^ */ + *iv_return = LDNS_DH; + return PERL_constant_ISIV; + } + break; + case 'Q': + if (memEQ(name, "LDNS_QR", 7)) { + /* ^ */ +#ifdef LDNS_QR + *iv_return = LDNS_QR; + return PERL_constant_ISIV; +#else + return PERL_constant_NOTDEF; +#endif + } + break; + case 'R': + if (memEQ(name, "LDNS_RA", 7)) { + /* ^ */ +#ifdef LDNS_RA + *iv_return = LDNS_RA; + return PERL_constant_ISIV; +#else + return PERL_constant_NOTDEF; +#endif + } + if (memEQ(name, "LDNS_RD", 7)) { + /* ^ */ +#ifdef LDNS_RD + *iv_return = LDNS_RD; + return PERL_constant_ISIV; +#else + return PERL_constant_NOTDEF; +#endif + } + break; + case 'T': + if (memEQ(name, "LDNS_TC", 7)) { + /* ^ */ +#ifdef LDNS_TC + *iv_return = LDNS_TC; + return PERL_constant_ISIV; +#else + return PERL_constant_NOTDEF; +#endif + } + break; + } + return PERL_constant_NOTFOUND; +} + +static int +constant_11 (pTHX_ const char *name, IV *iv_return) { + /* When generated this function returned values for the list of names given + here. However, subsequent manual editing may have added or removed some. + LDNS_RSAMD5 LDNS_SHA256 LDNS_SHA384 */ + /* Offset 10 gives the best switch position. */ + switch (name[10]) { + case '4': + if (memEQ(name, "LDNS_SHA38", 10)) { + /* 4 */ + *iv_return = LDNS_SHA384; + return PERL_constant_ISIV; + } + break; + case '5': + if (memEQ(name, "LDNS_RSAMD", 10)) { + /* 5 */ + *iv_return = LDNS_RSAMD5; + return PERL_constant_ISIV; + } + break; + case '6': + if (memEQ(name, "LDNS_SHA25", 10)) { + /* 6 */ + *iv_return = LDNS_SHA256; + return PERL_constant_ISIV; + } + break; + } + return PERL_constant_NOTFOUND; +} + +static int +constant_13 (pTHX_ const char *name, IV *iv_return) { + /* When generated this function returned values for the list of names given + here. However, subsequent manual editing may have added or removed some. + LDNS_CERT_OID LDNS_CERT_PGP LDNS_CERT_URI LDNS_ECC_GOST LDNS_SIGN_DSA */ + /* Offset 12 gives the best switch position. */ + switch (name[12]) { + case 'A': + if (memEQ(name, "LDNS_SIGN_DS", 12)) { + /* A */ + *iv_return = LDNS_SIGN_DSA; + return PERL_constant_ISIV; + } + break; + case 'D': + if (memEQ(name, "LDNS_CERT_OI", 12)) { + /* D */ + *iv_return = LDNS_CERT_OID; + return PERL_constant_ISIV; + } + break; + case 'I': + if (memEQ(name, "LDNS_CERT_UR", 12)) { + /* I */ + *iv_return = LDNS_CERT_URI; + return PERL_constant_ISIV; + } + break; + case 'P': + if (memEQ(name, "LDNS_CERT_PG", 12)) { + /* P */ + *iv_return = LDNS_CERT_PGP; + return PERL_constant_ISIV; + } + break; + case 'T': + if (memEQ(name, "LDNS_ECC_GOS", 12)) { + /* T */ + *iv_return = LDNS_ECC_GOST; + return PERL_constant_ISIV; + } + break; + } + return PERL_constant_NOTFOUND; +} + +static int +constant_14 (pTHX_ const char *name, IV *iv_return) { + /* When generated this function returned values for the list of names given + here. However, subsequent manual editing may have added or removed some. + LDNS_CERT_IPGP LDNS_CERT_PKIX LDNS_CERT_SPKI LDNS_DSA_NSEC3 LDNS_HASH_GOST + LDNS_RR_TYPE_A LDNS_RSASHA256 LDNS_RSASHA512 LDNS_STATUS_OK */ + /* Offset 13 gives the best switch position. */ + switch (name[13]) { + case '2': + if (memEQ(name, "LDNS_RSASHA51", 13)) { + /* 2 */ + *iv_return = LDNS_RSASHA512; + return PERL_constant_ISIV; + } + break; + case '3': + if (memEQ(name, "LDNS_DSA_NSEC", 13)) { + /* 3 */ + *iv_return = LDNS_DSA_NSEC3; + return PERL_constant_ISIV; + } + break; + case '6': + if (memEQ(name, "LDNS_RSASHA25", 13)) { + /* 6 */ + *iv_return = LDNS_RSASHA256; + return PERL_constant_ISIV; + } + break; + case 'A': + if (memEQ(name, "LDNS_RR_TYPE_", 13)) { + /* A */ + *iv_return = LDNS_RR_TYPE_A; + return PERL_constant_ISIV; + } + break; + case 'I': + if (memEQ(name, "LDNS_CERT_SPK", 13)) { + /* I */ + *iv_return = LDNS_CERT_SPKI; + return PERL_constant_ISIV; + } + break; + case 'K': + if (memEQ(name, "LDNS_STATUS_O", 13)) { + /* K */ + *iv_return = LDNS_STATUS_OK; + return PERL_constant_ISIV; + } + break; + case 'P': + if (memEQ(name, "LDNS_CERT_IPG", 13)) { + /* P */ + *iv_return = LDNS_CERT_IPGP; + return PERL_constant_ISIV; + } + break; + case 'T': + if (memEQ(name, "LDNS_HASH_GOS", 13)) { + /* T */ + *iv_return = LDNS_HASH_GOST; + return PERL_constant_ISIV; + } + break; + case 'X': + if (memEQ(name, "LDNS_CERT_PKI", 13)) { + /* X */ + *iv_return = LDNS_CERT_PKIX; + return PERL_constant_ISIV; + } + break; + } + return PERL_constant_NOTFOUND; +} + +static int +constant_15 (pTHX_ const char *name, IV *iv_return) { + /* When generated this function returned values for the list of names given + here. However, subsequent manual editing may have added or removed some. + LDNS_CERT_IPKIX LDNS_CERT_ISPKI LDNS_IP4ADDRLEN LDNS_IP6ADDRLEN + LDNS_MAX_RDFLEN LDNS_PRIVATEDNS LDNS_PRIVATEOID LDNS_RDF_TYPE_A + LDNS_RR_TYPE_A6 LDNS_RR_TYPE_DS LDNS_RR_TYPE_KX LDNS_RR_TYPE_MB + LDNS_RR_TYPE_MD LDNS_RR_TYPE_MF LDNS_RR_TYPE_MG LDNS_RR_TYPE_MR + LDNS_RR_TYPE_MX LDNS_RR_TYPE_NS LDNS_RR_TYPE_PX LDNS_RR_TYPE_RP + LDNS_RR_TYPE_RT LDNS_STATUS_ERR */ + /* Offset 14 gives the best switch position. */ + switch (name[14]) { + case '6': + if (memEQ(name, "LDNS_RR_TYPE_A", 14)) { + /* 6 */ + *iv_return = LDNS_RR_TYPE_A6; + return PERL_constant_ISIV; + } + break; + case 'A': + if (memEQ(name, "LDNS_RDF_TYPE_", 14)) { + /* A */ + *iv_return = LDNS_RDF_TYPE_A; + return PERL_constant_ISIV; + } + break; + case 'B': + if (memEQ(name, "LDNS_RR_TYPE_M", 14)) { + /* B */ + *iv_return = LDNS_RR_TYPE_MB; + return PERL_constant_ISIV; + } + break; + case 'D': + if (memEQ(name, "LDNS_PRIVATEOI", 14)) { + /* D */ + *iv_return = LDNS_PRIVATEOID; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RR_TYPE_M", 14)) { + /* D */ + *iv_return = LDNS_RR_TYPE_MD; + return PERL_constant_ISIV; + } + break; + case 'F': + if (memEQ(name, "LDNS_RR_TYPE_M", 14)) { + /* F */ + *iv_return = LDNS_RR_TYPE_MF; + return PERL_constant_ISIV; + } + break; + case 'G': + if (memEQ(name, "LDNS_RR_TYPE_M", 14)) { + /* G */ + *iv_return = LDNS_RR_TYPE_MG; + return PERL_constant_ISIV; + } + break; + case 'I': + if (memEQ(name, "LDNS_CERT_ISPK", 14)) { + /* I */ + *iv_return = LDNS_CERT_ISPKI; + return PERL_constant_ISIV; + } + break; + case 'N': + if (memEQ(name, "LDNS_IP4ADDRLE", 14)) { + /* N */ +#ifdef LDNS_IP4ADDRLEN + *iv_return = LDNS_IP4ADDRLEN; + return PERL_constant_ISIV; +#else + return PERL_constant_NOTDEF; +#endif + } + if (memEQ(name, "LDNS_IP6ADDRLE", 14)) { + /* N */ +#ifdef LDNS_IP6ADDRLEN + *iv_return = LDNS_IP6ADDRLEN; + return PERL_constant_ISIV; +#else + return PERL_constant_NOTDEF; +#endif + } + if (memEQ(name, "LDNS_MAX_RDFLE", 14)) { + /* N */ +#ifdef LDNS_MAX_RDFLEN + *iv_return = LDNS_MAX_RDFLEN; + return PERL_constant_ISIV; +#else + return PERL_constant_NOTDEF; +#endif + } + break; + case 'P': + if (memEQ(name, "LDNS_RR_TYPE_R", 14)) { + /* P */ + *iv_return = LDNS_RR_TYPE_RP; + return PERL_constant_ISIV; + } + break; + case 'R': + if (memEQ(name, "LDNS_RR_TYPE_M", 14)) { + /* R */ + *iv_return = LDNS_RR_TYPE_MR; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_STATUS_ER", 14)) { + /* R */ + *iv_return = LDNS_STATUS_ERR; + return PERL_constant_ISIV; + } + break; + case 'S': + if (memEQ(name, "LDNS_PRIVATEDN", 14)) { + /* S */ + *iv_return = LDNS_PRIVATEDNS; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RR_TYPE_D", 14)) { + /* S */ + *iv_return = LDNS_RR_TYPE_DS; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RR_TYPE_N", 14)) { + /* S */ + *iv_return = LDNS_RR_TYPE_NS; + return PERL_constant_ISIV; + } + break; + case 'T': + if (memEQ(name, "LDNS_RR_TYPE_R", 14)) { + /* T */ + *iv_return = LDNS_RR_TYPE_RT; + return PERL_constant_ISIV; + } + break; + case 'X': + if (memEQ(name, "LDNS_CERT_IPKI", 14)) { + /* X */ + *iv_return = LDNS_CERT_IPKIX; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RR_TYPE_K", 14)) { + /* X */ + *iv_return = LDNS_RR_TYPE_KX; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RR_TYPE_M", 14)) { + /* X */ + *iv_return = LDNS_RR_TYPE_MX; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RR_TYPE_P", 14)) { + /* X */ + *iv_return = LDNS_RR_TYPE_PX; + return PERL_constant_ISIV; + } + break; + } + return PERL_constant_NOTFOUND; +} + +static int +constant_16 (pTHX_ const char *name, IV *iv_return) { + /* When generated this function returned values for the list of names given + here. However, subsequent manual editing may have added or removed some. + LDNS_CERT_ACPKIX LDNS_DEFAULT_TTL LDNS_KEY_SEP_KEY LDNS_RESOLV_INET + LDNS_RR_CLASS_CH LDNS_RR_CLASS_HS LDNS_RR_CLASS_IN LDNS_RR_COMPRESS + LDNS_RR_OVERHEAD LDNS_RR_TYPE_ANY LDNS_RR_TYPE_APL LDNS_RR_TYPE_DLV + LDNS_RR_TYPE_EID LDNS_RR_TYPE_GID LDNS_RR_TYPE_KEY LDNS_RR_TYPE_LOC + LDNS_RR_TYPE_NXT LDNS_RR_TYPE_OPT LDNS_RR_TYPE_PTR LDNS_RR_TYPE_SIG + LDNS_RR_TYPE_SOA LDNS_RR_TYPE_SPF LDNS_RR_TYPE_SRV LDNS_RR_TYPE_TXT + LDNS_RR_TYPE_UID LDNS_RR_TYPE_WKS LDNS_RR_TYPE_X25 LDNS_SECTION_ANY + LDNS_SIGN_RSAMD5 LDNS_STATUS_NULL */ + /* Offset 13 gives the best switch position. */ + switch (name[13]) { + case 'A': + if (memEQ(name, "LDNS_RR_TYPE_ANY", 16)) { + /* ^ */ + *iv_return = LDNS_RR_TYPE_ANY; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RR_TYPE_APL", 16)) { + /* ^ */ + *iv_return = LDNS_RR_TYPE_APL; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_SECTION_ANY", 16)) { + /* ^ */ + *iv_return = LDNS_SECTION_ANY; + return PERL_constant_ISIV; + } + break; + case 'D': + if (memEQ(name, "LDNS_RR_TYPE_DLV", 16)) { + /* ^ */ + *iv_return = LDNS_RR_TYPE_DLV; + return PERL_constant_ISIV; + } + break; + case 'E': + if (memEQ(name, "LDNS_RR_COMPRESS", 16)) { + /* ^ */ + *iv_return = LDNS_RR_COMPRESS; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RR_OVERHEAD", 16)) { + /* ^ */ +#ifdef LDNS_RR_OVERHEAD + *iv_return = LDNS_RR_OVERHEAD; + return PERL_constant_ISIV; +#else + return PERL_constant_NOTDEF; +#endif + } + if (memEQ(name, "LDNS_RR_TYPE_EID", 16)) { + /* ^ */ + *iv_return = LDNS_RR_TYPE_EID; + return PERL_constant_ISIV; + } + break; + case 'G': + if (memEQ(name, "LDNS_RR_TYPE_GID", 16)) { + /* ^ */ + *iv_return = LDNS_RR_TYPE_GID; + return PERL_constant_ISIV; + } + break; + case 'K': + if (memEQ(name, "LDNS_CERT_ACPKIX", 16)) { + /* ^ */ + *iv_return = LDNS_CERT_ACPKIX; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_KEY_SEP_KEY", 16)) { + /* ^ */ +#ifdef LDNS_KEY_SEP_KEY + *iv_return = LDNS_KEY_SEP_KEY; + return PERL_constant_ISIV; +#else + return PERL_constant_NOTDEF; +#endif + } + if (memEQ(name, "LDNS_RR_TYPE_KEY", 16)) { + /* ^ */ + *iv_return = LDNS_RR_TYPE_KEY; + return PERL_constant_ISIV; + } + break; + case 'L': + if (memEQ(name, "LDNS_RR_TYPE_LOC", 16)) { + /* ^ */ + *iv_return = LDNS_RR_TYPE_LOC; + return PERL_constant_ISIV; + } + break; + case 'M': + if (memEQ(name, "LDNS_SIGN_RSAMD5", 16)) { + /* ^ */ + *iv_return = LDNS_SIGN_RSAMD5; + return PERL_constant_ISIV; + } + break; + case 'N': + if (memEQ(name, "LDNS_RESOLV_INET", 16)) { + /* ^ */ +#ifdef LDNS_RESOLV_INET + *iv_return = LDNS_RESOLV_INET; + return PERL_constant_ISIV; +#else + return PERL_constant_NOTDEF; +#endif + } + if (memEQ(name, "LDNS_RR_TYPE_NXT", 16)) { + /* ^ */ + *iv_return = LDNS_RR_TYPE_NXT; + return PERL_constant_ISIV; + } + break; + case 'O': + if (memEQ(name, "LDNS_RR_TYPE_OPT", 16)) { + /* ^ */ + *iv_return = LDNS_RR_TYPE_OPT; + return PERL_constant_ISIV; + } + break; + case 'P': + if (memEQ(name, "LDNS_RR_TYPE_PTR", 16)) { + /* ^ */ + *iv_return = LDNS_RR_TYPE_PTR; + return PERL_constant_ISIV; + } + break; + case 'S': + if (memEQ(name, "LDNS_RR_TYPE_SIG", 16)) { + /* ^ */ + *iv_return = LDNS_RR_TYPE_SIG; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RR_TYPE_SOA", 16)) { + /* ^ */ + *iv_return = LDNS_RR_TYPE_SOA; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RR_TYPE_SPF", 16)) { + /* ^ */ + *iv_return = LDNS_RR_TYPE_SPF; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RR_TYPE_SRV", 16)) { + /* ^ */ + *iv_return = LDNS_RR_TYPE_SRV; + return PERL_constant_ISIV; + } + break; + case 'T': + if (memEQ(name, "LDNS_DEFAULT_TTL", 16)) { + /* ^ */ +#ifdef LDNS_DEFAULT_TTL + *iv_return = LDNS_DEFAULT_TTL; + return PERL_constant_ISIV; +#else + return PERL_constant_NOTDEF; +#endif + } + if (memEQ(name, "LDNS_RR_TYPE_TXT", 16)) { + /* ^ */ + *iv_return = LDNS_RR_TYPE_TXT; + return PERL_constant_ISIV; + } + break; + case 'U': + if (memEQ(name, "LDNS_RR_TYPE_UID", 16)) { + /* ^ */ + *iv_return = LDNS_RR_TYPE_UID; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_STATUS_NULL", 16)) { + /* ^ */ + *iv_return = LDNS_STATUS_NULL; + return PERL_constant_ISIV; + } + break; + case 'W': + if (memEQ(name, "LDNS_RR_TYPE_WKS", 16)) { + /* ^ */ + *iv_return = LDNS_RR_TYPE_WKS; + return PERL_constant_ISIV; + } + break; + case 'X': + if (memEQ(name, "LDNS_RR_TYPE_X25", 16)) { + /* ^ */ + *iv_return = LDNS_RR_TYPE_X25; + return PERL_constant_ISIV; + } + break; + case '_': + if (memEQ(name, "LDNS_RR_CLASS_CH", 16)) { + /* ^ */ + *iv_return = LDNS_RR_CLASS_CH; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RR_CLASS_HS", 16)) { + /* ^ */ + *iv_return = LDNS_RR_CLASS_HS; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RR_CLASS_IN", 16)) { + /* ^ */ + *iv_return = LDNS_RR_CLASS_IN; + return PERL_constant_ISIV; + } + break; + } + return PERL_constant_NOTFOUND; +} + +static int +constant_17 (pTHX_ const char *name, IV *iv_return) { + /* When generated this function returned values for the list of names given + here. However, subsequent manual editing may have added or removed some. + LDNS_CERT_IACPKIX LDNS_KEY_ZONE_KEY LDNS_MAX_LABELLEN LDNS_MAX_POINTERS + LDNS_PACKET_QUERY LDNS_RDF_TYPE_ALG LDNS_RDF_TYPE_APL LDNS_RDF_TYPE_B64 + LDNS_RDF_TYPE_HEX LDNS_RDF_TYPE_LOC LDNS_RDF_TYPE_STR LDNS_RDF_TYPE_WKS + LDNS_RESOLV_INET6 LDNS_RR_CLASS_ANY LDNS_RR_TYPE_AAAA LDNS_RR_TYPE_ATMA + LDNS_RR_TYPE_AXFR LDNS_RR_TYPE_CERT LDNS_RR_TYPE_GPOS LDNS_RR_TYPE_ISDN + LDNS_RR_TYPE_IXFR LDNS_RR_TYPE_LAST LDNS_RR_TYPE_NSAP LDNS_RR_TYPE_NSEC + LDNS_RR_TYPE_NULL LDNS_RR_TYPE_SINK LDNS_RR_TYPE_TSIG LDNS_SIGN_RSASHA1 */ + /* Offset 16 gives the best switch position. */ + switch (name[16]) { + case '1': + if (memEQ(name, "LDNS_SIGN_RSASHA", 16)) { + /* 1 */ + *iv_return = LDNS_SIGN_RSASHA1; + return PERL_constant_ISIV; + } + break; + case '4': + if (memEQ(name, "LDNS_RDF_TYPE_B6", 16)) { + /* 4 */ + *iv_return = LDNS_RDF_TYPE_B64; + return PERL_constant_ISIV; + } + break; + case '6': + if (memEQ(name, "LDNS_RESOLV_INET", 16)) { + /* 6 */ +#ifdef LDNS_RESOLV_INET6 + *iv_return = LDNS_RESOLV_INET6; + return PERL_constant_ISIV; +#else + return PERL_constant_NOTDEF; +#endif + } + break; + case 'A': + if (memEQ(name, "LDNS_RR_TYPE_AAA", 16)) { + /* A */ + *iv_return = LDNS_RR_TYPE_AAAA; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RR_TYPE_ATM", 16)) { + /* A */ + *iv_return = LDNS_RR_TYPE_ATMA; + return PERL_constant_ISIV; + } + break; + case 'C': + if (memEQ(name, "LDNS_RDF_TYPE_LO", 16)) { + /* C */ + *iv_return = LDNS_RDF_TYPE_LOC; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RR_TYPE_NSE", 16)) { + /* C */ + *iv_return = LDNS_RR_TYPE_NSEC; + return PERL_constant_ISIV; + } + break; + case 'G': + if (memEQ(name, "LDNS_RDF_TYPE_AL", 16)) { + /* G */ + *iv_return = LDNS_RDF_TYPE_ALG; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RR_TYPE_TSI", 16)) { + /* G */ + *iv_return = LDNS_RR_TYPE_TSIG; + return PERL_constant_ISIV; + } + break; + case 'K': + if (memEQ(name, "LDNS_RR_TYPE_SIN", 16)) { + /* K */ + *iv_return = LDNS_RR_TYPE_SINK; + return PERL_constant_ISIV; + } + break; + case 'L': + if (memEQ(name, "LDNS_RDF_TYPE_AP", 16)) { + /* L */ + *iv_return = LDNS_RDF_TYPE_APL; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RR_TYPE_NUL", 16)) { + /* L */ + *iv_return = LDNS_RR_TYPE_NULL; + return PERL_constant_ISIV; + } + break; + case 'N': + if (memEQ(name, "LDNS_MAX_LABELLE", 16)) { + /* N */ +#ifdef LDNS_MAX_LABELLEN + *iv_return = LDNS_MAX_LABELLEN; + return PERL_constant_ISIV; +#else + return PERL_constant_NOTDEF; +#endif + } + if (memEQ(name, "LDNS_RR_TYPE_ISD", 16)) { + /* N */ + *iv_return = LDNS_RR_TYPE_ISDN; + return PERL_constant_ISIV; + } + break; + case 'P': + if (memEQ(name, "LDNS_RR_TYPE_NSA", 16)) { + /* P */ + *iv_return = LDNS_RR_TYPE_NSAP; + return PERL_constant_ISIV; + } + break; + case 'R': + if (memEQ(name, "LDNS_RDF_TYPE_ST", 16)) { + /* R */ + *iv_return = LDNS_RDF_TYPE_STR; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RR_TYPE_AXF", 16)) { + /* R */ + *iv_return = LDNS_RR_TYPE_AXFR; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RR_TYPE_IXF", 16)) { + /* R */ + *iv_return = LDNS_RR_TYPE_IXFR; + return PERL_constant_ISIV; + } + break; + case 'S': + if (memEQ(name, "LDNS_MAX_POINTER", 16)) { + /* S */ +#ifdef LDNS_MAX_POINTERS + *iv_return = LDNS_MAX_POINTERS; + return PERL_constant_ISIV; +#else + return PERL_constant_NOTDEF; +#endif + } + if (memEQ(name, "LDNS_RDF_TYPE_WK", 16)) { + /* S */ + *iv_return = LDNS_RDF_TYPE_WKS; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RR_TYPE_GPO", 16)) { + /* S */ + *iv_return = LDNS_RR_TYPE_GPOS; + return PERL_constant_ISIV; + } + break; + case 'T': + if (memEQ(name, "LDNS_RR_TYPE_CER", 16)) { + /* T */ + *iv_return = LDNS_RR_TYPE_CERT; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RR_TYPE_LAS", 16)) { + /* T */ + *iv_return = LDNS_RR_TYPE_LAST; + return PERL_constant_ISIV; + } + break; + case 'X': + if (memEQ(name, "LDNS_CERT_IACPKI", 16)) { + /* X */ + *iv_return = LDNS_CERT_IACPKIX; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RDF_TYPE_HE", 16)) { + /* X */ + *iv_return = LDNS_RDF_TYPE_HEX; + return PERL_constant_ISIV; + } + break; + case 'Y': + if (memEQ(name, "LDNS_KEY_ZONE_KE", 16)) { + /* Y */ +#ifdef LDNS_KEY_ZONE_KEY + *iv_return = LDNS_KEY_ZONE_KEY; + return PERL_constant_ISIV; +#else + return PERL_constant_NOTDEF; +#endif + } + if (memEQ(name, "LDNS_PACKET_QUER", 16)) { + /* Y */ + *iv_return = LDNS_PACKET_QUERY; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RR_CLASS_AN", 16)) { + /* Y */ + *iv_return = LDNS_RR_CLASS_ANY; + return PERL_constant_ISIV; + } + break; + } + return PERL_constant_NOTFOUND; +} + +static int +constant_18 (pTHX_ const char *name, IV *iv_return) { + /* When generated this function returned values for the list of names given + here. However, subsequent manual editing may have added or removed some. + LDNS_MAX_DOMAINLEN LDNS_MAX_PACKETLEN LDNS_PACKET_ANSWER + LDNS_PACKET_IQUERY LDNS_PACKET_NODATA LDNS_PACKET_NOTIFY + LDNS_PACKET_STATUS LDNS_PACKET_UPDATE LDNS_RCODE_FORMERR + LDNS_RCODE_NOERROR LDNS_RCODE_NOTAUTH LDNS_RCODE_NOTIMPL + LDNS_RCODE_NOTZONE LDNS_RCODE_NXRRSET LDNS_RCODE_REFUSED + LDNS_RCODE_YXRRSET LDNS_RDF_SIZE_BYTE LDNS_RDF_SIZE_WORD + LDNS_RDF_TYPE_AAAA LDNS_RDF_TYPE_ATMA LDNS_RDF_TYPE_INT8 + LDNS_RDF_TYPE_NONE LDNS_RDF_TYPE_NSAP LDNS_RDF_TYPE_NSEC + LDNS_RDF_TYPE_TIME LDNS_RDF_TYPE_HIP LDNS_RDF_TYPE_TYPE + LDNS_RESOLV_ANCHOR LDNS_RESOLV_SEARCH LDNS_RR_CLASS_LAST + LDNS_RR_CLASS_NONE LDNS_RR_TYPE_AFSDB LDNS_RR_TYPE_CNAME + LDNS_RR_TYPE_COUNT LDNS_RR_TYPE_DHCID LDNS_RR_TYPE_DNAME + LDNS_RR_TYPE_FIRST LDNS_RR_TYPE_HINFO LDNS_RR_TYPE_MAILA + LDNS_RR_TYPE_MAILB LDNS_RR_TYPE_MINFO LDNS_RR_TYPE_NAPTR + LDNS_RR_TYPE_NSEC3 LDNS_RR_TYPE_RRSIG LDNS_RR_TYPE_SSHFP + LDNS_RR_TYPE_UINFO LDNS_RSASHA1_NSEC3 LDNS_SIGN_ECC_GOST + LDNS_SIGN_HMACSHA1 */ + /* Offset 17 gives the best switch position. */ + switch (name[17]) { + case '1': + if (memEQ(name, "LDNS_SIGN_HMACSHA", 17)) { + /* 1 */ + *iv_return = LDNS_SIGN_HMACSHA1; + return PERL_constant_ISIV; + } + break; + case '3': + if (memEQ(name, "LDNS_RR_TYPE_NSEC", 17)) { + /* 3 */ + *iv_return = LDNS_RR_TYPE_NSEC3; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RSASHA1_NSEC", 17)) { + /* 3 */ + *iv_return = LDNS_RSASHA1_NSEC3; + return PERL_constant_ISIV; + } + break; + case '8': + if (memEQ(name, "LDNS_RDF_TYPE_INT", 17)) { + /* 8 */ + *iv_return = LDNS_RDF_TYPE_INT8; + return PERL_constant_ISIV; + } + break; + case 'A': + if (memEQ(name, "LDNS_PACKET_NODAT", 17)) { + /* A */ + *iv_return = LDNS_PACKET_NODATA; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RDF_TYPE_AAA", 17)) { + /* A */ + *iv_return = LDNS_RDF_TYPE_AAAA; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RDF_TYPE_ATM", 17)) { + /* A */ + *iv_return = LDNS_RDF_TYPE_ATMA; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RR_TYPE_MAIL", 17)) { + /* A */ + *iv_return = LDNS_RR_TYPE_MAILA; + return PERL_constant_ISIV; + } + break; + case 'B': + if (memEQ(name, "LDNS_RR_TYPE_AFSD", 17)) { + /* B */ + *iv_return = LDNS_RR_TYPE_AFSDB; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RR_TYPE_MAIL", 17)) { + /* B */ + *iv_return = LDNS_RR_TYPE_MAILB; + return PERL_constant_ISIV; + } + break; + case 'C': + if (memEQ(name, "LDNS_RDF_TYPE_NSE", 17)) { + /* C */ + *iv_return = LDNS_RDF_TYPE_NSEC; + return PERL_constant_ISIV; + } + break; + case 'D': + if (memEQ(name, "LDNS_RCODE_REFUSE", 17)) { + /* D */ + *iv_return = LDNS_RCODE_REFUSED; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RDF_SIZE_WOR", 17)) { + /* D */ +#ifdef LDNS_RDF_SIZE_WORD + *iv_return = LDNS_RDF_SIZE_WORD; + return PERL_constant_ISIV; +#else + return PERL_constant_NOTDEF; +#endif + } + if (memEQ(name, "LDNS_RR_TYPE_DHCI", 17)) { + /* D */ + *iv_return = LDNS_RR_TYPE_DHCID; + return PERL_constant_ISIV; + } + break; + case 'E': + if (memEQ(name, "LDNS_PACKET_UPDAT", 17)) { + /* E */ + *iv_return = LDNS_PACKET_UPDATE; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RCODE_NOTZON", 17)) { + /* E */ + *iv_return = LDNS_RCODE_NOTZONE; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RDF_SIZE_BYT", 17)) { + /* E */ +#ifdef LDNS_RDF_SIZE_BYTE + *iv_return = LDNS_RDF_SIZE_BYTE; + return PERL_constant_ISIV; +#else + return PERL_constant_NOTDEF; +#endif + } + if (memEQ(name, "LDNS_RDF_TYPE_NON", 17)) { + /* E */ + *iv_return = LDNS_RDF_TYPE_NONE; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RDF_TYPE_TIM", 17)) { + /* E */ + *iv_return = LDNS_RDF_TYPE_TIME; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RDF_TYPE_TYP", 17)) { + /* E */ + *iv_return = LDNS_RDF_TYPE_TYPE; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RR_CLASS_NON", 17)) { + /* E */ + *iv_return = LDNS_RR_CLASS_NONE; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RR_TYPE_CNAM", 17)) { + /* E */ + *iv_return = LDNS_RR_TYPE_CNAME; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RR_TYPE_DNAM", 17)) { + /* E */ + *iv_return = LDNS_RR_TYPE_DNAME; + return PERL_constant_ISIV; + } + break; + case 'G': + if (memEQ(name, "LDNS_RDF_TYPE_HIP", 17)) { + /* G */ + *iv_return = LDNS_RDF_TYPE_HIP; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RR_TYPE_RRSI", 17)) { + /* G */ + *iv_return = LDNS_RR_TYPE_RRSIG; + return PERL_constant_ISIV; + } + break; + case 'H': + if (memEQ(name, "LDNS_RCODE_NOTAUT", 17)) { + /* H */ + *iv_return = LDNS_RCODE_NOTAUTH; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RESOLV_SEARC", 17)) { + /* H */ +#ifdef LDNS_RESOLV_SEARCH + *iv_return = LDNS_RESOLV_SEARCH; + return PERL_constant_ISIV; +#else + return PERL_constant_NOTDEF; +#endif + } + break; + case 'L': + if (memEQ(name, "LDNS_RCODE_NOTIMP", 17)) { + /* L */ + *iv_return = LDNS_RCODE_NOTIMPL; + return PERL_constant_ISIV; + } + break; + case 'N': + if (memEQ(name, "LDNS_MAX_DOMAINLE", 17)) { + /* N */ +#ifdef LDNS_MAX_DOMAINLEN + *iv_return = LDNS_MAX_DOMAINLEN; + return PERL_constant_ISIV; +#else + return PERL_constant_NOTDEF; +#endif + } + if (memEQ(name, "LDNS_MAX_PACKETLE", 17)) { + /* N */ +#ifdef LDNS_MAX_PACKETLEN + *iv_return = LDNS_MAX_PACKETLEN; + return PERL_constant_ISIV; +#else + return PERL_constant_NOTDEF; +#endif + } + break; + case 'O': + if (memEQ(name, "LDNS_RR_TYPE_HINF", 17)) { + /* O */ + *iv_return = LDNS_RR_TYPE_HINFO; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RR_TYPE_MINF", 17)) { + /* O */ + *iv_return = LDNS_RR_TYPE_MINFO; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RR_TYPE_UINF", 17)) { + /* O */ + *iv_return = LDNS_RR_TYPE_UINFO; + return PERL_constant_ISIV; + } + break; + case 'P': + if (memEQ(name, "LDNS_RDF_TYPE_NSA", 17)) { + /* P */ + *iv_return = LDNS_RDF_TYPE_NSAP; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RR_TYPE_SSHF", 17)) { + /* P */ + *iv_return = LDNS_RR_TYPE_SSHFP; + return PERL_constant_ISIV; + } + break; + case 'R': + if (memEQ(name, "LDNS_PACKET_ANSWE", 17)) { + /* R */ + *iv_return = LDNS_PACKET_ANSWER; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RCODE_FORMER", 17)) { + /* R */ + *iv_return = LDNS_RCODE_FORMERR; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RCODE_NOERRO", 17)) { + /* R */ + *iv_return = LDNS_RCODE_NOERROR; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RESOLV_ANCHO", 17)) { + /* R */ +#ifdef LDNS_RESOLV_ANCHOR + *iv_return = LDNS_RESOLV_ANCHOR; + return PERL_constant_ISIV; +#else + return PERL_constant_NOTDEF; +#endif + } + if (memEQ(name, "LDNS_RR_TYPE_NAPT", 17)) { + /* R */ + *iv_return = LDNS_RR_TYPE_NAPTR; + return PERL_constant_ISIV; + } + break; + case 'S': + if (memEQ(name, "LDNS_PACKET_STATU", 17)) { + /* S */ + *iv_return = LDNS_PACKET_STATUS; + return PERL_constant_ISIV; + } + break; + case 'T': + if (memEQ(name, "LDNS_RCODE_NXRRSE", 17)) { + /* T */ + *iv_return = LDNS_RCODE_NXRRSET; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RCODE_YXRRSE", 17)) { + /* T */ + *iv_return = LDNS_RCODE_YXRRSET; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RR_CLASS_LAS", 17)) { + /* T */ + *iv_return = LDNS_RR_CLASS_LAST; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RR_TYPE_COUN", 17)) { + /* T */ + *iv_return = LDNS_RR_TYPE_COUNT; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RR_TYPE_FIRS", 17)) { + /* T */ + *iv_return = LDNS_RR_TYPE_FIRST; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_SIGN_ECC_GOS", 17)) { + /* T */ + *iv_return = LDNS_SIGN_ECC_GOST; + return PERL_constant_ISIV; + } + break; + case 'Y': + if (memEQ(name, "LDNS_PACKET_IQUER", 17)) { + /* Y */ + *iv_return = LDNS_PACKET_IQUERY; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_PACKET_NOTIF", 17)) { + /* Y */ + *iv_return = LDNS_PACKET_NOTIFY; + return PERL_constant_ISIV; + } + break; + } + return PERL_constant_NOTFOUND; +} + +static int +constant_19 (pTHX_ const char *name, IV *iv_return) { + /* When generated this function returned values for the list of names given + here. However, subsequent manual editing may have added or removed some. + LDNS_KEY_REVOKE_KEY LDNS_PACKET_UNKNOWN LDNS_RCODE_NXDOMAIN + LDNS_RCODE_SERVFAIL LDNS_RCODE_YXDOMAIN LDNS_RDF_TYPE_CLASS + LDNS_RDF_TYPE_DNAME LDNS_RDF_TYPE_INT16 LDNS_RDF_TYPE_INT32 + LDNS_RESOLV_INETANY LDNS_RESOLV_KEYWORD LDNS_RESOLV_OPTIONS + LDNS_RESOLV_RTT_INF LDNS_RESOLV_RTT_MIN LDNS_RR_CLASS_COUNT + LDNS_RR_CLASS_FIRST LDNS_RR_NO_COMPRESS LDNS_RR_TYPE_DNSKEY + LDNS_RR_TYPE_NIMLOC LDNS_RR_TYPE_TALINK LDNS_RR_TYPE_UNSPEC + LDNS_SECTION_ANSWER LDNS_SIGN_DSA_NSEC3 LDNS_SIGN_RSASHA256 + LDNS_SIGN_RSASHA512 LDNS_STATUS_MEM_ERR LDNS_STATUS_NO_DATA + LDNS_STATUS_SSL_ERR */ + /* Offset 14 gives the best switch position. */ + switch (name[14]) { + case 'A': + if (memEQ(name, "LDNS_RR_TYPE_TALINK", 19)) { + /* ^ */ + *iv_return = LDNS_RR_TYPE_TALINK; + return PERL_constant_ISIV; + } + break; + case 'C': + if (memEQ(name, "LDNS_RDF_TYPE_CLASS", 19)) { + /* ^ */ + *iv_return = LDNS_RDF_TYPE_CLASS; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RR_CLASS_COUNT", 19)) { + /* ^ */ + *iv_return = LDNS_RR_CLASS_COUNT; + return PERL_constant_ISIV; + } + break; + case 'D': + if (memEQ(name, "LDNS_RDF_TYPE_DNAME", 19)) { + /* ^ */ + *iv_return = LDNS_RDF_TYPE_DNAME; + return PERL_constant_ISIV; + } + break; + case 'E': + if (memEQ(name, "LDNS_KEY_REVOKE_KEY", 19)) { + /* ^ */ +#ifdef LDNS_KEY_REVOKE_KEY + *iv_return = LDNS_KEY_REVOKE_KEY; + return PERL_constant_ISIV; +#else + return PERL_constant_NOTDEF; +#endif + } + if (memEQ(name, "LDNS_RESOLV_INETANY", 19)) { + /* ^ */ +#ifdef LDNS_RESOLV_INETANY + *iv_return = LDNS_RESOLV_INETANY; + return PERL_constant_ISIV; +#else + return PERL_constant_NOTDEF; +#endif + } + break; + case 'F': + if (memEQ(name, "LDNS_RR_CLASS_FIRST", 19)) { + /* ^ */ + *iv_return = LDNS_RR_CLASS_FIRST; + return PERL_constant_ISIV; + } + break; + case 'H': + if (memEQ(name, "LDNS_SIGN_RSASHA256", 19)) { + /* ^ */ + *iv_return = LDNS_SIGN_RSASHA256; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_SIGN_RSASHA512", 19)) { + /* ^ */ + *iv_return = LDNS_SIGN_RSASHA512; + return PERL_constant_ISIV; + } + break; + case 'I': + if (memEQ(name, "LDNS_RDF_TYPE_INT16", 19)) { + /* ^ */ + *iv_return = LDNS_RDF_TYPE_INT16; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RDF_TYPE_INT32", 19)) { + /* ^ */ + *iv_return = LDNS_RDF_TYPE_INT32; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RR_TYPE_NIMLOC", 19)) { + /* ^ */ + *iv_return = LDNS_RR_TYPE_NIMLOC; + return PERL_constant_ISIV; + } + break; + case 'K': + if (memEQ(name, "LDNS_PACKET_UNKNOWN", 19)) { + /* ^ */ + *iv_return = LDNS_PACKET_UNKNOWN; + return PERL_constant_ISIV; + } + break; + case 'L': + if (memEQ(name, "LDNS_STATUS_SSL_ERR", 19)) { + /* ^ */ + *iv_return = LDNS_STATUS_SSL_ERR; + return PERL_constant_ISIV; + } + break; + case 'M': + if (memEQ(name, "LDNS_STATUS_MEM_ERR", 19)) { + /* ^ */ + *iv_return = LDNS_STATUS_MEM_ERR; + return PERL_constant_ISIV; + } + break; + case 'N': + if (memEQ(name, "LDNS_RR_TYPE_DNSKEY", 19)) { + /* ^ */ + *iv_return = LDNS_RR_TYPE_DNSKEY; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RR_TYPE_UNSPEC", 19)) { + /* ^ */ + *iv_return = LDNS_RR_TYPE_UNSPEC; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_SECTION_ANSWER", 19)) { + /* ^ */ + *iv_return = LDNS_SECTION_ANSWER; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_SIGN_DSA_NSEC3", 19)) { + /* ^ */ + *iv_return = LDNS_SIGN_DSA_NSEC3; + return PERL_constant_ISIV; + } + break; + case 'O': + if (memEQ(name, "LDNS_RCODE_NXDOMAIN", 19)) { + /* ^ */ + *iv_return = LDNS_RCODE_NXDOMAIN; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RCODE_YXDOMAIN", 19)) { + /* ^ */ + *iv_return = LDNS_RCODE_YXDOMAIN; + return PERL_constant_ISIV; + } + break; + case 'P': + if (memEQ(name, "LDNS_RR_NO_COMPRESS", 19)) { + /* ^ */ + *iv_return = LDNS_RR_NO_COMPRESS; + return PERL_constant_ISIV; + } + break; + case 'T': + if (memEQ(name, "LDNS_RESOLV_OPTIONS", 19)) { + /* ^ */ +#ifdef LDNS_RESOLV_OPTIONS + *iv_return = LDNS_RESOLV_OPTIONS; + return PERL_constant_ISIV; +#else + return PERL_constant_NOTDEF; +#endif + } + if (memEQ(name, "LDNS_RESOLV_RTT_INF", 19)) { + /* ^ */ +#ifdef LDNS_RESOLV_RTT_INF + *iv_return = LDNS_RESOLV_RTT_INF; + return PERL_constant_ISIV; +#else + return PERL_constant_NOTDEF; +#endif + } + if (memEQ(name, "LDNS_RESOLV_RTT_MIN", 19)) { + /* ^ */ +#ifdef LDNS_RESOLV_RTT_MIN + *iv_return = LDNS_RESOLV_RTT_MIN; + return PERL_constant_ISIV; +#else + return PERL_constant_NOTDEF; +#endif + } + break; + case 'V': + if (memEQ(name, "LDNS_RCODE_SERVFAIL", 19)) { + /* ^ */ + *iv_return = LDNS_RCODE_SERVFAIL; + return PERL_constant_ISIV; + } + break; + case 'Y': + if (memEQ(name, "LDNS_RESOLV_KEYWORD", 19)) { + /* ^ */ +#ifdef LDNS_RESOLV_KEYWORD + *iv_return = LDNS_RESOLV_KEYWORD; + return PERL_constant_ISIV; +#else + return PERL_constant_NOTDEF; +#endif + } + break; + case '_': + if (memEQ(name, "LDNS_STATUS_NO_DATA", 19)) { + /* ^ */ + *iv_return = LDNS_STATUS_NO_DATA; + return PERL_constant_ISIV; + } + break; + } + return PERL_constant_NOTFOUND; +} + +static int +constant_20 (pTHX_ const char *name, IV *iv_return) { + /* When generated this function returned values for the list of names given + here. However, subsequent manual editing may have added or removed some. + LDNS_ECDSAP384SHA384 LDNS_PACKET_NXDOMAIN LDNS_PACKET_QUESTION + LDNS_PACKET_REFERRAL LDNS_RDF_SIZE_6BYTES LDNS_RDF_TYPE_PERIOD + LDNS_RESOLV_KEYWORDS LDNS_RESOLV_SORTLIST LDNS_SIGN_HMACSHA256 + LDNS_STATUS_FILE_ERR LDNS_STATUS_NOT_IMPL */ + /* Offset 18 gives the best switch position. */ + switch (name[18]) { + case '5': + if (memEQ(name, "LDNS_SIGN_HMACSHA256", 20)) { + /* ^ */ + *iv_return = LDNS_SIGN_HMACSHA256; + return PERL_constant_ISIV; + } + break; + case '8': + if (memEQ(name, "LDNS_ECDSAP384SHA384", 20)) { + /* ^ */ + *iv_return = LDNS_ECDSAP384SHA384; + return PERL_constant_ISIV; + } + break; + case 'A': + if (memEQ(name, "LDNS_PACKET_REFERRAL", 20)) { + /* ^ */ + *iv_return = LDNS_PACKET_REFERRAL; + return PERL_constant_ISIV; + } + break; + case 'D': + if (memEQ(name, "LDNS_RESOLV_KEYWORDS", 20)) { + /* ^ */ +#ifdef LDNS_RESOLV_KEYWORDS + *iv_return = LDNS_RESOLV_KEYWORDS; + return PERL_constant_ISIV; +#else + return PERL_constant_NOTDEF; +#endif + } + break; + case 'E': + if (memEQ(name, "LDNS_RDF_SIZE_6BYTES", 20)) { + /* ^ */ +#ifdef LDNS_RDF_SIZE_6BYTES + *iv_return = LDNS_RDF_SIZE_6BYTES; + return PERL_constant_ISIV; +#else + return PERL_constant_NOTDEF; +#endif + } + break; + case 'I': + if (memEQ(name, "LDNS_PACKET_NXDOMAIN", 20)) { + /* ^ */ + *iv_return = LDNS_PACKET_NXDOMAIN; + return PERL_constant_ISIV; + } + break; + case 'O': + if (memEQ(name, "LDNS_PACKET_QUESTION", 20)) { + /* ^ */ + *iv_return = LDNS_PACKET_QUESTION; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_RDF_TYPE_PERIOD", 20)) { + /* ^ */ + *iv_return = LDNS_RDF_TYPE_PERIOD; + return PERL_constant_ISIV; + } + break; + case 'P': + if (memEQ(name, "LDNS_STATUS_NOT_IMPL", 20)) { + /* ^ */ + *iv_return = LDNS_STATUS_NOT_IMPL; + return PERL_constant_ISIV; + } + break; + case 'R': + if (memEQ(name, "LDNS_STATUS_FILE_ERR", 20)) { + /* ^ */ + *iv_return = LDNS_STATUS_FILE_ERR; + return PERL_constant_ISIV; + } + break; + case 'S': + if (memEQ(name, "LDNS_RESOLV_SORTLIST", 20)) { + /* ^ */ +#ifdef LDNS_RESOLV_SORTLIST + *iv_return = LDNS_RESOLV_SORTLIST; + return PERL_constant_ISIV; +#else + return PERL_constant_NOTDEF; +#endif + } + break; + } + return PERL_constant_NOTFOUND; +} + +static int +constant_21 (pTHX_ const char *name, IV *iv_return) { + /* When generated this function returned values for the list of names given + here. However, subsequent manual editing may have added or removed some. + LDNS_RDF_SIZE_16BYTES LDNS_RDF_TYPE_B32_EXT LDNS_RDF_TYPE_SERVICE + LDNS_RDF_TYPE_UNKNOWN LDNS_RESOLV_DEFDOMAIN LDNS_RR_TYPE_IPSECKEY + LDNS_RR_TYPE_NSAP_PTR LDNS_SECTION_QUESTION LDNS_STATUS_NSEC3_ERR + LDNS_STATUS_RES_NO_NS LDNS_STATUS_RES_QUERY */ + /* Offset 16 gives the best switch position. */ + switch (name[16]) { + case '2': + if (memEQ(name, "LDNS_RDF_TYPE_B32_EXT", 21)) { + /* ^ */ + *iv_return = LDNS_RDF_TYPE_B32_EXT; + return PERL_constant_ISIV; + } + break; + case '3': + if (memEQ(name, "LDNS_STATUS_NSEC3_ERR", 21)) { + /* ^ */ + *iv_return = LDNS_STATUS_NSEC3_ERR; + return PERL_constant_ISIV; + } + break; + case 'B': + if (memEQ(name, "LDNS_RDF_SIZE_16BYTES", 21)) { + /* ^ */ +#ifdef LDNS_RDF_SIZE_16BYTES + *iv_return = LDNS_RDF_SIZE_16BYTES; + return PERL_constant_ISIV; +#else + return PERL_constant_NOTDEF; +#endif + } + break; + case 'E': + if (memEQ(name, "LDNS_RR_TYPE_IPSECKEY", 21)) { + /* ^ */ + *iv_return = LDNS_RR_TYPE_IPSECKEY; + return PERL_constant_ISIV; + } + break; + case 'K': + if (memEQ(name, "LDNS_RDF_TYPE_UNKNOWN", 21)) { + /* ^ */ + *iv_return = LDNS_RDF_TYPE_UNKNOWN; + return PERL_constant_ISIV; + } + break; + case 'N': + if (memEQ(name, "LDNS_STATUS_RES_NO_NS", 21)) { + /* ^ */ + *iv_return = LDNS_STATUS_RES_NO_NS; + return PERL_constant_ISIV; + } + break; + case 'O': + if (memEQ(name, "LDNS_RESOLV_DEFDOMAIN", 21)) { + /* ^ */ +#ifdef LDNS_RESOLV_DEFDOMAIN + *iv_return = LDNS_RESOLV_DEFDOMAIN; + return PERL_constant_ISIV; +#else + return PERL_constant_NOTDEF; +#endif + } + break; + case 'P': + if (memEQ(name, "LDNS_RR_TYPE_NSAP_PTR", 21)) { + /* ^ */ + *iv_return = LDNS_RR_TYPE_NSAP_PTR; + return PERL_constant_ISIV; + } + break; + case 'Q': + if (memEQ(name, "LDNS_STATUS_RES_QUERY", 21)) { + /* ^ */ + *iv_return = LDNS_STATUS_RES_QUERY; + return PERL_constant_ISIV; + } + break; + case 'R': + if (memEQ(name, "LDNS_RDF_TYPE_SERVICE", 21)) { + /* ^ */ + *iv_return = LDNS_RDF_TYPE_SERVICE; + return PERL_constant_ISIV; + } + break; + case 'S': + if (memEQ(name, "LDNS_SECTION_QUESTION", 21)) { + /* ^ */ + *iv_return = LDNS_SECTION_QUESTION; + return PERL_constant_ISIV; + } + break; + } + return PERL_constant_NOTFOUND; +} + +static int +constant_22 (pTHX_ const char *name, IV *iv_return) { + /* When generated this function returned values for the list of names given + here. However, subsequent manual editing may have added or removed some. + LDNS_RDF_TYPE_CERT_ALG LDNS_RDF_TYPE_IPSECKEY LDNS_RDF_TYPE_TSIGTIME + LDNS_RESOLV_NAMESERVER LDNS_SECTION_AUTHORITY LDNS_STATUS_SYNTAX_ERR + LDNS_STATUS_SYNTAX_TTL */ + /* Offset 14 gives the best switch position. */ + switch (name[14]) { + case 'C': + if (memEQ(name, "LDNS_RDF_TYPE_CERT_ALG", 22)) { + /* ^ */ + *iv_return = LDNS_RDF_TYPE_CERT_ALG; + return PERL_constant_ISIV; + } + break; + case 'I': + if (memEQ(name, "LDNS_RDF_TYPE_IPSECKEY", 22)) { + /* ^ */ + *iv_return = LDNS_RDF_TYPE_IPSECKEY; + return PERL_constant_ISIV; + } + break; + case 'M': + if (memEQ(name, "LDNS_RESOLV_NAMESERVER", 22)) { + /* ^ */ +#ifdef LDNS_RESOLV_NAMESERVER + *iv_return = LDNS_RESOLV_NAMESERVER; + return PERL_constant_ISIV; +#else + return PERL_constant_NOTDEF; +#endif + } + break; + case 'N': + if (memEQ(name, "LDNS_STATUS_SYNTAX_ERR", 22)) { + /* ^ */ + *iv_return = LDNS_STATUS_SYNTAX_ERR; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_STATUS_SYNTAX_TTL", 22)) { + /* ^ */ + *iv_return = LDNS_STATUS_SYNTAX_TTL; + return PERL_constant_ISIV; + } + break; + case 'T': + if (memEQ(name, "LDNS_RDF_TYPE_TSIGTIME", 22)) { + /* ^ */ + *iv_return = LDNS_RDF_TYPE_TSIGTIME; + return PERL_constant_ISIV; + } + break; + case 'U': + if (memEQ(name, "LDNS_SECTION_AUTHORITY", 22)) { + /* ^ */ + *iv_return = LDNS_SECTION_AUTHORITY; + return PERL_constant_ISIV; + } + break; + } + return PERL_constant_NOTFOUND; +} + +static int +constant_23 (pTHX_ const char *name, IV *iv_return) { + /* When generated this function returned values for the list of names given + here. However, subsequent manual editing may have added or removed some. + LDNS_RR_TYPE_NSEC3PARAM LDNS_SECTION_ADDITIONAL LDNS_SIGN_RSASHA1_NSEC3 + LDNS_STATUS_ADDRESS_ERR LDNS_STATUS_EMPTY_LABEL LDNS_STATUS_INVALID_B64 + LDNS_STATUS_INVALID_HEX LDNS_STATUS_INVALID_INT LDNS_STATUS_INVALID_IP4 + LDNS_STATUS_INVALID_IP6 LDNS_STATUS_INVALID_STR LDNS_STATUS_NETWORK_ERR */ + /* Offset 21 gives the best switch position. */ + switch (name[21]) { + case '6': + if (memEQ(name, "LDNS_STATUS_INVALID_B64", 23)) { + /* ^ */ + *iv_return = LDNS_STATUS_INVALID_B64; + return PERL_constant_ISIV; + } + break; + case 'A': + if (memEQ(name, "LDNS_RR_TYPE_NSEC3PARAM", 23)) { + /* ^ */ + *iv_return = LDNS_RR_TYPE_NSEC3PARAM; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_SECTION_ADDITIONAL", 23)) { + /* ^ */ + *iv_return = LDNS_SECTION_ADDITIONAL; + return PERL_constant_ISIV; + } + break; + case 'C': + if (memEQ(name, "LDNS_SIGN_RSASHA1_NSEC3", 23)) { + /* ^ */ + *iv_return = LDNS_SIGN_RSASHA1_NSEC3; + return PERL_constant_ISIV; + } + break; + case 'E': + if (memEQ(name, "LDNS_STATUS_EMPTY_LABEL", 23)) { + /* ^ */ + *iv_return = LDNS_STATUS_EMPTY_LABEL; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_STATUS_INVALID_HEX", 23)) { + /* ^ */ + *iv_return = LDNS_STATUS_INVALID_HEX; + return PERL_constant_ISIV; + } + break; + case 'N': + if (memEQ(name, "LDNS_STATUS_INVALID_INT", 23)) { + /* ^ */ + *iv_return = LDNS_STATUS_INVALID_INT; + return PERL_constant_ISIV; + } + break; + case 'P': + if (memEQ(name, "LDNS_STATUS_INVALID_IP4", 23)) { + /* ^ */ + *iv_return = LDNS_STATUS_INVALID_IP4; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_STATUS_INVALID_IP6", 23)) { + /* ^ */ + *iv_return = LDNS_STATUS_INVALID_IP6; + return PERL_constant_ISIV; + } + break; + case 'R': + if (memEQ(name, "LDNS_STATUS_ADDRESS_ERR", 23)) { + /* ^ */ + *iv_return = LDNS_STATUS_ADDRESS_ERR; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_STATUS_NETWORK_ERR", 23)) { + /* ^ */ + *iv_return = LDNS_STATUS_NETWORK_ERR; + return PERL_constant_ISIV; + } + break; + case 'T': + if (memEQ(name, "LDNS_STATUS_INVALID_STR", 23)) { + /* ^ */ + *iv_return = LDNS_STATUS_INVALID_STR; + return PERL_constant_ISIV; + } + break; + } + return PERL_constant_NOTFOUND; +} + +static int +constant_24 (pTHX_ const char *name, IV *iv_return) { + /* When generated this function returned values for the list of names given + here. However, subsequent manual editing may have added or removed some. + LDNS_RDF_SIZE_DOUBLEWORD LDNS_RDF_TYPE_INT16_DATA LDNS_RDF_TYPE_NSEC3_SALT + LDNS_RR_TYPE_NSEC3PARAMS LDNS_STATUS_CRYPTO_BOGUS LDNS_STATUS_CRYPTO_NO_DS + LDNS_STATUS_DDD_OVERFLOW LDNS_STATUS_INTERNAL_ERR LDNS_STATUS_INVALID_TIME + LDNS_STATUS_SOCKET_ERROR LDNS_STATUS_SYNTAX_EMPTY LDNS_STATUS_UNKNOWN_INET + */ + /* Offset 17 gives the best switch position. */ + switch (name[17]) { + case '1': + if (memEQ(name, "LDNS_RDF_TYPE_INT16_DATA", 24)) { + /* ^ */ + *iv_return = LDNS_RDF_TYPE_INT16_DATA; + return PERL_constant_ISIV; + } + break; + case '3': + if (memEQ(name, "LDNS_RR_TYPE_NSEC3PARAMS", 24)) { + /* ^ */ + *iv_return = LDNS_RR_TYPE_NSEC3PARAMS; + return PERL_constant_ISIV; + } + break; + case 'B': + if (memEQ(name, "LDNS_RDF_SIZE_DOUBLEWORD", 24)) { + /* ^ */ +#ifdef LDNS_RDF_SIZE_DOUBLEWORD + *iv_return = LDNS_RDF_SIZE_DOUBLEWORD; + return PERL_constant_ISIV; +#else + return PERL_constant_NOTDEF; +#endif + } + break; + case 'C': + if (memEQ(name, "LDNS_RDF_TYPE_NSEC3_SALT", 24)) { + /* ^ */ + *iv_return = LDNS_RDF_TYPE_NSEC3_SALT; + return PERL_constant_ISIV; + } + break; + case 'I': + if (memEQ(name, "LDNS_STATUS_INVALID_TIME", 24)) { + /* ^ */ + *iv_return = LDNS_STATUS_INVALID_TIME; + return PERL_constant_ISIV; + } + break; + case 'N': + if (memEQ(name, "LDNS_STATUS_INTERNAL_ERR", 24)) { + /* ^ */ + *iv_return = LDNS_STATUS_INTERNAL_ERR; + return PERL_constant_ISIV; + } + break; + case 'O': + if (memEQ(name, "LDNS_STATUS_CRYPTO_BOGUS", 24)) { + /* ^ */ + *iv_return = LDNS_STATUS_CRYPTO_BOGUS; + return PERL_constant_ISIV; + } + if (memEQ(name, "LDNS_STATUS_CRYPTO_NO_DS", 24)) { + /* ^ */ + *iv_return = LDNS_STATUS_CRYPTO_NO_DS; + return PERL_constant_ISIV; + } + break; + case 'T': + if (memEQ(name, "LDNS_STATUS_SOCKET_ERROR", 24)) { + /* ^ */ + *iv_return = LDNS_STATUS_SOCKET_ERROR; + return PERL_constant_ISIV; + } + break; + case 'V': + if (memEQ(name, "LDNS_STATUS_DDD_OVERFLOW", 24)) { + /* ^ */ + *iv_return = LDNS_STATUS_DDD_OVERFLOW; + return PERL_constant_ISIV; + } + break; + case 'W': + if (memEQ(name, "LDNS_STATUS_UNKNOWN_INET", 24)) { + /* ^ */ + *iv_return = LDNS_STATUS_UNKNOWN_INET; + return PERL_constant_ISIV; + } + break; + case 'X': + if (memEQ(name, "LDNS_STATUS_SYNTAX_EMPTY", 24)) { + /* ^ */ + *iv_return = LDNS_STATUS_SYNTAX_EMPTY; + return PERL_constant_ISIV; + } + break; + } + return PERL_constant_NOTFOUND; +} + +static int +constant_26 (pTHX_ const char *name, IV *iv_return) { + /* When generated this function returned values for the list of names given + here. However, subsequent manual editing may have added or removed some. + LDNS_STATUS_LABEL_OVERFLOW LDNS_STATUS_SYNTAX_ALG_ERR + LDNS_STATUS_SYNTAX_INCLUDE LDNS_STATUS_SYNTAX_TTL_ERR */ + /* Offset 20 gives the best switch position. */ + switch (name[20]) { + case 'E': + if (memEQ(name, "LDNS_STATUS_LABEL_OVERFLOW", 26)) { + /* ^ */ + *iv_return = LDNS_STATUS_LABEL_OVERFLOW; + return PERL_constant_ISIV; + } + break; + case 'L': + if (memEQ(name, "LDNS_STATUS_SYNTAX_ALG_ERR", 26)) { + /* ^ */ + *iv_return = LDNS_STATUS_SYNTAX_ALG_ERR; + return PERL_constant_ISIV; + } + break; + case 'N': + if (memEQ(name, "LDNS_STATUS_SYNTAX_INCLUDE", 26)) { + /* ^ */ + *iv_return = LDNS_STATUS_SYNTAX_INCLUDE; + return PERL_constant_ISIV; + } + break; + case 'T': + if (memEQ(name, "LDNS_STATUS_SYNTAX_TTL_ERR", 26)) { + /* ^ */ + *iv_return = LDNS_STATUS_SYNTAX_TTL_ERR; + return PERL_constant_ISIV; + } + break; + } + return PERL_constant_NOTFOUND; +} + +static int +constant_27 (pTHX_ const char *name, IV *iv_return) { + /* When generated this function returned values for the list of names given + here. However, subsequent manual editing may have added or removed some. + LDNS_NSEC3_VARS_OPTOUT_MASK LDNS_SECTION_ANY_NOQUESTION + LDNS_STATUS_CRYPTO_NO_RRSIG LDNS_STATUS_CRYPTO_TSIG_ERR + LDNS_STATUS_INVALID_B32_EXT LDNS_STATUS_INVALID_POINTER + LDNS_STATUS_PACKET_OVERFLOW LDNS_STATUS_SYNTAX_TYPE_ERR */ + /* Offset 20 gives the best switch position. */ + switch (name[20]) { + case 'B': + if (memEQ(name, "LDNS_STATUS_INVALID_B32_EXT", 27)) { + /* ^ */ + *iv_return = LDNS_STATUS_INVALID_B32_EXT; + return PERL_constant_ISIV; + } + break; + case 'O': + if (memEQ(name, "LDNS_STATUS_CRYPTO_NO_RRSIG", 27)) { + /* ^ */ + *iv_return = LDNS_STATUS_CRYPTO_NO_RRSIG; + return PERL_constant_ISIV; + } + break; + case 'P': + if (memEQ(name, "LDNS_STATUS_INVALID_POINTER", 27)) { + /* ^ */ + *iv_return = LDNS_STATUS_INVALID_POINTER; + return PERL_constant_ISIV; + } + break; + case 'S': + if (memEQ(name, "LDNS_STATUS_CRYPTO_TSIG_ERR", 27)) { + /* ^ */ + *iv_return = LDNS_STATUS_CRYPTO_TSIG_ERR; + return PERL_constant_ISIV; + } + break; + case 'U': + if (memEQ(name, "LDNS_NSEC3_VARS_OPTOUT_MASK", 27)) { + /* ^ */ +#ifdef LDNS_NSEC3_VARS_OPTOUT_MASK + *iv_return = LDNS_NSEC3_VARS_OPTOUT_MASK; + return PERL_constant_ISIV; +#else + return PERL_constant_NOTDEF; +#endif + } + if (memEQ(name, "LDNS_SECTION_ANY_NOQUESTION", 27)) { + /* ^ */ + *iv_return = LDNS_SECTION_ANY_NOQUESTION; + return PERL_constant_ISIV; + } + break; + case 'V': + if (memEQ(name, "LDNS_STATUS_PACKET_OVERFLOW", 27)) { + /* ^ */ + *iv_return = LDNS_STATUS_PACKET_OVERFLOW; + return PERL_constant_ISIV; + } + break; + case 'Y': + if (memEQ(name, "LDNS_STATUS_SYNTAX_TYPE_ERR", 27)) { + /* ^ */ + *iv_return = LDNS_STATUS_SYNTAX_TYPE_ERR; + return PERL_constant_ISIV; + } + break; + } + return PERL_constant_NOTFOUND; +} + +static int +constant_28 (pTHX_ const char *name, IV *iv_return) { + /* When generated this function returned values for the list of names given + here. However, subsequent manual editing may have added or removed some. + LDNS_STATUS_CRYPTO_NO_DNSKEY LDNS_STATUS_CRYPTO_VALIDATED + LDNS_STATUS_SYNTAX_CLASS_ERR LDNS_STATUS_SYNTAX_DNAME_ERR + LDNS_STATUS_SYNTAX_RDATA_ERR */ + /* Offset 20 gives the best switch position. */ + switch (name[20]) { + case 'A': + if (memEQ(name, "LDNS_STATUS_CRYPTO_VALIDATED", 28)) { + /* ^ */ + *iv_return = LDNS_STATUS_CRYPTO_VALIDATED; + return PERL_constant_ISIV; + } + break; + case 'D': + if (memEQ(name, "LDNS_STATUS_SYNTAX_RDATA_ERR", 28)) { + /* ^ */ + *iv_return = LDNS_STATUS_SYNTAX_RDATA_ERR; + return PERL_constant_ISIV; + } + break; + case 'L': + if (memEQ(name, "LDNS_STATUS_SYNTAX_CLASS_ERR", 28)) { + /* ^ */ + *iv_return = LDNS_STATUS_SYNTAX_CLASS_ERR; + return PERL_constant_ISIV; + } + break; + case 'N': + if (memEQ(name, "LDNS_STATUS_SYNTAX_DNAME_ERR", 28)) { + /* ^ */ + *iv_return = LDNS_STATUS_SYNTAX_DNAME_ERR; + return PERL_constant_ISIV; + } + break; + case 'O': + if (memEQ(name, "LDNS_STATUS_CRYPTO_NO_DNSKEY", 28)) { + /* ^ */ + *iv_return = LDNS_STATUS_CRYPTO_NO_DNSKEY; + return PERL_constant_ISIV; + } + break; + } + return PERL_constant_NOTFOUND; +} + +static int +constant_30 (pTHX_ const char *name, IV *iv_return) { + /* When generated this function returned values for the list of names given + here. However, subsequent manual editing may have added or removed some. + LDNS_RDF_TYPE_NSEC3_NEXT_OWNER LDNS_STATUS_CERT_BAD_ALGORITHM + LDNS_STATUS_CRYPTO_SIG_EXPIRED LDNS_STATUS_SYNTAX_KEYWORD_ERR + LDNS_STATUS_SYNTAX_VERSION_ERR */ + /* Offset 25 gives the best switch position. */ + switch (name[25]) { + case 'D': + if (memEQ(name, "LDNS_STATUS_SYNTAX_KEYWORD_ERR", 30)) { + /* ^ */ + *iv_return = LDNS_STATUS_SYNTAX_KEYWORD_ERR; + return PERL_constant_ISIV; + } + break; + case 'N': + if (memEQ(name, "LDNS_STATUS_SYNTAX_VERSION_ERR", 30)) { + /* ^ */ + *iv_return = LDNS_STATUS_SYNTAX_VERSION_ERR; + return PERL_constant_ISIV; + } + break; + case 'O': + if (memEQ(name, "LDNS_RDF_TYPE_NSEC3_NEXT_OWNER", 30)) { + /* ^ */ + *iv_return = LDNS_RDF_TYPE_NSEC3_NEXT_OWNER; + return PERL_constant_ISIV; + } + break; + case 'P': + if (memEQ(name, "LDNS_STATUS_CRYPTO_SIG_EXPIRED", 30)) { + /* ^ */ + *iv_return = LDNS_STATUS_CRYPTO_SIG_EXPIRED; + return PERL_constant_ISIV; + } + break; + case 'R': + if (memEQ(name, "LDNS_STATUS_CERT_BAD_ALGORITHM", 30)) { + /* ^ */ + *iv_return = LDNS_STATUS_CERT_BAD_ALGORITHM; + return PERL_constant_ISIV; + } + break; + } + return PERL_constant_NOTFOUND; +} + +static int +constant_32 (pTHX_ const char *name, IV *iv_return) { + /* When generated this function returned values for the list of names given + here. However, subsequent manual editing may have added or removed some. + LDNS_STATUS_CRYPTO_ALGO_NOT_IMPL LDNS_STATUS_CRYPTO_NO_TRUSTED_DS + LDNS_STATUS_DOMAINNAME_UNDERFLOW */ + /* Offset 20 gives the best switch position. */ + switch (name[20]) { + case 'L': + if (memEQ(name, "LDNS_STATUS_CRYPTO_ALGO_NOT_IMPL", 32)) { + /* ^ */ + *iv_return = LDNS_STATUS_CRYPTO_ALGO_NOT_IMPL; + return PERL_constant_ISIV; + } + break; + case 'M': + if (memEQ(name, "LDNS_STATUS_DOMAINNAME_UNDERFLOW", 32)) { + /* ^ */ + *iv_return = LDNS_STATUS_DOMAINNAME_UNDERFLOW; + return PERL_constant_ISIV; + } + break; + case 'O': + if (memEQ(name, "LDNS_STATUS_CRYPTO_NO_TRUSTED_DS", 32)) { + /* ^ */ + *iv_return = LDNS_STATUS_CRYPTO_NO_TRUSTED_DS; + return PERL_constant_ISIV; + } + break; + } + return PERL_constant_NOTFOUND; +} + +static int +constant_35 (pTHX_ const char *name, IV *iv_return) { + /* When generated this function returned values for the list of names given + here. However, subsequent manual editing may have added or removed some. + LDNS_RDATA_FIELD_DESCRIPTORS_COMMON LDNS_STATUS_CRYPTO_SIG_NOT_INCEPTED + LDNS_STATUS_CRYPTO_TYPE_COVERED_ERR LDNS_STATUS_DNSSEC_EXISTENCE_DENIED + LDNS_STATUS_SYNTAX_INTEGER_OVERFLOW */ + /* Offset 21 gives the best switch position. */ + switch (name[21]) { + case 'G': + if (memEQ(name, "LDNS_STATUS_CRYPTO_SIG_NOT_INCEPTED", 35)) { + /* ^ */ + *iv_return = LDNS_STATUS_CRYPTO_SIG_NOT_INCEPTED; + return PERL_constant_ISIV; + } + break; + case 'I': + if (memEQ(name, "LDNS_STATUS_DNSSEC_EXISTENCE_DENIED", 35)) { + /* ^ */ + *iv_return = LDNS_STATUS_DNSSEC_EXISTENCE_DENIED; + return PERL_constant_ISIV; + } + break; + case 'P': + if (memEQ(name, "LDNS_STATUS_CRYPTO_TYPE_COVERED_ERR", 35)) { + /* ^ */ + *iv_return = LDNS_STATUS_CRYPTO_TYPE_COVERED_ERR; + return PERL_constant_ISIV; + } + break; + case 'R': + if (memEQ(name, "LDNS_RDATA_FIELD_DESCRIPTORS_COMMON", 35)) { + /* ^ */ +#ifdef LDNS_RDATA_FIELD_DESCRIPTORS_COMMON + *iv_return = LDNS_RDATA_FIELD_DESCRIPTORS_COMMON; + return PERL_constant_ISIV; +#else + return PERL_constant_NOTDEF; +#endif + } + break; + case 'T': + if (memEQ(name, "LDNS_STATUS_SYNTAX_INTEGER_OVERFLOW", 35)) { + /* ^ */ + *iv_return = LDNS_STATUS_SYNTAX_INTEGER_OVERFLOW; + return PERL_constant_ISIV; + } + break; + } + return PERL_constant_NOTFOUND; +} + +static int +constant_36 (pTHX_ const char *name, IV *iv_return) { + /* When generated this function returned values for the list of names given + here. However, subsequent manual editing may have added or removed some. + LDNS_STATUS_CRYPTO_NO_TRUSTED_DNSKEY LDNS_STATUS_MISSING_RDATA_FIELDS_KEY + LDNS_STATUS_SYNTAX_MISSING_VALUE_ERR LDNS_STATUS_WIRE_INCOMPLETE_QUESTION + */ + /* Offset 14 gives the best switch position. */ + switch (name[14]) { + case 'N': + if (memEQ(name, "LDNS_STATUS_SYNTAX_MISSING_VALUE_ERR", 36)) { + /* ^ */ + *iv_return = LDNS_STATUS_SYNTAX_MISSING_VALUE_ERR; + return PERL_constant_ISIV; + } + break; + case 'R': + if (memEQ(name, "LDNS_STATUS_WIRE_INCOMPLETE_QUESTION", 36)) { + /* ^ */ + *iv_return = LDNS_STATUS_WIRE_INCOMPLETE_QUESTION; + return PERL_constant_ISIV; + } + break; + case 'S': + if (memEQ(name, "LDNS_STATUS_MISSING_RDATA_FIELDS_KEY", 36)) { + /* ^ */ + *iv_return = LDNS_STATUS_MISSING_RDATA_FIELDS_KEY; + return PERL_constant_ISIV; + } + break; + case 'Y': + if (memEQ(name, "LDNS_STATUS_CRYPTO_NO_TRUSTED_DNSKEY", 36)) { + /* ^ */ + *iv_return = LDNS_STATUS_CRYPTO_NO_TRUSTED_DNSKEY; + return PERL_constant_ISIV; + } + break; + } + return PERL_constant_NOTFOUND; +} + +static int +constant_38 (pTHX_ const char *name, IV *iv_return) { + /* When generated this function returned values for the list of names given + here. However, subsequent manual editing may have added or removed some. + LDNS_STATUS_DNSSEC_NSEC_RR_NOT_COVERED + LDNS_STATUS_MISSING_RDATA_FIELDS_RRSIG + LDNS_STATUS_SYNTAX_INCLUDE_ERR_NOTIMPL + LDNS_STATUS_SYNTAX_ITERATIONS_OVERFLOW + LDNS_STATUS_WIRE_INCOMPLETE_ADDITIONAL */ + /* Offset 20 gives the best switch position. */ + switch (name[20]) { + case 'N': + if (memEQ(name, "LDNS_STATUS_SYNTAX_INCLUDE_ERR_NOTIMPL", 38)) { + /* ^ */ + *iv_return = LDNS_STATUS_SYNTAX_INCLUDE_ERR_NOTIMPL; + return PERL_constant_ISIV; + } + break; + case 'O': + if (memEQ(name, "LDNS_STATUS_WIRE_INCOMPLETE_ADDITIONAL", 38)) { + /* ^ */ + *iv_return = LDNS_STATUS_WIRE_INCOMPLETE_ADDITIONAL; + return PERL_constant_ISIV; + } + break; + case 'R': + if (memEQ(name, "LDNS_STATUS_MISSING_RDATA_FIELDS_RRSIG", 38)) { + /* ^ */ + *iv_return = LDNS_STATUS_MISSING_RDATA_FIELDS_RRSIG; + return PERL_constant_ISIV; + } + break; + case 'S': + if (memEQ(name, "LDNS_STATUS_DNSSEC_NSEC_RR_NOT_COVERED", 38)) { + /* ^ */ + *iv_return = LDNS_STATUS_DNSSEC_NSEC_RR_NOT_COVERED; + return PERL_constant_ISIV; + } + break; + case 'T': + if (memEQ(name, "LDNS_STATUS_SYNTAX_ITERATIONS_OVERFLOW", 38)) { + /* ^ */ + *iv_return = LDNS_STATUS_SYNTAX_ITERATIONS_OVERFLOW; + return PERL_constant_ISIV; + } + break; + } + return PERL_constant_NOTFOUND; +} + +static int +constant (pTHX_ const char *name, STRLEN len, IV *iv_return) { + /* Initially switch on the length of the name. */ + /* When generated this function returned values for the list of names given + in this section of perl code. Rather than manually editing these functions + to add or remove constants, which would result in this comment and section + of code becoming inaccurate, we recommend that you edit this section of + code, and use it to regenerate a new set of constant functions which you + then use to replace the originals. + + Regenerate these constant functions by feeding this entire source file to + perl -x + +#!/usr/bin/perl -w +use ExtUtils::Constant qw (constant_types C_constant XS_constant); + +my $types = {map {($_, 1)} qw(IV)}; +my @names = (qw(LDNS_AA LDNS_AD LDNS_CD LDNS_DEFAULT_TTL 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_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_TC), + {name=>"LDNS_CERT_ACPKIX", type=>"IV", macro=>"1"}, + {name=>"LDNS_CERT_IACPKIX", type=>"IV", macro=>"1"}, + {name=>"LDNS_CERT_IPGP", type=>"IV", macro=>"1"}, + {name=>"LDNS_CERT_IPKIX", type=>"IV", macro=>"1"}, + {name=>"LDNS_CERT_ISPKI", type=>"IV", macro=>"1"}, + {name=>"LDNS_CERT_OID", type=>"IV", macro=>"1"}, + {name=>"LDNS_CERT_PGP", type=>"IV", macro=>"1"}, + {name=>"LDNS_CERT_PKIX", type=>"IV", macro=>"1"}, + {name=>"LDNS_CERT_SPKI", type=>"IV", macro=>"1"}, + {name=>"LDNS_CERT_URI", type=>"IV", macro=>"1"}, + {name=>"LDNS_DH", type=>"IV", macro=>"1"}, + {name=>"LDNS_DSA", type=>"IV", macro=>"1"}, + {name=>"LDNS_DSA_NSEC3", type=>"IV", macro=>"1"}, + {name=>"LDNS_ECC", type=>"IV", macro=>"1"}, + {name=>"LDNS_ECC_GOST", type=>"IV", macro=>"1"}, + {name=>"LDNS_ECDSAP384SHA384", type=>"IV", macro=>"1"}, + {name=>"LDNS_HASH_GOST", type=>"IV", macro=>"1"}, + {name=>"LDNS_PACKET_ANSWER", type=>"IV", macro=>"1"}, + {name=>"LDNS_PACKET_IQUERY", type=>"IV", macro=>"1"}, + {name=>"LDNS_PACKET_NODATA", type=>"IV", macro=>"1"}, + {name=>"LDNS_PACKET_NOTIFY", type=>"IV", macro=>"1"}, + {name=>"LDNS_PACKET_NXDOMAIN", type=>"IV", macro=>"1"}, + {name=>"LDNS_PACKET_QUERY", type=>"IV", macro=>"1"}, + {name=>"LDNS_PACKET_QUESTION", type=>"IV", macro=>"1"}, + {name=>"LDNS_PACKET_REFERRAL", type=>"IV", macro=>"1"}, + {name=>"LDNS_PACKET_STATUS", type=>"IV", macro=>"1"}, + {name=>"LDNS_PACKET_UNKNOWN", type=>"IV", macro=>"1"}, + {name=>"LDNS_PACKET_UPDATE", type=>"IV", macro=>"1"}, + {name=>"LDNS_PRIVATEDNS", type=>"IV", macro=>"1"}, + {name=>"LDNS_PRIVATEOID", type=>"IV", macro=>"1"}, + {name=>"LDNS_RCODE_FORMERR", type=>"IV", macro=>"1"}, + {name=>"LDNS_RCODE_NOERROR", type=>"IV", macro=>"1"}, + {name=>"LDNS_RCODE_NOTAUTH", type=>"IV", macro=>"1"}, + {name=>"LDNS_RCODE_NOTIMPL", type=>"IV", macro=>"1"}, + {name=>"LDNS_RCODE_NOTZONE", type=>"IV", macro=>"1"}, + {name=>"LDNS_RCODE_NXDOMAIN", type=>"IV", macro=>"1"}, + {name=>"LDNS_RCODE_NXRRSET", type=>"IV", macro=>"1"}, + {name=>"LDNS_RCODE_REFUSED", type=>"IV", macro=>"1"}, + {name=>"LDNS_RCODE_SERVFAIL", type=>"IV", macro=>"1"}, + {name=>"LDNS_RCODE_YXDOMAIN", type=>"IV", macro=>"1"}, + {name=>"LDNS_RCODE_YXRRSET", type=>"IV", macro=>"1"}, + {name=>"LDNS_RDF_TYPE_A", type=>"IV", macro=>"1"}, + {name=>"LDNS_RDF_TYPE_AAAA", type=>"IV", macro=>"1"}, + {name=>"LDNS_RDF_TYPE_ALG", type=>"IV", macro=>"1"}, + {name=>"LDNS_RDF_TYPE_APL", type=>"IV", macro=>"1"}, + {name=>"LDNS_RDF_TYPE_ATMA", type=>"IV", macro=>"1"}, + {name=>"LDNS_RDF_TYPE_B32_EXT", type=>"IV", macro=>"1"}, + {name=>"LDNS_RDF_TYPE_B64", type=>"IV", macro=>"1"}, + {name=>"LDNS_RDF_TYPE_CERT_ALG", type=>"IV", macro=>"1"}, + {name=>"LDNS_RDF_TYPE_CLASS", type=>"IV", macro=>"1"}, + {name=>"LDNS_RDF_TYPE_DNAME", type=>"IV", macro=>"1"}, + {name=>"LDNS_RDF_TYPE_HEX", type=>"IV", macro=>"1"}, + {name=>"LDNS_RDF_TYPE_INT16", type=>"IV", macro=>"1"}, + {name=>"LDNS_RDF_TYPE_INT16_DATA", type=>"IV", macro=>"1"}, + {name=>"LDNS_RDF_TYPE_INT32", type=>"IV", macro=>"1"}, + {name=>"LDNS_RDF_TYPE_INT8", type=>"IV", macro=>"1"}, + {name=>"LDNS_RDF_TYPE_IPSECKEY", type=>"IV", macro=>"1"}, + {name=>"LDNS_RDF_TYPE_LOC", type=>"IV", macro=>"1"}, + {name=>"LDNS_RDF_TYPE_NONE", type=>"IV", macro=>"1"}, + {name=>"LDNS_RDF_TYPE_NSAP", type=>"IV", macro=>"1"}, + {name=>"LDNS_RDF_TYPE_NSEC", type=>"IV", macro=>"1"}, + {name=>"LDNS_RDF_TYPE_NSEC3_NEXT_OWNER", type=>"IV", macro=>"1"}, + {name=>"LDNS_RDF_TYPE_NSEC3_SALT", type=>"IV", macro=>"1"}, + {name=>"LDNS_RDF_TYPE_PERIOD", type=>"IV", macro=>"1"}, + {name=>"LDNS_RDF_TYPE_SERVICE", type=>"IV", macro=>"1"}, + {name=>"LDNS_RDF_TYPE_STR", type=>"IV", macro=>"1"}, + {name=>"LDNS_RDF_TYPE_TIME", type=>"IV", macro=>"1"}, + {name=>"LDNS_RDF_TYPE_HIP", type=>"IV", macro=>"1"}, + {name=>"LDNS_RDF_TYPE_TSIGTIME", type=>"IV", macro=>"1"}, + {name=>"LDNS_RDF_TYPE_TYPE", type=>"IV", macro=>"1"}, + {name=>"LDNS_RDF_TYPE_UNKNOWN", type=>"IV", macro=>"1"}, + {name=>"LDNS_RDF_TYPE_WKS", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_CLASS_ANY", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_CLASS_CH", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_CLASS_COUNT", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_CLASS_FIRST", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_CLASS_HS", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_CLASS_IN", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_CLASS_LAST", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_CLASS_NONE", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_COMPRESS", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_NO_COMPRESS", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_A", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_A6", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_AAAA", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_AFSDB", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_ANY", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_APL", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_ATMA", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_AXFR", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_CERT", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_CNAME", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_COUNT", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_DHCID", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_DLV", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_DNAME", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_DNSKEY", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_DS", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_EID", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_FIRST", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_GID", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_GPOS", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_HINFO", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_IPSECKEY", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_ISDN", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_IXFR", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_KEY", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_KX", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_LAST", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_LOC", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_MAILA", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_MAILB", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_MB", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_MD", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_MF", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_MG", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_MINFO", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_MR", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_MX", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_NAPTR", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_NIMLOC", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_NS", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_NSAP", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_NSAP_PTR", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_NSEC", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_NSEC3", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_NSEC3PARAM", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_NSEC3PARAMS", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_NULL", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_NXT", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_OPT", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_PTR", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_PX", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_RP", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_RRSIG", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_RT", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_SIG", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_SINK", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_SOA", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_SPF", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_SRV", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_SSHFP", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_TALINK", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_TSIG", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_TXT", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_UID", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_UINFO", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_UNSPEC", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_WKS", type=>"IV", macro=>"1"}, + {name=>"LDNS_RR_TYPE_X25", type=>"IV", macro=>"1"}, + {name=>"LDNS_RSAMD5", type=>"IV", macro=>"1"}, + {name=>"LDNS_RSASHA1", type=>"IV", macro=>"1"}, + {name=>"LDNS_RSASHA1_NSEC3", type=>"IV", macro=>"1"}, + {name=>"LDNS_RSASHA256", type=>"IV", macro=>"1"}, + {name=>"LDNS_RSASHA512", type=>"IV", macro=>"1"}, + {name=>"LDNS_SECTION_ADDITIONAL", type=>"IV", macro=>"1"}, + {name=>"LDNS_SECTION_ANSWER", type=>"IV", macro=>"1"}, + {name=>"LDNS_SECTION_ANY", type=>"IV", macro=>"1"}, + {name=>"LDNS_SECTION_ANY_NOQUESTION", type=>"IV", macro=>"1"}, + {name=>"LDNS_SECTION_AUTHORITY", type=>"IV", macro=>"1"}, + {name=>"LDNS_SECTION_QUESTION", type=>"IV", macro=>"1"}, + {name=>"LDNS_SHA1", type=>"IV", macro=>"1"}, + {name=>"LDNS_SHA256", type=>"IV", macro=>"1"}, + {name=>"LDNS_SHA384", type=>"IV", macro=>"1"}, + {name=>"LDNS_SIGN_DSA", type=>"IV", macro=>"1"}, + {name=>"LDNS_SIGN_DSA_NSEC3", type=>"IV", macro=>"1"}, + {name=>"LDNS_SIGN_ECC_GOST", type=>"IV", macro=>"1"}, + {name=>"LDNS_SIGN_ECDSAP384SHA384", type=>"IV", macro=>"1"}, + {name=>"LDNS_SIGN_HMACSHA1", type=>"IV", macro=>"1"}, + {name=>"LDNS_SIGN_HMACSHA256", type=>"IV", macro=>"1"}, + {name=>"LDNS_SIGN_RSAMD5", type=>"IV", macro=>"1"}, + {name=>"LDNS_SIGN_RSASHA1", type=>"IV", macro=>"1"}, + {name=>"LDNS_SIGN_RSASHA1_NSEC3", type=>"IV", macro=>"1"}, + {name=>"LDNS_SIGN_RSASHA256", type=>"IV", macro=>"1"}, + {name=>"LDNS_SIGN_RSASHA512", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_ADDRESS_ERR", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_CERT_BAD_ALGORITHM", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_CRYPTO_ALGO_NOT_IMPL", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_CRYPTO_BOGUS", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_CRYPTO_EXPIRATION_BEFORE_INCEPTION", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_CRYPTO_NO_DNSKEY", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_CRYPTO_NO_DS", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_CRYPTO_NO_MATCHING_KEYTAG_DNSKEY", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_CRYPTO_NO_RRSIG", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_CRYPTO_NO_TRUSTED_DNSKEY", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_CRYPTO_NO_TRUSTED_DS", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_CRYPTO_SIG_EXPIRED", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_CRYPTO_SIG_NOT_INCEPTED", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_CRYPTO_TSIG_BOGUS", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_CRYPTO_TSIG_ERR", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_CRYPTO_TYPE_COVERED_ERR", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_CRYPTO_UNKNOWN_ALGO", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_CRYPTO_VALIDATED", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_DDD_OVERFLOW", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_DNSSEC_EXISTENCE_DENIED", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_DNSSEC_NSEC3_ORIGINAL_NOT_FOUND", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_DNSSEC_NSEC_RR_NOT_COVERED", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_DNSSEC_NSEC_WILDCARD_NOT_COVERED", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_DOMAINNAME_OVERFLOW", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_DOMAINNAME_UNDERFLOW", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_EMPTY_LABEL", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_ENGINE_KEY_NOT_LOADED", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_ERR", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_FILE_ERR", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_INTERNAL_ERR", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_INVALID_B32_EXT", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_INVALID_B64", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_INVALID_HEX", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_INVALID_INT", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_INVALID_IP4", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_INVALID_IP6", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_INVALID_POINTER", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_INVALID_STR", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_INVALID_TIME", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_LABEL_OVERFLOW", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_MEM_ERR", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_MISSING_RDATA_FIELDS_KEY", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_MISSING_RDATA_FIELDS_RRSIG", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_NETWORK_ERR", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_NOT_IMPL", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_NO_DATA", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_NSEC3_ERR", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_NULL", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_OK", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_PACKET_OVERFLOW", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_RES_NO_NS", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_RES_QUERY", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_SOCKET_ERROR", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_SSL_ERR", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_SYNTAX_ALG_ERR", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_SYNTAX_BAD_ESCAPE", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_SYNTAX_CLASS_ERR", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_SYNTAX_DNAME_ERR", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_SYNTAX_EMPTY", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_SYNTAX_ERR", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_SYNTAX_INCLUDE", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_SYNTAX_INCLUDE_ERR_NOTIMPL", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_SYNTAX_INTEGER_OVERFLOW", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_SYNTAX_ITERATIONS_OVERFLOW", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_SYNTAX_KEYWORD_ERR", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_SYNTAX_MISSING_VALUE_ERR", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_SYNTAX_ORIGIN", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_SYNTAX_RDATA_ERR", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_SYNTAX_TTL", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_SYNTAX_TTL_ERR", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_SYNTAX_TYPE_ERR", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_SYNTAX_VERSION_ERR", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_UNKNOWN_INET", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_WIRE_INCOMPLETE_ADDITIONAL", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_WIRE_INCOMPLETE_ANSWER", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_WIRE_INCOMPLETE_AUTHORITY", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_WIRE_INCOMPLETE_HEADER", type=>"IV", macro=>"1"}, + {name=>"LDNS_STATUS_WIRE_INCOMPLETE_QUESTION", type=>"IV", macro=>"1"}, + {name=>"endif", type=>"IV", macro=>"1"}, + {name=>"if", type=>"IV", macro=>"1"}); + +print constant_types(), "\n"; # macro defs +foreach (C_constant ("LDNS", 'constant', 'IV', $types, undef, 3, @names) ) { + print $_, "\n"; # C constant subs +} +print "\n#### XS Section:\n"; +print XS_constant ("LDNS", $types); +__END__ + */ + + switch (len) { + case 2: + if (name[0] == 'i' && name[1] == 'f') { + *iv_return = if; + return PERL_constant_ISIV; + } + break; + case 5: + if (memEQ(name, "endif", 5)) { + *iv_return = endif; + return PERL_constant_ISIV; + } + break; + case 7: + return constant_7 (aTHX_ name, iv_return); + break; + case 8: + /* Names all of length 8. */ + /* LDNS_DSA LDNS_ECC */ + /* Offset 5 gives the best switch position. */ + switch (name[5]) { + case 'D': + if (memEQ(name, "LDNS_DSA", 8)) { + /* ^ */ + *iv_return = LDNS_DSA; + return PERL_constant_ISIV; + } + break; + case 'E': + if (memEQ(name, "LDNS_ECC", 8)) { + /* ^ */ + *iv_return = LDNS_ECC; + return PERL_constant_ISIV; + } + break; + } + break; + case 9: + /* Names all of length 9. */ + /* LDNS_PORT LDNS_SHA1 */ + /* Offset 5 gives the best switch position. */ + switch (name[5]) { + case 'P': + if (memEQ(name, "LDNS_PORT", 9)) { + /* ^ */ +#ifdef LDNS_PORT + *iv_return = LDNS_PORT; + return PERL_constant_ISIV; +#else + return PERL_constant_NOTDEF; +#endif + } + break; + case 'S': + if (memEQ(name, "LDNS_SHA1", 9)) { + /* ^ */ + *iv_return = LDNS_SHA1; + return PERL_constant_ISIV; + } + break; + } + break; + case 11: + return constant_11 (aTHX_ name, iv_return); + break; + case 12: + if (memEQ(name, "LDNS_RSASHA1", 12)) { + *iv_return = LDNS_RSASHA1; + return PERL_constant_ISIV; + } + break; + case 13: + return constant_13 (aTHX_ name, iv_return); + break; + case 14: + return constant_14 (aTHX_ name, iv_return); + break; + case 15: + return constant_15 (aTHX_ name, iv_return); + break; + case 16: + return constant_16 (aTHX_ name, iv_return); + break; + case 17: + return constant_17 (aTHX_ name, iv_return); + break; + case 18: + return constant_18 (aTHX_ name, iv_return); + break; + case 19: + return constant_19 (aTHX_ name, iv_return); + break; + case 20: + return constant_20 (aTHX_ name, iv_return); + break; + case 21: + return constant_21 (aTHX_ name, iv_return); + break; + case 22: + return constant_22 (aTHX_ name, iv_return); + break; + case 23: + return constant_23 (aTHX_ name, iv_return); + break; + case 24: + return constant_24 (aTHX_ name, iv_return); + break; + case 25: + /* Names all of length 25. */ + /* LDNS_SIGN_ECDSAP384SHA384 LDNS_STATUS_SYNTAX_ORIGIN */ + /* Offset 15 gives the best switch position. */ + switch (name[15]) { + case 'P': + if (memEQ(name, "LDNS_SIGN_ECDSAP384SHA384", 25)) { + /* ^ */ + *iv_return = LDNS_SIGN_ECDSAP384SHA384; + return PERL_constant_ISIV; + } + break; + case 'T': + if (memEQ(name, "LDNS_STATUS_SYNTAX_ORIGIN", 25)) { + /* ^ */ + *iv_return = LDNS_STATUS_SYNTAX_ORIGIN; + return PERL_constant_ISIV; + } + break; + } + break; + case 26: + return constant_26 (aTHX_ name, iv_return); + break; + case 27: + return constant_27 (aTHX_ name, iv_return); + break; + case 28: + return constant_28 (aTHX_ name, iv_return); + break; + case 29: + /* Names all of length 29. */ + /* LDNS_STATUS_CRYPTO_TSIG_BOGUS LDNS_STATUS_SYNTAX_BAD_ESCAPE */ + /* Offset 15 gives the best switch position. */ + switch (name[15]) { + case 'P': + if (memEQ(name, "LDNS_STATUS_CRYPTO_TSIG_BOGUS", 29)) { + /* ^ */ + *iv_return = LDNS_STATUS_CRYPTO_TSIG_BOGUS; + return PERL_constant_ISIV; + } + break; + case 'T': + if (memEQ(name, "LDNS_STATUS_SYNTAX_BAD_ESCAPE", 29)) { + /* ^ */ + *iv_return = LDNS_STATUS_SYNTAX_BAD_ESCAPE; + return PERL_constant_ISIV; + } + break; + } + break; + case 30: + return constant_30 (aTHX_ name, iv_return); + break; + case 31: + /* Names all of length 31. */ + /* LDNS_STATUS_CRYPTO_UNKNOWN_ALGO LDNS_STATUS_DOMAINNAME_OVERFLOW */ + /* Offset 12 gives the best switch position. */ + switch (name[12]) { + case 'C': + if (memEQ(name, "LDNS_STATUS_CRYPTO_UNKNOWN_ALGO", 31)) { + /* ^ */ + *iv_return = LDNS_STATUS_CRYPTO_UNKNOWN_ALGO; + return PERL_constant_ISIV; + } + break; + case 'D': + if (memEQ(name, "LDNS_STATUS_DOMAINNAME_OVERFLOW", 31)) { + /* ^ */ + *iv_return = LDNS_STATUS_DOMAINNAME_OVERFLOW; + return PERL_constant_ISIV; + } + break; + } + break; + case 32: + return constant_32 (aTHX_ name, iv_return); + break; + case 33: + if (memEQ(name, "LDNS_STATUS_ENGINE_KEY_NOT_LOADED", 33)) { + *iv_return = LDNS_STATUS_ENGINE_KEY_NOT_LOADED; + return PERL_constant_ISIV; + } + break; + case 34: + /* Names all of length 34. */ + /* LDNS_STATUS_WIRE_INCOMPLETE_ANSWER LDNS_STATUS_WIRE_INCOMPLETE_HEADER */ + /* Offset 28 gives the best switch position. */ + switch (name[28]) { + case 'A': + if (memEQ(name, "LDNS_STATUS_WIRE_INCOMPLETE_ANSWER", 34)) { + /* ^ */ + *iv_return = LDNS_STATUS_WIRE_INCOMPLETE_ANSWER; + return PERL_constant_ISIV; + } + break; + case 'H': + if (memEQ(name, "LDNS_STATUS_WIRE_INCOMPLETE_HEADER", 34)) { + /* ^ */ + *iv_return = LDNS_STATUS_WIRE_INCOMPLETE_HEADER; + return PERL_constant_ISIV; + } + break; + } + break; + case 35: + return constant_35 (aTHX_ name, iv_return); + break; + case 36: + return constant_36 (aTHX_ name, iv_return); + break; + case 37: + if (memEQ(name, "LDNS_STATUS_WIRE_INCOMPLETE_AUTHORITY", 37)) { + *iv_return = LDNS_STATUS_WIRE_INCOMPLETE_AUTHORITY; + return PERL_constant_ISIV; + } + break; + case 38: + return constant_38 (aTHX_ name, iv_return); + break; + case 43: + if (memEQ(name, "LDNS_STATUS_DNSSEC_NSEC3_ORIGINAL_NOT_FOUND", 43)) { + *iv_return = LDNS_STATUS_DNSSEC_NSEC3_ORIGINAL_NOT_FOUND; + return PERL_constant_ISIV; + } + break; + case 44: + /* Names all of length 44. */ + /* LDNS_STATUS_CRYPTO_NO_MATCHING_KEYTAG_DNSKEY + LDNS_STATUS_DNSSEC_NSEC_WILDCARD_NOT_COVERED */ + /* Offset 12 gives the best switch position. */ + switch (name[12]) { + case 'C': + if (memEQ(name, "LDNS_STATUS_CRYPTO_NO_MATCHING_KEYTAG_DNSKEY", 44)) { + /* ^ */ + *iv_return = LDNS_STATUS_CRYPTO_NO_MATCHING_KEYTAG_DNSKEY; + return PERL_constant_ISIV; + } + break; + case 'D': + if (memEQ(name, "LDNS_STATUS_DNSSEC_NSEC_WILDCARD_NOT_COVERED", 44)) { + /* ^ */ + *iv_return = LDNS_STATUS_DNSSEC_NSEC_WILDCARD_NOT_COVERED; + return PERL_constant_ISIV; + } + break; + } + break; + case 46: + if (memEQ(name, "LDNS_STATUS_CRYPTO_EXPIRATION_BEFORE_INCEPTION", 46)) { + *iv_return = LDNS_STATUS_CRYPTO_EXPIRATION_BEFORE_INCEPTION; + return PERL_constant_ISIV; + } + break; + } + return PERL_constant_NOTFOUND; +} + diff --git a/contrib/DNS-LDNS/fallback/const-xs.inc b/contrib/DNS-LDNS/fallback/const-xs.inc new file mode 100644 index 0000000000000..1738df2243a75 --- /dev/null +++ b/contrib/DNS-LDNS/fallback/const-xs.inc @@ -0,0 +1,90 @@ +void +constant(sv) + PREINIT: +#ifdef dXSTARG + dXSTARG; /* Faster if we have it. */ +#else + dTARGET; +#endif + STRLEN len; + int type; + IV iv; + /* NV nv; Uncomment this if you need to return NVs */ + /* const char *pv; Uncomment this if you need to return PVs */ + INPUT: + SV * sv; + const char * s = SvPV(sv, len); + PPCODE: + /* Change this to constant(aTHX_ s, len, &iv, &nv); + if you need to return both NVs and IVs */ + type = constant(aTHX_ s, len, &iv); + /* Return 1 or 2 items. First is error message, or undef if no error. + Second, if present, is found value */ + switch (type) { + case PERL_constant_NOTFOUND: + sv = + sv_2mortal(newSVpvf("%s is not a valid LDNS macro", s)); + PUSHs(sv); + break; + case PERL_constant_NOTDEF: + sv = sv_2mortal(newSVpvf( + "Your vendor has not defined LDNS macro %s, used", + s)); + PUSHs(sv); + break; + case PERL_constant_ISIV: + EXTEND(SP, 1); + PUSHs(&PL_sv_undef); + PUSHi(iv); + break; + /* Uncomment this if you need to return NOs + case PERL_constant_ISNO: + EXTEND(SP, 1); + PUSHs(&PL_sv_undef); + PUSHs(&PL_sv_no); + break; */ + /* Uncomment this if you need to return NVs + case PERL_constant_ISNV: + EXTEND(SP, 1); + PUSHs(&PL_sv_undef); + PUSHn(nv); + break; */ + /* Uncomment this if you need to return PVs + case PERL_constant_ISPV: + EXTEND(SP, 1); + PUSHs(&PL_sv_undef); + PUSHp(pv, strlen(pv)); + break; */ + /* Uncomment this if you need to return PVNs + case PERL_constant_ISPVN: + EXTEND(SP, 1); + PUSHs(&PL_sv_undef); + PUSHp(pv, iv); + break; */ + /* Uncomment this if you need to return SVs + case PERL_constant_ISSV: + EXTEND(SP, 1); + PUSHs(&PL_sv_undef); + PUSHs(sv); + break; */ + /* Uncomment this if you need to return UNDEFs + case PERL_constant_ISUNDEF: + break; */ + /* Uncomment this if you need to return UVs + case PERL_constant_ISUV: + EXTEND(SP, 1); + PUSHs(&PL_sv_undef); + PUSHu((UV)iv); + break; */ + /* Uncomment this if you need to return YESs + case PERL_constant_ISYES: + EXTEND(SP, 1); + PUSHs(&PL_sv_undef); + PUSHs(&PL_sv_yes); + break; */ + default: + sv = sv_2mortal(newSVpvf( + "Unexpected return type %d while processing LDNS macro %s, used", + type, s)); + PUSHs(sv); + } diff --git a/contrib/DNS-LDNS/lib/DNS/LDNS.pm b/contrib/DNS-LDNS/lib/DNS/LDNS.pm new file mode 100644 index 0000000000000..d2fe20e193b30 --- /dev/null +++ b/contrib/DNS-LDNS/lib/DNS/LDNS.pm @@ -0,0 +1,1310 @@ +package DNS::LDNS; + +use 5.014002; +use strict; +use warnings; +use Carp; + +require Exporter; +use AutoLoader; + +our @ISA = qw(Exporter); + +# Items to export into callers namespace by default. Note: do not export +# names by default without a very good reason. Use EXPORT_OK instead. +# Do not simply export all your public functions/methods/constants. + +our %EXPORT_TAGS = ( 'all' => [ 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_EXP_TIME + LDNS_DEFAULT_TTL + LDNS_DH + LDNS_DNSSEC_KEYPROTO + 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_KEYLEN + LDNS_MAX_LABELLEN + LDNS_MAX_PACKETLEN + LDNS_MAX_POINTERS + LDNS_MAX_RDFLEN + LDNS_NSEC3_MAX_ITERATIONS + 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_SIGNATURE_LEAVE_ADD_NEW + LDNS_SIGNATURE_LEAVE_NO_ADD + LDNS_SIGNATURE_REMOVE_ADD_NEW + LDNS_SIGNATURE_REMOVE_NO_ADD + 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 + + dnssec_create_nsec + dnssec_create_nsec3 + create_nsec + create_nsec3 + + rr_type2str + rr_class2str + rr_type_by_name + rr_class_by_name + pkt_opcode2str + pkt_rcode2str + + errorstr_by_id + signing_algorithm_by_name + key_algorithm_supported + read_anchor_file +) ] ); + +our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } ); + +our @EXPORT = 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_EXP_TIME + LDNS_DEFAULT_TTL + LDNS_DH + LDNS_DNSSEC_KEYPROTO + 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_KEYLEN + LDNS_MAX_LABELLEN + LDNS_MAX_PACKETLEN + LDNS_MAX_POINTERS + LDNS_MAX_RDFLEN + LDNS_NSEC3_MAX_ITERATIONS + 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_SIGNATURE_LEAVE_ADD_NEW + LDNS_SIGNATURE_LEAVE_NO_ADD + LDNS_SIGNATURE_REMOVE_ADD_NEW + LDNS_SIGNATURE_REMOVE_NO_ADD + 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 + + dnssec_create_nsec + dnssec_create_nsec3 + create_nsec + create_nsec3 + + rr_type2str + rr_class2str + pkt_opcode2str + pkt_rcode2str + rr_type_by_name + rr_class_by_name + errorstr_by_id + signing_algorithm_by_name + key_algorithm_supported + read_anchor_file +); + +our $VERSION = '0.06'; + +sub AUTOLOAD { + # This AUTOLOAD is used to 'autoload' constants from the constant() + # XS function. + + my $constname; + our $AUTOLOAD; + ($constname = $AUTOLOAD) =~ s/.*:://; + croak "&DNS::LDNS::constant not defined" if $constname eq 'constant'; + my ($error, $val) = constant($constname); + if ($error) { croak $error; } + { + no strict 'refs'; + # Fixed between 5.005_53 and 5.005_61 +#XXX if ($] >= 5.00561) { +#XXX *$AUTOLOAD = sub () { $val }; +#XXX } +#XXX else { + *$AUTOLOAD = sub { $val }; +#XXX } + } + goto &$AUTOLOAD; +} + +require XSLoader; +XSLoader::load('DNS::LDNS', $VERSION); + +# Preloaded methods go here. + +our $last_status; +our $line_nr; + +sub last_error { + return errorstr_by_id($DNS::LDNS::last_status); +} + +require DNS::LDNS::RR; +require DNS::LDNS::GC; +require DNS::LDNS::RData; +require DNS::LDNS::Zone; +require DNS::LDNS::RRList; +require DNS::LDNS::DNSSecZone; +require DNS::LDNS::DNSSecRRSets; +require DNS::LDNS::DNSSecRRs; +require DNS::LDNS::DNSSecName; +require DNS::LDNS::RBTree; +require DNS::LDNS::RBNode; +require DNS::LDNS::Resolver; +require DNS::LDNS::Packet; +require DNS::LDNS::Key; +require DNS::LDNS::KeyList; +require DNS::LDNS::DNSSecDataChain; +require DNS::LDNS::DNSSecTrustTree; + +# Some default values used by the constructors +our $DEFAULT_CLASS = &LDNS_RR_CLASS_IN; +our $DEFAULT_TTL = 86400; # 1d +our $DEFAULT_ORIGIN = new DNS::LDNS::RData(&LDNS_RDF_TYPE_DNAME, '.'); +our $DEFAULT_SOA_REFRESH = 86400; # 1d +our $DEFAULT_SOA_RETRY = 3600; # 1h +our $DEFAULT_SOA_EXPIRE = 604800; # 1w +our $DEFAULT_SOA_MINIMUM = 10800; # 3h + +# Autoload methods go after =cut, and are processed by the autosplit program. + +1; +__END__ + +=head1 NAME + +DNS::LDNS - Perl extension for the ldns library + +=head1 SYNOPSIS + + use DNS::LDNS ':all' + +=head1 DESCRIPTION + +DNS::LDNS is a perl OO-wrapper for the ldns library. A complete list +of object methods is found in the perldoc for each of the individual +classes. You may also read the documentation of the ldns library +(http://www.nlnetlabs.nl/projects/ldns). + +=head2 Brief examples of usage + + use DNS::LDNS ':all'; + + my $z = new DNS::LDNS::Zone(filename => '/path/to/myzone'); + print DNS::LDNS::last_error; + my $rr = new DNS::LDNS::RR('mylabel 3600 IN A 168.10.10.10'); + print $z->soa->to_string; + my $rrlist = $z->rrs->push($rr); + print $z->to_string; + + my $kl = new DNS::LDNS::KeyList; + $kl->push(new DNS::LDNS::Key(filename => 'key'); + $kl->key(0)->set_pubkey_owner( + new DNS::LDNS::RData(LDNS_RDF_TYPE_DNAME, 'myzone.org')); + my $signedz = $z->sign($kl); + print $signedz->to_string; + + my $r = new DNS::LDNS::Resolver(filename => '/my/resolv.conf'); + my $p = $r->send( + new DNS::LDNS::RData(LDNS_RDF_TYPE_DNAME, 'www.google.com'), + LDNS_RR_TYPE_A, LDNS_RR_CLASS_IN, LDNS_RD); + print $p->answer->to_string; + print $p->authority->to_string; + +=head2 Classes + +A description of the classes included and how they map to the ldns +library structures: + +=over 20 + +=item B<DNS::LDNS> + +Base class with static functions and constants + +=item B<DNS::LDNS::Zone> + +Represents a parsed zonefile (maps to the ldns_zone struct) + +=item B<DNS::LDNS::RRList> + +Represents a list of RRs. This class is also used to represent an +RRSet all the dnames and types are equal, (maps to the the +ldns_rr_list struct) + +=item B<DNS::LDNS::RR> + +Represents a resource record (RR), (maps to the ldns_rr struct) + +=item B<DNS::LDNS::RData> + +Represents an rdata field or a dname in an RR (maps to the ldns_rdf +struct) + +=item B<DNS::LDNS::Resolver> + +Represents a DNS resolver (maps to the ldns_resolver struct) + +=item B<DNS::LDNS::Packet> + +Represents a DNS package (maps to the ldns_pkt struct) + +=item B<DNS::LDNS::Key> + +Represents a DNSSec private key (maps to the ldns_key struct) + +=item B<DNS::LDNS::KeyList> + +Represents a linked list of keys (maps to the ldns_key_list struct) + +=item B<DNS::LDNS::DNSSecZone> + +Represents a zone with dnssec data (maps to the ldns_dnssec_zone +struct) + +=item B<DNS::LDNS::RBTree> + +Represents a tree of DNSSecName nodes (maps to the ldns_rbtree struct) + +=item B<DNS::LDNS::RBNode> + +Represents a node in the RBTree (maps to the ldns_rbnode struct) + +=item B<DNS::LDNS::DNSSecName> + +Represents a dname in a DNSSecZone and holds a DNSSecRRSets list for +this dname, possibly with signatures (maps to the ldns_dnssec_name +struct) + +=item B<DNS::LDNS::DNSSecRRSets> + +Represents a linked list of DNSSec RR sets, possibly with signatures +(maps to the ldns_dnssec_rrsets struct) + +=item B<DNS::LDNS::DNSSecRRs> + +Represents a linked list of RRs (maps to the ldns_dnssec_rrs struct) + +=item B<DNS::LDNS::DNSSecDataChain> + +Represents a chain of RR, DNSKEY, and DS data used for building a +dnssec trust tree (maps to the ldns_dnssec_data_chain struct) + +=item B<DNS::LDNS::DNSSecTrustTree> + +Represents a tree of chained trust relationships from a signed RR to a +set of trust anchors (maps to the ldns_dnssec_trust_tree struct). + +=item B<DNS::LDNS::GC> + +Garbage collector. Handles ownership dependencies and freeing data +used by the other classes. Used internally only. + +=back + +One thing to note is that some of the classes have a seemingly +overlapping functionality. The Zone and RRList are used to represent +a generic zone. It may contain dnssec data but treats it like any +other dns data and does not have any knowledge of its structure. The +DNSSec* and RB* classes are building blocks for representing a signed +zone in a more structured way. + +=head2 Static functions + + 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 +inserting data inserts inserts a clone of the object. Most classes +have a clone method which can be used if a cloned object is what you +really want. + +=head3 Examples + +DNS::LDNS::Zone::rrs returns a reference to the DNS::LDNS::RRList +within the zone, so if you make changes to the RRList you also +changes the Zone object. + +DNS::LDNS::RRList::push(rr) clones the rr, then pushes the cloned rr +to the list. Changing the rr afterwards will not change the list. + +An exception is the Key class which does not have a clone +mechanism. In this case we allow a free Key to be added to only one +KeyList. Adding it to multiple lists will provoke an error. + +The wrapper keeps track of allocated data structures and references. +Whenever data is no longer referred to by a perl object, it will be +freed. + +=head2 ERROR HANDLING + +The purpose for writing this wrapper class has been to be able to +process zone file data with good time performance. Data checking and +error handling is a bit sparse. Calling a method with wrong argument +types will some times kill the application with an intelligible error +message, in other cases it may provoke a segmentation fault. Using +out-of-range data values, e.g. in array indexes, may also cause +unexpected results. + +Most constructors and all methods returning a status will update the +static DNS::LDNS::last_status variable. Most methods do not return a +status and will not reset this variable even though they succeeds. + +=head2 EXPORT + +None by default. + +=head2 Exportable constants + +=head3 Status + + 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 + +=head3 Resolver flags and constants + + 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 + +=head3 Resolver query flags + + LDNS_AA + LDNS_AD + LDNS_CD + LDNS_QR + LDNS_RA + LDNS_RD + LDNS_TC + +=head3 Resolver rcodes + + 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 + +=head3 Packet types + + LDNS_PACKET_ANSWER + LDNS_PACKET_NODATA + LDNS_PACKET_NXDOMAIN + LDNS_PACKET_QUESTION + LDNS_PACKET_REFERRAL + LDNS_PACKET_UNKNOWN + +=head3 Packet opcodes + + LDNS_PACKET_IQUERY + LDNS_PACKET_NOTIFY + LDNS_PACKET_QUERY + LDNS_PACKET_STATUS + LDNS_PACKET_UPDATE + +=head3 Packet sections + + LDNS_SECTION_ADDITIONAL + LDNS_SECTION_ANSWER + LDNS_SECTION_ANY + LDNS_SECTION_ANY_NOQUESTION + LDNS_SECTION_AUTHORITY + LDNS_SECTION_QUESTION + +=head3 DNSSec constants + + LDNS_DEFAULT_EXP_TIME + LDNS_MAX_KEYLEN + LDNS_DNSSEC_KEYPROTO + +=head3 DNSSec sign policies + + LDNS_SIGNATURE_LEAVE_ADD_NEW + LDNS_SIGNATURE_LEAVE_NO_ADD + LDNS_SIGNATURE_REMOVE_ADD_NEW + LDNS_SIGNATURE_REMOVE_NO_ADD + LDNS_NSEC3_MAX_ITERATIONS + +=head3 Key flags + + LDNS_KEY_REVOKE_KEY + LDNS_KEY_SEP_KEY + LDNS_KEY_ZONE_KEY + +=head3 Key algorithms + + LDNS_DH + LDNS_DSA + LDNS_DSA_NSEC3 + LDNS_ECC + LDNS_RSAMD5 + LDNS_RSASHA1 + LDNS_RSASHA1_NSEC3 + LDNS_RSASHA256 + LDNS_RSASHA512 + LDNS_ECC_GOST + LDNS_PRIVATEDNS + LDNS_PRIVATEOID + +=head3 Signing algorithms + + 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 + +=head3 Hashing algorithm + + LDNS_SHA1 + LDNS_SHA256 + LDNS_HASH_GOST + +=head3 Rdata constants + + LDNS_MAX_RDFLEN + LDNS_NSEC3_VARS_OPTOUT_MASK + + LDNS_RDF_SIZE_16BYTES + LDNS_RDF_SIZE_6BYTES + LDNS_RDF_SIZE_BYTE + LDNS_RDF_SIZE_DOUBLEWORD + LDNS_RDF_SIZE_WORD + +=head3 Rdata types + + 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 + +=head3 Algorithms used in CERT RRs. + + 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 + +=head3 RR compress flag + + LDNS_RR_COMPRESS + LDNS_RR_NO_COMPRESS + +=head3 RR classes + + 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 + +=head3 RR types + + 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 + +=head3 Various defaults and other constants + + LDNS_DEFAULT_TTL + LDNS_PORT + LDNS_IP4ADDRLEN + LDNS_IP6ADDRLEN + LDNS_MAX_DOMAINLEN + LDNS_MAX_LABELLEN + LDNS_MAX_PACKETLEN + LDNS_MAX_POINTERS + LDNS_RR_OVERHEAD + LDNS_RDATA_FIELD_DESCRIPTORS_COMMON + +=head1 BUGS + +This package is currently in a very early stage of development. There +are probably some bugs. You may also expect that method names and +behaviour could still change without much considerations to backward +compatibility. + +=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 diff --git a/contrib/DNS-LDNS/lib/DNS/LDNS/DNSSecDataChain.pm b/contrib/DNS-LDNS/lib/DNS/LDNS/DNSSecDataChain.pm new file mode 100644 index 0000000000000..42074dc153c8b --- /dev/null +++ b/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.06'; + +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 diff --git a/contrib/DNS-LDNS/lib/DNS/LDNS/DNSSecName.pm b/contrib/DNS-LDNS/lib/DNS/LDNS/DNSSecName.pm new file mode 100644 index 0000000000000..bea6bb7c49312 --- /dev/null +++ b/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.06'; + +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 diff --git a/contrib/DNS-LDNS/lib/DNS/LDNS/DNSSecRRSets.pm b/contrib/DNS-LDNS/lib/DNS/LDNS/DNSSecRRSets.pm new file mode 100644 index 0000000000000..fbd9bb735628d --- /dev/null +++ b/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.06'; + +# 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 diff --git a/contrib/DNS-LDNS/lib/DNS/LDNS/DNSSecRRs.pm b/contrib/DNS-LDNS/lib/DNS/LDNS/DNSSecRRs.pm new file mode 100644 index 0000000000000..b7b3dccf9543a --- /dev/null +++ b/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.06'; + +# 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 diff --git a/contrib/DNS-LDNS/lib/DNS/LDNS/DNSSecTrustTree.pm b/contrib/DNS-LDNS/lib/DNS/LDNS/DNSSecTrustTree.pm new file mode 100644 index 0000000000000..1b9ca66e61026 --- /dev/null +++ b/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.06'; + +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 diff --git a/contrib/DNS-LDNS/lib/DNS/LDNS/DNSSecZone.pm b/contrib/DNS-LDNS/lib/DNS/LDNS/DNSSecZone.pm new file mode 100644 index 0000000000000..da809a6ace01e --- /dev/null +++ b/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.06'; + +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} || $LDNS::DEFAULT_ORIGIN, + $args{ttl} || $LDNS::DEFAULT_TTL, + $args{class} || $LDNS::DEFAULT_CLASS, + $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 diff --git a/contrib/DNS-LDNS/lib/DNS/LDNS/GC.pm b/contrib/DNS-LDNS/lib/DNS/LDNS/GC.pm new file mode 100644 index 0000000000000..014b7bee21af0 --- /dev/null +++ b/contrib/DNS-LDNS/lib/DNS/LDNS/GC.pm @@ -0,0 +1,122 @@ +package DNS::LDNS::GC; + +use strict; +use warnings; + +our $VERSION = '0.06'; + +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 diff --git a/contrib/DNS-LDNS/lib/DNS/LDNS/Key.pm b/contrib/DNS-LDNS/lib/DNS/LDNS/Key.pm new file mode 100644 index 0000000000000..bbce173dd8bbe --- /dev/null +++ b/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.06'; + +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 diff --git a/contrib/DNS-LDNS/lib/DNS/LDNS/KeyList.pm b/contrib/DNS-LDNS/lib/DNS/LDNS/KeyList.pm new file mode 100644 index 0000000000000..c39e1c704e538 --- /dev/null +++ b/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.06'; + +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 diff --git a/contrib/DNS-LDNS/lib/DNS/LDNS/Packet.pm b/contrib/DNS-LDNS/lib/DNS/LDNS/Packet.pm new file mode 100644 index 0000000000000..f9875bf5abd09 --- /dev/null +++ b/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.06'; + +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 diff --git a/contrib/DNS-LDNS/lib/DNS/LDNS/RBNode.pm b/contrib/DNS-LDNS/lib/DNS/LDNS/RBNode.pm new file mode 100644 index 0000000000000..31f617cddb1b5 --- /dev/null +++ b/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.06'; + +# 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 diff --git a/contrib/DNS-LDNS/lib/DNS/LDNS/RBTree.pm b/contrib/DNS-LDNS/lib/DNS/LDNS/RBTree.pm new file mode 100644 index 0000000000000..e86bfa8ddfa41 --- /dev/null +++ b/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.06'; + +# 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 diff --git a/contrib/DNS-LDNS/lib/DNS/LDNS/RData.pm b/contrib/DNS-LDNS/lib/DNS/LDNS/RData.pm new file mode 100644 index 0000000000000..76ef5ebac8613 --- /dev/null +++ b/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.06'; + +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 diff --git a/contrib/DNS-LDNS/lib/DNS/LDNS/RR.pm b/contrib/DNS-LDNS/lib/DNS/LDNS/RR.pm new file mode 100644 index 0000000000000..91f34afb40284 --- /dev/null +++ b/contrib/DNS-LDNS/lib/DNS/LDNS/RR.pm @@ -0,0 +1,481 @@ +package DNS::LDNS::RR; + +use 5.008008; +use strict; +use warnings; + +use DNS::LDNS ':all'; +use Carp 'croak'; + +our $VERSION = '0.06'; + +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], $DNS::LDNS::DEFAULT_TTL, + $DNS::LDNS::DEFAULT_ORIGIN, $status); + } + else { + my %args = @_; + + if ($args{str}) { + $rr = _new_from_str($args{str}, + $args{default_ttl} || $DNS::LDNS::DEFAULT_TTL, + $args{origin} || $DNS::LDNS::DEFAULT_ORIGIN, + $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; + } + + $rr = _new_from_file($file, + $args{default_ttl} || $DNS::LDNS::DEFAULT_TTL, + $args{origin} || $DNS::LDNS::DEFAULT_ORIGIN, + $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(new DNS::LDNS::RData( + &LDNS_RDF_TYPE_DNAME, $args{owner})); + } + $rr->set_ttl($args{ttl} || $DNS::LDNS::DEFAULT_TTL); + $rr->set_class($args{class} || $DNS::LDNS::DEFAULT_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 => new DNS::LDNS::RData(LDNS_RDF_TYPE_NAME, 'myzone.'), " # optional + ) + my rr = new DNS::LDNS::RR( + filename => '/path/to/rr', + origin => ...) + my rr = new DNS::LDNS::RR( + file => \*FILE, + origin => ...) + 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_NAME, '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 diff --git a/contrib/DNS-LDNS/lib/DNS/LDNS/RRList.pm b/contrib/DNS-LDNS/lib/DNS/LDNS/RRList.pm new file mode 100644 index 0000000000000..11570acbcdde6 --- /dev/null +++ b/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.06'; + +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 diff --git a/contrib/DNS-LDNS/lib/DNS/LDNS/Resolver.pm b/contrib/DNS-LDNS/lib/DNS/LDNS/Resolver.pm new file mode 100644 index 0000000000000..111e64f0b7ec7 --- /dev/null +++ b/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.06'; + +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 diff --git a/contrib/DNS-LDNS/lib/DNS/LDNS/Zone.pm b/contrib/DNS-LDNS/lib/DNS/LDNS/Zone.pm new file mode 100644 index 0000000000000..a42beace7288b --- /dev/null +++ b/contrib/DNS-LDNS/lib/DNS/LDNS/Zone.pm @@ -0,0 +1,137 @@ +package DNS::LDNS::Zone; + +use 5.008008; +use strict; +use warnings; + +use DNS::LDNS ':all'; + +our $VERSION = '0.06'; + +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; + } + + if ($file) { + $zone = _new_from_file($file, + $args{origin} || $DNS::LDNS::DEFAULT_ORIGIN, + $args{default_ttl} || $DNS::LDNS::DEFAULT_TTL, + $args{class} || $DNS::LDNS::DEFAULT_CLASS, + $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 diff --git a/contrib/DNS-LDNS/ppport.h b/contrib/DNS-LDNS/ppport.h new file mode 100644 index 0000000000000..6d650f440d445 --- /dev/null +++ b/contrib/DNS-LDNS/ppport.h @@ -0,0 +1,7063 @@ +#if 0 +<<'SKIP'; +#endif +/* +---------------------------------------------------------------------- + + ppport.h -- Perl/Pollution/Portability Version 3.19 + + Automatically created by Devel::PPPort running under perl 5.014002. + + Do NOT edit this file directly! -- Edit PPPort_pm.PL and the + includes in parts/inc/ instead. + + Use 'perldoc ppport.h' to view the documentation below. + +---------------------------------------------------------------------- + +SKIP + +=pod + +=head1 NAME + +ppport.h - Perl/Pollution/Portability version 3.19 + +=head1 SYNOPSIS + + perl ppport.h [options] [source files] + + Searches current directory for files if no [source files] are given + + --help show short help + + --version show version + + --patch=file write one patch file with changes + --copy=suffix write changed copies with suffix + --diff=program use diff program and options + + --compat-version=version provide compatibility with Perl version + --cplusplus accept C++ comments + + --quiet don't output anything except fatal errors + --nodiag don't show diagnostics + --nohints don't show hints + --nochanges don't suggest changes + --nofilter don't filter input files + + --strip strip all script and doc functionality from + ppport.h + + --list-provided list provided API + --list-unsupported list unsupported API + --api-info=name show Perl API portability information + +=head1 COMPATIBILITY + +This version of F<ppport.h> is designed to support operation with Perl +installations back to 5.003, and has been tested up to 5.10.0. + +=head1 OPTIONS + +=head2 --help + +Display a brief usage summary. + +=head2 --version + +Display the version of F<ppport.h>. + +=head2 --patch=I<file> + +If this option is given, a single patch file will be created if +any changes are suggested. This requires a working diff program +to be installed on your system. + +=head2 --copy=I<suffix> + +If this option is given, a copy of each file will be saved with +the given suffix that contains the suggested changes. This does +not require any external programs. Note that this does not +automagially add a dot between the original filename and the +suffix. If you want the dot, you have to include it in the option +argument. + +If neither C<--patch> or C<--copy> are given, the default is to +simply print the diffs for each file. This requires either +C<Text::Diff> or a C<diff> program to be installed. + +=head2 --diff=I<program> + +Manually set the diff program and options to use. The default +is to use C<Text::Diff>, when installed, and output unified +context diffs. + +=head2 --compat-version=I<version> + +Tell F<ppport.h> to check for compatibility with the given +Perl version. The default is to check for compatibility with Perl +version 5.003. You can use this option to reduce the output +of F<ppport.h> if you intend to be backward compatible only +down to a certain Perl version. + +=head2 --cplusplus + +Usually, F<ppport.h> will detect C++ style comments and +replace them with C style comments for portability reasons. +Using this option instructs F<ppport.h> to leave C++ +comments untouched. + +=head2 --quiet + +Be quiet. Don't print anything except fatal errors. + +=head2 --nodiag + +Don't output any diagnostic messages. Only portability +alerts will be printed. + +=head2 --nohints + +Don't output any hints. Hints often contain useful portability +notes. Warnings will still be displayed. + +=head2 --nochanges + +Don't suggest any changes. Only give diagnostic output and hints +unless these are also deactivated. + +=head2 --nofilter + +Don't filter the list of input files. By default, files not looking +like source code (i.e. not *.xs, *.c, *.cc, *.cpp or *.h) are skipped. + +=head2 --strip + +Strip all script and documentation functionality from F<ppport.h>. +This reduces the size of F<ppport.h> dramatically and may be useful +if you want to include F<ppport.h> in smaller modules without +increasing their distribution size too much. + +The stripped F<ppport.h> will have a C<--unstrip> option that allows +you to undo the stripping, but only if an appropriate C<Devel::PPPort> +module is installed. + +=head2 --list-provided + +Lists the API elements for which compatibility is provided by +F<ppport.h>. Also lists if it must be explicitly requested, +if it has dependencies, and if there are hints or warnings for it. + +=head2 --list-unsupported + +Lists the API elements that are known not to be supported by +F<ppport.h> and below which version of Perl they probably +won't be available or work. + +=head2 --api-info=I<name> + +Show portability information for API elements matching I<name>. +If I<name> is surrounded by slashes, it is interpreted as a regular +expression. + +=head1 DESCRIPTION + +In order for a Perl extension (XS) module to be as portable as possible +across differing versions of Perl itself, certain steps need to be taken. + +=over 4 + +=item * + +Including this header is the first major one. This alone will give you +access to a large part of the Perl API that hasn't been available in +earlier Perl releases. Use + + perl ppport.h --list-provided + +to see which API elements are provided by ppport.h. + +=item * + +You should avoid using deprecated parts of the API. For example, using +global Perl variables without the C<PL_> prefix is deprecated. Also, +some API functions used to have a C<perl_> prefix. Using this form is +also deprecated. You can safely use the supported API, as F<ppport.h> +will provide wrappers for older Perl versions. + +=item * + +If you use one of a few functions or variables that were not present in +earlier versions of Perl, and that can't be provided using a macro, you +have to explicitly request support for these functions by adding one or +more C<#define>s in your source code before the inclusion of F<ppport.h>. + +These functions or variables will be marked C<explicit> in the list shown +by C<--list-provided>. + +Depending on whether you module has a single or multiple files that +use such functions or variables, you want either C<static> or global +variants. + +For a C<static> function or variable (used only in a single source +file), use: + + #define NEED_function + #define NEED_variable + +For a global function or variable (used in multiple source files), +use: + + #define NEED_function_GLOBAL + #define NEED_variable_GLOBAL + +Note that you mustn't have more than one global request for the +same function or variable in your project. + + Function / Variable Static Request Global Request + ----------------------------------------------------------------------------------------- + PL_parser NEED_PL_parser NEED_PL_parser_GLOBAL + PL_signals NEED_PL_signals NEED_PL_signals_GLOBAL + eval_pv() NEED_eval_pv NEED_eval_pv_GLOBAL + grok_bin() NEED_grok_bin NEED_grok_bin_GLOBAL + grok_hex() NEED_grok_hex NEED_grok_hex_GLOBAL + grok_number() NEED_grok_number NEED_grok_number_GLOBAL + grok_numeric_radix() NEED_grok_numeric_radix NEED_grok_numeric_radix_GLOBAL + grok_oct() NEED_grok_oct NEED_grok_oct_GLOBAL + load_module() NEED_load_module NEED_load_module_GLOBAL + my_snprintf() NEED_my_snprintf NEED_my_snprintf_GLOBAL + my_sprintf() NEED_my_sprintf NEED_my_sprintf_GLOBAL + my_strlcat() NEED_my_strlcat NEED_my_strlcat_GLOBAL + my_strlcpy() NEED_my_strlcpy NEED_my_strlcpy_GLOBAL + newCONSTSUB() NEED_newCONSTSUB NEED_newCONSTSUB_GLOBAL + newRV_noinc() NEED_newRV_noinc NEED_newRV_noinc_GLOBAL + newSV_type() NEED_newSV_type NEED_newSV_type_GLOBAL + newSVpvn_flags() NEED_newSVpvn_flags NEED_newSVpvn_flags_GLOBAL + newSVpvn_share() NEED_newSVpvn_share NEED_newSVpvn_share_GLOBAL + pv_display() NEED_pv_display NEED_pv_display_GLOBAL + pv_escape() NEED_pv_escape NEED_pv_escape_GLOBAL + pv_pretty() NEED_pv_pretty NEED_pv_pretty_GLOBAL + sv_2pv_flags() NEED_sv_2pv_flags NEED_sv_2pv_flags_GLOBAL + sv_2pvbyte() NEED_sv_2pvbyte NEED_sv_2pvbyte_GLOBAL + sv_catpvf_mg() NEED_sv_catpvf_mg NEED_sv_catpvf_mg_GLOBAL + sv_catpvf_mg_nocontext() NEED_sv_catpvf_mg_nocontext NEED_sv_catpvf_mg_nocontext_GLOBAL + sv_pvn_force_flags() NEED_sv_pvn_force_flags NEED_sv_pvn_force_flags_GLOBAL + sv_setpvf_mg() NEED_sv_setpvf_mg NEED_sv_setpvf_mg_GLOBAL + sv_setpvf_mg_nocontext() NEED_sv_setpvf_mg_nocontext NEED_sv_setpvf_mg_nocontext_GLOBAL + vload_module() NEED_vload_module NEED_vload_module_GLOBAL + vnewSVpvf() NEED_vnewSVpvf NEED_vnewSVpvf_GLOBAL + warner() NEED_warner NEED_warner_GLOBAL + +To avoid namespace conflicts, you can change the namespace of the +explicitly exported functions / variables using the C<DPPP_NAMESPACE> +macro. Just C<#define> the macro before including C<ppport.h>: + + #define DPPP_NAMESPACE MyOwnNamespace_ + #include "ppport.h" + +The default namespace is C<DPPP_>. + +=back + +The good thing is that most of the above can be checked by running +F<ppport.h> on your source code. See the next section for +details. + +=head1 EXAMPLES + +To verify whether F<ppport.h> is needed for your module, whether you +should make any changes to your code, and whether any special defines +should be used, F<ppport.h> can be run as a Perl script to check your +source code. Simply say: + + perl ppport.h + +The result will usually be a list of patches suggesting changes +that should at least be acceptable, if not necessarily the most +efficient solution, or a fix for all possible problems. + +If you know that your XS module uses features only available in +newer Perl releases, if you're aware that it uses C++ comments, +and if you want all suggestions as a single patch file, you could +use something like this: + + perl ppport.h --compat-version=5.6.0 --cplusplus --patch=test.diff + +If you only want your code to be scanned without any suggestions +for changes, use: + + perl ppport.h --nochanges + +You can specify a different C<diff> program or options, using +the C<--diff> option: + + perl ppport.h --diff='diff -C 10' + +This would output context diffs with 10 lines of context. + +If you want to create patched copies of your files instead, use: + + perl ppport.h --copy=.new + +To display portability information for the C<newSVpvn> function, +use: + + perl ppport.h --api-info=newSVpvn + +Since the argument to C<--api-info> can be a regular expression, +you can use + + perl ppport.h --api-info=/_nomg$/ + +to display portability information for all C<_nomg> functions or + + perl ppport.h --api-info=/./ + +to display information for all known API elements. + +=head1 BUGS + +If this version of F<ppport.h> is causing failure during +the compilation of this module, please check if newer versions +of either this module or C<Devel::PPPort> are available on CPAN +before sending a bug report. + +If F<ppport.h> was generated using the latest version of +C<Devel::PPPort> and is causing failure of this module, please +file a bug report using the CPAN Request Tracker at L<http://rt.cpan.org/>. + +Please include the following information: + +=over 4 + +=item 1. + +The complete output from running "perl -V" + +=item 2. + +This file. + +=item 3. + +The name and version of the module you were trying to build. + +=item 4. + +A full log of the build that failed. + +=item 5. + +Any other information that you think could be relevant. + +=back + +For the latest version of this code, please get the C<Devel::PPPort> +module from CPAN. + +=head1 COPYRIGHT + +Version 3.x, Copyright (c) 2004-2009, Marcus Holland-Moritz. + +Version 2.x, Copyright (C) 2001, Paul Marquess. + +Version 1.x, Copyright (C) 1999, Kenneth Albanowski. + +This program is free software; you can redistribute it and/or +modify it under the same terms as Perl itself. + +=head1 SEE ALSO + +See L<Devel::PPPort>. + +=cut + +use strict; + +# Disable broken TRIE-optimization +BEGIN { eval '${^RE_TRIE_MAXBUF} = -1' if $] >= 5.009004 && $] <= 5.009005 } + +my $VERSION = 3.19; + +my %opt = ( + quiet => 0, + diag => 1, + hints => 1, + changes => 1, + cplusplus => 0, + filter => 1, + strip => 0, + version => 0, +); + +my($ppport) = $0 =~ /([\w.]+)$/; +my $LF = '(?:\r\n|[\r\n])'; # line feed +my $HS = "[ \t]"; # horizontal whitespace + +# Never use C comments in this file! +my $ccs = '/'.'*'; +my $cce = '*'.'/'; +my $rccs = quotemeta $ccs; +my $rcce = quotemeta $cce; + +eval { + require Getopt::Long; + Getopt::Long::GetOptions(\%opt, qw( + help quiet diag! filter! hints! changes! cplusplus strip version + patch=s copy=s diff=s compat-version=s + list-provided list-unsupported api-info=s + )) or usage(); +}; + +if ($@ and grep /^-/, @ARGV) { + usage() if "@ARGV" =~ /^--?h(?:elp)?$/; + die "Getopt::Long not found. Please don't use any options.\n"; +} + +if ($opt{version}) { + print "This is $0 $VERSION.\n"; + exit 0; +} + +usage() if $opt{help}; +strip() if $opt{strip}; + +if (exists $opt{'compat-version'}) { + my($r,$v,$s) = eval { parse_version($opt{'compat-version'}) }; + if ($@) { + die "Invalid version number format: '$opt{'compat-version'}'\n"; + } + die "Only Perl 5 is supported\n" if $r != 5; + die "Invalid version number: $opt{'compat-version'}\n" if $v >= 1000 || $s >= 1000; + $opt{'compat-version'} = sprintf "%d.%03d%03d", $r, $v, $s; +} +else { + $opt{'compat-version'} = 5; +} + +my %API = map { /^(\w+)\|([^|]*)\|([^|]*)\|(\w*)$/ + ? ( $1 => { + ($2 ? ( base => $2 ) : ()), + ($3 ? ( todo => $3 ) : ()), + (index($4, 'v') >= 0 ? ( varargs => 1 ) : ()), + (index($4, 'p') >= 0 ? ( provided => 1 ) : ()), + (index($4, 'n') >= 0 ? ( nothxarg => 1 ) : ()), + } ) + : die "invalid spec: $_" } qw( +AvFILLp|5.004050||p +AvFILL||| +CLASS|||n +CPERLscope|5.005000||p +CX_CURPAD_SAVE||| +CX_CURPAD_SV||| +CopFILEAV|5.006000||p +CopFILEGV_set|5.006000||p +CopFILEGV|5.006000||p +CopFILESV|5.006000||p +CopFILE_set|5.006000||p +CopFILE|5.006000||p +CopSTASHPV_set|5.006000||p +CopSTASHPV|5.006000||p +CopSTASH_eq|5.006000||p +CopSTASH_set|5.006000||p +CopSTASH|5.006000||p +CopyD|5.009002||p +Copy||| +CvPADLIST||| +CvSTASH||| +CvWEAKOUTSIDE||| +DEFSV_set|5.011000||p +DEFSV|5.004050||p +END_EXTERN_C|5.005000||p +ENTER||| +ERRSV|5.004050||p +EXTEND||| +EXTERN_C|5.005000||p +F0convert|||n +FREETMPS||| +GIMME_V||5.004000|n +GIMME|||n +GROK_NUMERIC_RADIX|5.007002||p +G_ARRAY||| +G_DISCARD||| +G_EVAL||| +G_METHOD|5.006001||p +G_NOARGS||| +G_SCALAR||| +G_VOID||5.004000| +GetVars||| +GvSVn|5.009003||p +GvSV||| +Gv_AMupdate||| +HEf_SVKEY||5.004000| +HeHASH||5.004000| +HeKEY||5.004000| +HeKLEN||5.004000| +HePV||5.004000| +HeSVKEY_force||5.004000| +HeSVKEY_set||5.004000| +HeSVKEY||5.004000| +HeUTF8||5.011000| +HeVAL||5.004000| +HvNAMELEN_get|5.009003||p +HvNAME_get|5.009003||p +HvNAME||| +INT2PTR|5.006000||p +IN_LOCALE_COMPILETIME|5.007002||p +IN_LOCALE_RUNTIME|5.007002||p +IN_LOCALE|5.007002||p +IN_PERL_COMPILETIME|5.008001||p +IS_NUMBER_GREATER_THAN_UV_MAX|5.007002||p +IS_NUMBER_INFINITY|5.007002||p +IS_NUMBER_IN_UV|5.007002||p +IS_NUMBER_NAN|5.007003||p +IS_NUMBER_NEG|5.007002||p +IS_NUMBER_NOT_INT|5.007002||p +IVSIZE|5.006000||p +IVTYPE|5.006000||p +IVdf|5.006000||p +LEAVE||| +LVRET||| +MARK||| +MULTICALL||5.011000| +MY_CXT_CLONE|5.009002||p +MY_CXT_INIT|5.007003||p +MY_CXT|5.007003||p +MoveD|5.009002||p +Move||| +NOOP|5.005000||p +NUM2PTR|5.006000||p +NVTYPE|5.006000||p +NVef|5.006001||p +NVff|5.006001||p +NVgf|5.006001||p +Newxc|5.009003||p +Newxz|5.009003||p +Newx|5.009003||p +Nullav||| +Nullch||| +Nullcv||| +Nullhv||| +Nullsv||| +ORIGMARK||| +PAD_BASE_SV||| +PAD_CLONE_VARS||| +PAD_COMPNAME_FLAGS||| +PAD_COMPNAME_GEN_set||| +PAD_COMPNAME_GEN||| +PAD_COMPNAME_OURSTASH||| +PAD_COMPNAME_PV||| +PAD_COMPNAME_TYPE||| +PAD_DUP||| +PAD_RESTORE_LOCAL||| +PAD_SAVE_LOCAL||| +PAD_SAVE_SETNULLPAD||| +PAD_SETSV||| +PAD_SET_CUR_NOSAVE||| +PAD_SET_CUR||| +PAD_SVl||| +PAD_SV||| +PERLIO_FUNCS_CAST|5.009003||p +PERLIO_FUNCS_DECL|5.009003||p +PERL_ABS|5.008001||p +PERL_BCDVERSION|5.011000||p +PERL_GCC_BRACE_GROUPS_FORBIDDEN|5.008001||p +PERL_HASH|5.004000||p +PERL_INT_MAX|5.004000||p +PERL_INT_MIN|5.004000||p +PERL_LONG_MAX|5.004000||p +PERL_LONG_MIN|5.004000||p +PERL_MAGIC_arylen|5.007002||p +PERL_MAGIC_backref|5.007002||p +PERL_MAGIC_bm|5.007002||p +PERL_MAGIC_collxfrm|5.007002||p +PERL_MAGIC_dbfile|5.007002||p +PERL_MAGIC_dbline|5.007002||p +PERL_MAGIC_defelem|5.007002||p +PERL_MAGIC_envelem|5.007002||p +PERL_MAGIC_env|5.007002||p +PERL_MAGIC_ext|5.007002||p +PERL_MAGIC_fm|5.007002||p +PERL_MAGIC_glob|5.011000||p +PERL_MAGIC_isaelem|5.007002||p +PERL_MAGIC_isa|5.007002||p +PERL_MAGIC_mutex|5.011000||p +PERL_MAGIC_nkeys|5.007002||p +PERL_MAGIC_overload_elem|5.007002||p +PERL_MAGIC_overload_table|5.007002||p +PERL_MAGIC_overload|5.007002||p +PERL_MAGIC_pos|5.007002||p +PERL_MAGIC_qr|5.007002||p +PERL_MAGIC_regdata|5.007002||p +PERL_MAGIC_regdatum|5.007002||p +PERL_MAGIC_regex_global|5.007002||p +PERL_MAGIC_shared_scalar|5.007003||p +PERL_MAGIC_shared|5.007003||p +PERL_MAGIC_sigelem|5.007002||p +PERL_MAGIC_sig|5.007002||p +PERL_MAGIC_substr|5.007002||p +PERL_MAGIC_sv|5.007002||p +PERL_MAGIC_taint|5.007002||p +PERL_MAGIC_tiedelem|5.007002||p +PERL_MAGIC_tiedscalar|5.007002||p +PERL_MAGIC_tied|5.007002||p +PERL_MAGIC_utf8|5.008001||p +PERL_MAGIC_uvar_elem|5.007003||p +PERL_MAGIC_uvar|5.007002||p +PERL_MAGIC_vec|5.007002||p +PERL_MAGIC_vstring|5.008001||p +PERL_PV_ESCAPE_ALL|5.009004||p +PERL_PV_ESCAPE_FIRSTCHAR|5.009004||p +PERL_PV_ESCAPE_NOBACKSLASH|5.009004||p +PERL_PV_ESCAPE_NOCLEAR|5.009004||p +PERL_PV_ESCAPE_QUOTE|5.009004||p +PERL_PV_ESCAPE_RE|5.009005||p +PERL_PV_ESCAPE_UNI_DETECT|5.009004||p +PERL_PV_ESCAPE_UNI|5.009004||p +PERL_PV_PRETTY_DUMP|5.009004||p +PERL_PV_PRETTY_ELLIPSES|5.010000||p +PERL_PV_PRETTY_LTGT|5.009004||p +PERL_PV_PRETTY_NOCLEAR|5.010000||p +PERL_PV_PRETTY_QUOTE|5.009004||p +PERL_PV_PRETTY_REGPROP|5.009004||p +PERL_QUAD_MAX|5.004000||p +PERL_QUAD_MIN|5.004000||p +PERL_REVISION|5.006000||p +PERL_SCAN_ALLOW_UNDERSCORES|5.007003||p +PERL_SCAN_DISALLOW_PREFIX|5.007003||p +PERL_SCAN_GREATER_THAN_UV_MAX|5.007003||p +PERL_SCAN_SILENT_ILLDIGIT|5.008001||p +PERL_SHORT_MAX|5.004000||p +PERL_SHORT_MIN|5.004000||p +PERL_SIGNALS_UNSAFE_FLAG|5.008001||p +PERL_SUBVERSION|5.006000||p +PERL_SYS_INIT3||5.006000| +PERL_SYS_INIT||| +PERL_SYS_TERM||5.011000| +PERL_UCHAR_MAX|5.004000||p +PERL_UCHAR_MIN|5.004000||p +PERL_UINT_MAX|5.004000||p +PERL_UINT_MIN|5.004000||p +PERL_ULONG_MAX|5.004000||p +PERL_ULONG_MIN|5.004000||p +PERL_UNUSED_ARG|5.009003||p +PERL_UNUSED_CONTEXT|5.009004||p +PERL_UNUSED_DECL|5.007002||p +PERL_UNUSED_VAR|5.007002||p +PERL_UQUAD_MAX|5.004000||p +PERL_UQUAD_MIN|5.004000||p +PERL_USE_GCC_BRACE_GROUPS|5.009004||p +PERL_USHORT_MAX|5.004000||p +PERL_USHORT_MIN|5.004000||p +PERL_VERSION|5.006000||p +PL_DBsignal|5.005000||p +PL_DBsingle|||pn +PL_DBsub|||pn +PL_DBtrace|||pn +PL_Sv|5.005000||p +PL_bufend|5.011000||p +PL_bufptr|5.011000||p +PL_compiling|5.004050||p +PL_copline|5.011000||p +PL_curcop|5.004050||p +PL_curstash|5.004050||p +PL_debstash|5.004050||p +PL_defgv|5.004050||p +PL_diehook|5.004050||p +PL_dirty|5.004050||p +PL_dowarn|||pn +PL_errgv|5.004050||p +PL_error_count|5.011000||p +PL_expect|5.011000||p +PL_hexdigit|5.005000||p +PL_hints|5.005000||p +PL_in_my_stash|5.011000||p +PL_in_my|5.011000||p +PL_last_in_gv|||n +PL_laststatval|5.005000||p +PL_lex_state|5.011000||p +PL_lex_stuff|5.011000||p +PL_linestr|5.011000||p +PL_modglobal||5.005000|n +PL_na|5.004050||pn +PL_no_modify|5.006000||p +PL_ofsgv|||n +PL_parser|5.009005||p +PL_perl_destruct_level|5.004050||p +PL_perldb|5.004050||p +PL_ppaddr|5.006000||p +PL_rsfp_filters|5.004050||p +PL_rsfp|5.004050||p +PL_rs|||n +PL_signals|5.008001||p +PL_stack_base|5.004050||p +PL_stack_sp|5.004050||p +PL_statcache|5.005000||p +PL_stdingv|5.004050||p +PL_sv_arenaroot|5.004050||p +PL_sv_no|5.004050||pn +PL_sv_undef|5.004050||pn +PL_sv_yes|5.004050||pn +PL_tainted|5.004050||p +PL_tainting|5.004050||p +PL_tokenbuf|5.011000||p +POP_MULTICALL||5.011000| +POPi|||n +POPl|||n +POPn|||n +POPpbytex||5.007001|n +POPpx||5.005030|n +POPp|||n +POPs|||n +PTR2IV|5.006000||p +PTR2NV|5.006000||p +PTR2UV|5.006000||p +PTR2nat|5.009003||p +PTR2ul|5.007001||p +PTRV|5.006000||p +PUSHMARK||| +PUSH_MULTICALL||5.011000| +PUSHi||| +PUSHmortal|5.009002||p +PUSHn||| +PUSHp||| +PUSHs||| +PUSHu|5.004000||p +PUTBACK||| +PerlIO_clearerr||5.007003| +PerlIO_close||5.007003| +PerlIO_context_layers||5.009004| +PerlIO_eof||5.007003| +PerlIO_error||5.007003| +PerlIO_fileno||5.007003| +PerlIO_fill||5.007003| +PerlIO_flush||5.007003| +PerlIO_get_base||5.007003| +PerlIO_get_bufsiz||5.007003| +PerlIO_get_cnt||5.007003| +PerlIO_get_ptr||5.007003| +PerlIO_read||5.007003| +PerlIO_seek||5.007003| +PerlIO_set_cnt||5.007003| +PerlIO_set_ptrcnt||5.007003| +PerlIO_setlinebuf||5.007003| +PerlIO_stderr||5.007003| +PerlIO_stdin||5.007003| +PerlIO_stdout||5.007003| +PerlIO_tell||5.007003| +PerlIO_unread||5.007003| +PerlIO_write||5.007003| +Perl_signbit||5.009005|n +PoisonFree|5.009004||p +PoisonNew|5.009004||p +PoisonWith|5.009004||p +Poison|5.008000||p +RETVAL|||n +Renewc||| +Renew||| +SAVECLEARSV||| +SAVECOMPPAD||| +SAVEPADSV||| +SAVETMPS||| +SAVE_DEFSV|5.004050||p +SPAGAIN||| +SP||| +START_EXTERN_C|5.005000||p +START_MY_CXT|5.007003||p +STMT_END|||p +STMT_START|||p +STR_WITH_LEN|5.009003||p +ST||| +SV_CONST_RETURN|5.009003||p +SV_COW_DROP_PV|5.008001||p +SV_COW_SHARED_HASH_KEYS|5.009005||p +SV_GMAGIC|5.007002||p +SV_HAS_TRAILING_NUL|5.009004||p +SV_IMMEDIATE_UNREF|5.007001||p +SV_MUTABLE_RETURN|5.009003||p +SV_NOSTEAL|5.009002||p +SV_SMAGIC|5.009003||p +SV_UTF8_NO_ENCODING|5.008001||p +SVfARG|5.009005||p +SVf_UTF8|5.006000||p +SVf|5.006000||p +SVt_IV||| +SVt_NV||| +SVt_PVAV||| +SVt_PVCV||| +SVt_PVHV||| +SVt_PVMG||| +SVt_PV||| +Safefree||| +Slab_Alloc||| +Slab_Free||| +Slab_to_rw||| +StructCopy||| +SvCUR_set||| +SvCUR||| +SvEND||| +SvGAMAGIC||5.006001| +SvGETMAGIC|5.004050||p +SvGROW||| +SvIOK_UV||5.006000| +SvIOK_notUV||5.006000| +SvIOK_off||| +SvIOK_only_UV||5.006000| +SvIOK_only||| +SvIOK_on||| +SvIOKp||| +SvIOK||| +SvIVX||| +SvIV_nomg|5.009001||p +SvIV_set||| +SvIVx||| +SvIV||| +SvIsCOW_shared_hash||5.008003| +SvIsCOW||5.008003| +SvLEN_set||| +SvLEN||| +SvLOCK||5.007003| +SvMAGIC_set|5.009003||p +SvNIOK_off||| +SvNIOKp||| +SvNIOK||| +SvNOK_off||| +SvNOK_only||| +SvNOK_on||| +SvNOKp||| +SvNOK||| +SvNVX||| +SvNV_set||| +SvNVx||| +SvNV||| +SvOK||| +SvOOK_offset||5.011000| +SvOOK||| +SvPOK_off||| +SvPOK_only_UTF8||5.006000| +SvPOK_only||| +SvPOK_on||| +SvPOKp||| +SvPOK||| +SvPVX_const|5.009003||p +SvPVX_mutable|5.009003||p +SvPVX||| +SvPV_const|5.009003||p +SvPV_flags_const_nolen|5.009003||p +SvPV_flags_const|5.009003||p +SvPV_flags_mutable|5.009003||p +SvPV_flags|5.007002||p +SvPV_force_flags_mutable|5.009003||p +SvPV_force_flags_nolen|5.009003||p +SvPV_force_flags|5.007002||p +SvPV_force_mutable|5.009003||p +SvPV_force_nolen|5.009003||p +SvPV_force_nomg_nolen|5.009003||p +SvPV_force_nomg|5.007002||p +SvPV_force|||p +SvPV_mutable|5.009003||p +SvPV_nolen_const|5.009003||p +SvPV_nolen|5.006000||p +SvPV_nomg_const_nolen|5.009003||p +SvPV_nomg_const|5.009003||p +SvPV_nomg|5.007002||p +SvPV_renew|5.009003||p +SvPV_set||| +SvPVbyte_force||5.009002| +SvPVbyte_nolen||5.006000| +SvPVbytex_force||5.006000| +SvPVbytex||5.006000| +SvPVbyte|5.006000||p +SvPVutf8_force||5.006000| +SvPVutf8_nolen||5.006000| +SvPVutf8x_force||5.006000| +SvPVutf8x||5.006000| +SvPVutf8||5.006000| +SvPVx||| +SvPV||| +SvREFCNT_dec||| +SvREFCNT_inc_NN|5.009004||p +SvREFCNT_inc_simple_NN|5.009004||p +SvREFCNT_inc_simple_void_NN|5.009004||p +SvREFCNT_inc_simple_void|5.009004||p +SvREFCNT_inc_simple|5.009004||p +SvREFCNT_inc_void_NN|5.009004||p +SvREFCNT_inc_void|5.009004||p +SvREFCNT_inc|||p +SvREFCNT||| +SvROK_off||| +SvROK_on||| +SvROK||| +SvRV_set|5.009003||p +SvRV||| +SvRXOK||5.009005| +SvRX||5.009005| +SvSETMAGIC||| +SvSHARED_HASH|5.009003||p +SvSHARE||5.007003| +SvSTASH_set|5.009003||p +SvSTASH||| +SvSetMagicSV_nosteal||5.004000| +SvSetMagicSV||5.004000| +SvSetSV_nosteal||5.004000| +SvSetSV||| +SvTAINTED_off||5.004000| +SvTAINTED_on||5.004000| +SvTAINTED||5.004000| +SvTAINT||| +SvTRUE||| +SvTYPE||| +SvUNLOCK||5.007003| +SvUOK|5.007001|5.006000|p +SvUPGRADE||| +SvUTF8_off||5.006000| +SvUTF8_on||5.006000| +SvUTF8||5.006000| +SvUVXx|5.004000||p +SvUVX|5.004000||p +SvUV_nomg|5.009001||p +SvUV_set|5.009003||p +SvUVx|5.004000||p +SvUV|5.004000||p +SvVOK||5.008001| +SvVSTRING_mg|5.009004||p +THIS|||n +UNDERBAR|5.009002||p +UTF8_MAXBYTES|5.009002||p +UVSIZE|5.006000||p +UVTYPE|5.006000||p +UVXf|5.007001||p +UVof|5.006000||p +UVuf|5.006000||p +UVxf|5.006000||p +WARN_ALL|5.006000||p +WARN_AMBIGUOUS|5.006000||p +WARN_ASSERTIONS|5.011000||p +WARN_BAREWORD|5.006000||p +WARN_CLOSED|5.006000||p +WARN_CLOSURE|5.006000||p +WARN_DEBUGGING|5.006000||p +WARN_DEPRECATED|5.006000||p +WARN_DIGIT|5.006000||p +WARN_EXEC|5.006000||p +WARN_EXITING|5.006000||p +WARN_GLOB|5.006000||p +WARN_INPLACE|5.006000||p +WARN_INTERNAL|5.006000||p +WARN_IO|5.006000||p +WARN_LAYER|5.008000||p +WARN_MALLOC|5.006000||p +WARN_MISC|5.006000||p +WARN_NEWLINE|5.006000||p +WARN_NUMERIC|5.006000||p +WARN_ONCE|5.006000||p +WARN_OVERFLOW|5.006000||p +WARN_PACK|5.006000||p +WARN_PARENTHESIS|5.006000||p +WARN_PIPE|5.006000||p +WARN_PORTABLE|5.006000||p +WARN_PRECEDENCE|5.006000||p +WARN_PRINTF|5.006000||p +WARN_PROTOTYPE|5.006000||p +WARN_QW|5.006000||p +WARN_RECURSION|5.006000||p +WARN_REDEFINE|5.006000||p +WARN_REGEXP|5.006000||p +WARN_RESERVED|5.006000||p +WARN_SEMICOLON|5.006000||p +WARN_SEVERE|5.006000||p +WARN_SIGNAL|5.006000||p +WARN_SUBSTR|5.006000||p +WARN_SYNTAX|5.006000||p +WARN_TAINT|5.006000||p +WARN_THREADS|5.008000||p +WARN_UNINITIALIZED|5.006000||p +WARN_UNOPENED|5.006000||p +WARN_UNPACK|5.006000||p +WARN_UNTIE|5.006000||p +WARN_UTF8|5.006000||p +WARN_VOID|5.006000||p +XCPT_CATCH|5.009002||p +XCPT_RETHROW|5.009002||p +XCPT_TRY_END|5.009002||p +XCPT_TRY_START|5.009002||p +XPUSHi||| +XPUSHmortal|5.009002||p +XPUSHn||| +XPUSHp||| +XPUSHs||| +XPUSHu|5.004000||p +XSPROTO|5.010000||p +XSRETURN_EMPTY||| +XSRETURN_IV||| +XSRETURN_NO||| +XSRETURN_NV||| +XSRETURN_PV||| +XSRETURN_UNDEF||| +XSRETURN_UV|5.008001||p +XSRETURN_YES||| +XSRETURN|||p +XST_mIV||| +XST_mNO||| +XST_mNV||| +XST_mPV||| +XST_mUNDEF||| +XST_mUV|5.008001||p +XST_mYES||| +XS_VERSION_BOOTCHECK||| +XS_VERSION||| +XSprePUSH|5.006000||p +XS||| +ZeroD|5.009002||p +Zero||| +_aMY_CXT|5.007003||p +_pMY_CXT|5.007003||p +aMY_CXT_|5.007003||p +aMY_CXT|5.007003||p +aTHXR_|5.011000||p +aTHXR|5.011000||p +aTHX_|5.006000||p +aTHX|5.006000||p +add_data|||n +addmad||| +allocmy||| +amagic_call||| +amagic_cmp_locale||| +amagic_cmp||| +amagic_i_ncmp||| +amagic_ncmp||| +any_dup||| +ao||| +append_elem||| +append_list||| +append_madprops||| +apply_attrs_my||| +apply_attrs_string||5.006001| +apply_attrs||| +apply||| +atfork_lock||5.007003|n +atfork_unlock||5.007003|n +av_arylen_p||5.009003| +av_clear||| +av_create_and_push||5.009005| +av_create_and_unshift_one||5.009005| +av_delete||5.006000| +av_exists||5.006000| +av_extend||| +av_fetch||| +av_fill||| +av_iter_p||5.011000| +av_len||| +av_make||| +av_pop||| +av_push||| +av_reify||| +av_shift||| +av_store||| +av_undef||| +av_unshift||| +ax|||n +bad_type||| +bind_match||| +block_end||| +block_gimme||5.004000| +block_start||| +boolSV|5.004000||p +boot_core_PerlIO||| +boot_core_UNIVERSAL||| +boot_core_mro||| +bytes_from_utf8||5.007001| +bytes_to_uni|||n +bytes_to_utf8||5.006001| +call_argv|5.006000||p +call_atexit||5.006000| +call_list||5.004000| +call_method|5.006000||p +call_pv|5.006000||p +call_sv|5.006000||p +calloc||5.007002|n +cando||| +cast_i32||5.006000| +cast_iv||5.006000| +cast_ulong||5.006000| +cast_uv||5.006000| +check_type_and_open||| +check_uni||| +checkcomma||| +checkposixcc||| +ckWARN|5.006000||p +ck_anoncode||| +ck_bitop||| +ck_concat||| +ck_defined||| +ck_delete||| +ck_die||| +ck_each||| +ck_eof||| +ck_eval||| +ck_exec||| +ck_exists||| +ck_exit||| +ck_ftst||| +ck_fun||| +ck_glob||| +ck_grep||| +ck_index||| +ck_join||| +ck_lfun||| +ck_listiob||| +ck_match||| +ck_method||| +ck_null||| +ck_open||| +ck_readline||| +ck_repeat||| +ck_require||| +ck_return||| +ck_rfun||| +ck_rvconst||| +ck_sassign||| +ck_select||| +ck_shift||| +ck_sort||| +ck_spair||| +ck_split||| +ck_subr||| +ck_substr||| +ck_svconst||| +ck_trunc||| +ck_unpack||| +ckwarn_d||5.009003| +ckwarn||5.009003| +cl_and|||n +cl_anything|||n +cl_init_zero|||n +cl_init|||n +cl_is_anything|||n +cl_or|||n +clear_placeholders||| +closest_cop||| +convert||| +cop_free||| +cr_textfilter||| +create_eval_scope||| +croak_nocontext|||vn +croak_xs_usage||5.011000| +croak|||v +csighandler||5.009003|n +curmad||| +custom_op_desc||5.007003| +custom_op_name||5.007003| +cv_ckproto_len||| +cv_clone||| +cv_const_sv||5.004000| +cv_dump||| +cv_undef||| +cx_dump||5.005000| +cx_dup||| +cxinc||| +dAXMARK|5.009003||p +dAX|5.007002||p +dITEMS|5.007002||p +dMARK||| +dMULTICALL||5.009003| +dMY_CXT_SV|5.007003||p +dMY_CXT|5.007003||p +dNOOP|5.006000||p +dORIGMARK||| +dSP||| +dTHR|5.004050||p +dTHXR|5.011000||p +dTHXa|5.006000||p +dTHXoa|5.006000||p +dTHX|5.006000||p +dUNDERBAR|5.009002||p +dVAR|5.009003||p +dXCPT|5.009002||p +dXSARGS||| +dXSI32||| +dXSTARG|5.006000||p +deb_curcv||| +deb_nocontext|||vn +deb_stack_all||| +deb_stack_n||| +debop||5.005000| +debprofdump||5.005000| +debprof||| +debstackptrs||5.007003| +debstack||5.007003| +debug_start_match||| +deb||5.007003|v +del_sv||| +delete_eval_scope||| +delimcpy||5.004000| +deprecate_old||| +deprecate||| +despatch_signals||5.007001| +destroy_matcher||| +die_nocontext|||vn +die_where||| +die|||v +dirp_dup||| +div128||| +djSP||| +do_aexec5||| +do_aexec||| +do_aspawn||| +do_binmode||5.004050| +do_chomp||| +do_chop||| +do_close||| +do_dump_pad||| +do_eof||| +do_exec3||| +do_execfree||| +do_exec||| +do_gv_dump||5.006000| +do_gvgv_dump||5.006000| +do_hv_dump||5.006000| +do_ipcctl||| +do_ipcget||| +do_join||| +do_kv||| +do_magic_dump||5.006000| +do_msgrcv||| +do_msgsnd||| +do_oddball||| +do_op_dump||5.006000| +do_op_xmldump||| +do_open9||5.006000| +do_openn||5.007001| +do_open||5.004000| +do_pmop_dump||5.006000| +do_pmop_xmldump||| +do_print||| +do_readline||| +do_seek||| +do_semop||| +do_shmio||| +do_smartmatch||| +do_spawn_nowait||| +do_spawn||| +do_sprintf||| +do_sv_dump||5.006000| +do_sysseek||| +do_tell||| +do_trans_complex_utf8||| +do_trans_complex||| +do_trans_count_utf8||| +do_trans_count||| +do_trans_simple_utf8||| +do_trans_simple||| +do_trans||| +do_vecget||| +do_vecset||| +do_vop||| +docatch||| +doeval||| +dofile||| +dofindlabel||| +doform||| +doing_taint||5.008001|n +dooneliner||| +doopen_pm||| +doparseform||| +dopoptoeval||| +dopoptogiven||| +dopoptolabel||| +dopoptoloop||| +dopoptosub_at||| +dopoptowhen||| +doref||5.009003| +dounwind||| +dowantarray||| +dump_all||5.006000| +dump_eval||5.006000| +dump_exec_pos||| +dump_fds||| +dump_form||5.006000| +dump_indent||5.006000|v +dump_mstats||| +dump_packsubs||5.006000| +dump_sub||5.006000| +dump_sv_child||| +dump_trie_interim_list||| +dump_trie_interim_table||| +dump_trie||| +dump_vindent||5.006000| +dumpuntil||| +dup_attrlist||| +emulate_cop_io||| +eval_pv|5.006000||p +eval_sv|5.006000||p +exec_failed||| +expect_number||| +fbm_compile||5.005000| +fbm_instr||5.005000| +feature_is_enabled||| +fetch_cop_label||5.011000| +filter_add||| +filter_del||| +filter_gets||| +filter_read||| +find_and_forget_pmops||| +find_array_subscript||| +find_beginning||| +find_byclass||| +find_hash_subscript||| +find_in_my_stash||| +find_runcv||5.008001| +find_rundefsvoffset||5.009002| +find_script||| +find_uninit_var||| +first_symbol|||n +fold_constants||| +forbid_setid||| +force_ident||| +force_list||| +force_next||| +force_version||| +force_word||| +forget_pmop||| +form_nocontext|||vn +form||5.004000|v +fp_dup||| +fprintf_nocontext|||vn +free_global_struct||| +free_tied_hv_pool||| +free_tmps||| +gen_constant_list||| +get_arena||| +get_aux_mg||| +get_av|5.006000||p +get_context||5.006000|n +get_cvn_flags||5.009005| +get_cv|5.006000||p +get_db_sub||| +get_debug_opts||| +get_hash_seed||| +get_hv|5.006000||p +get_isa_hash||| +get_mstats||| +get_no_modify||| +get_num||| +get_op_descs||5.005000| +get_op_names||5.005000| +get_opargs||| +get_ppaddr||5.006000| +get_re_arg||| +get_sv|5.006000||p +get_vtbl||5.005030| +getcwd_sv||5.007002| +getenv_len||| +glob_2number||| +glob_assign_glob||| +glob_assign_ref||| +gp_dup||| +gp_free||| +gp_ref||| +grok_bin|5.007003||p +grok_hex|5.007003||p +grok_number|5.007002||p +grok_numeric_radix|5.007002||p +grok_oct|5.007003||p +group_end||| +gv_AVadd||| +gv_HVadd||| +gv_IOadd||| +gv_SVadd||| +gv_autoload4||5.004000| +gv_check||| +gv_const_sv||5.009003| +gv_dump||5.006000| +gv_efullname3||5.004000| +gv_efullname4||5.006001| +gv_efullname||| +gv_ename||| +gv_fetchfile_flags||5.009005| +gv_fetchfile||| +gv_fetchmeth_autoload||5.007003| +gv_fetchmethod_autoload||5.004000| +gv_fetchmethod_flags||5.011000| +gv_fetchmethod||| +gv_fetchmeth||| +gv_fetchpvn_flags|5.009002||p +gv_fetchpvs|5.009004||p +gv_fetchpv||| +gv_fetchsv||5.009002| +gv_fullname3||5.004000| +gv_fullname4||5.006001| +gv_fullname||| +gv_get_super_pkg||| +gv_handler||5.007001| +gv_init_sv||| +gv_init||| +gv_name_set||5.009004| +gv_stashpvn|5.004000||p +gv_stashpvs|5.009003||p +gv_stashpv||| +gv_stashsv||| +he_dup||| +hek_dup||| +hfreeentries||| +hsplit||| +hv_assert||5.011000| +hv_auxinit|||n +hv_backreferences_p||| +hv_clear_placeholders||5.009001| +hv_clear||| +hv_common_key_len||5.010000| +hv_common||5.010000| +hv_copy_hints_hv||| +hv_delayfree_ent||5.004000| +hv_delete_common||| +hv_delete_ent||5.004000| +hv_delete||| +hv_eiter_p||5.009003| +hv_eiter_set||5.009003| +hv_exists_ent||5.004000| +hv_exists||| +hv_fetch_ent||5.004000| +hv_fetchs|5.009003||p +hv_fetch||| +hv_free_ent||5.004000| +hv_iterinit||| +hv_iterkeysv||5.004000| +hv_iterkey||| +hv_iternext_flags||5.008000| +hv_iternextsv||| +hv_iternext||| +hv_iterval||| +hv_kill_backrefs||| +hv_ksplit||5.004000| +hv_magic_check|||n +hv_magic||| +hv_name_set||5.009003| +hv_notallowed||| +hv_placeholders_get||5.009003| +hv_placeholders_p||5.009003| +hv_placeholders_set||5.009003| +hv_riter_p||5.009003| +hv_riter_set||5.009003| +hv_scalar||5.009001| +hv_store_ent||5.004000| +hv_store_flags||5.008000| +hv_stores|5.009004||p +hv_store||| +hv_undef||| +ibcmp_locale||5.004000| +ibcmp_utf8||5.007003| +ibcmp||| +incline||| +incpush_if_exists||| +incpush_use_sep||| +incpush||| +ingroup||| +init_argv_symbols||| +init_debugger||| +init_global_struct||| +init_i18nl10n||5.006000| +init_i18nl14n||5.006000| +init_ids||| +init_interp||| +init_main_stash||| +init_perllib||| +init_postdump_symbols||| +init_predump_symbols||| +init_stacks||5.005000| +init_tm||5.007002| +instr||| +intro_my||| +intuit_method||| +intuit_more||| +invert||| +io_close||| +isALNUMC|5.006000||p +isALNUM||| +isALPHA||| +isASCII|5.006000||p +isBLANK|5.006001||p +isCNTRL|5.006000||p +isDIGIT||| +isGRAPH|5.006000||p +isGV_with_GP|5.009004||p +isLOWER||| +isPRINT|5.004000||p +isPSXSPC|5.006001||p +isPUNCT|5.006000||p +isSPACE||| +isUPPER||| +isXDIGIT|5.006000||p +is_an_int||| +is_gv_magical_sv||| +is_handle_constructor|||n +is_list_assignment||| +is_lvalue_sub||5.007001| +is_uni_alnum_lc||5.006000| +is_uni_alnumc_lc||5.006000| +is_uni_alnumc||5.006000| +is_uni_alnum||5.006000| +is_uni_alpha_lc||5.006000| +is_uni_alpha||5.006000| +is_uni_ascii_lc||5.006000| +is_uni_ascii||5.006000| +is_uni_cntrl_lc||5.006000| +is_uni_cntrl||5.006000| +is_uni_digit_lc||5.006000| +is_uni_digit||5.006000| +is_uni_graph_lc||5.006000| +is_uni_graph||5.006000| +is_uni_idfirst_lc||5.006000| +is_uni_idfirst||5.006000| +is_uni_lower_lc||5.006000| +is_uni_lower||5.006000| +is_uni_print_lc||5.006000| +is_uni_print||5.006000| +is_uni_punct_lc||5.006000| +is_uni_punct||5.006000| +is_uni_space_lc||5.006000| +is_uni_space||5.006000| +is_uni_upper_lc||5.006000| +is_uni_upper||5.006000| +is_uni_xdigit_lc||5.006000| +is_uni_xdigit||5.006000| +is_utf8_alnumc||5.006000| +is_utf8_alnum||5.006000| +is_utf8_alpha||5.006000| +is_utf8_ascii||5.006000| +is_utf8_char_slow|||n +is_utf8_char||5.006000| +is_utf8_cntrl||5.006000| +is_utf8_common||| +is_utf8_digit||5.006000| +is_utf8_graph||5.006000| +is_utf8_idcont||5.008000| +is_utf8_idfirst||5.006000| +is_utf8_lower||5.006000| +is_utf8_mark||5.006000| +is_utf8_print||5.006000| +is_utf8_punct||5.006000| +is_utf8_space||5.006000| +is_utf8_string_loclen||5.009003| +is_utf8_string_loc||5.008001| +is_utf8_string||5.006001| +is_utf8_upper||5.006000| +is_utf8_xdigit||5.006000| +isa_lookup||| +items|||n +ix|||n +jmaybe||| +join_exact||| +keyword||| +leave_scope||| +lex_end||| +lex_start||| +linklist||| +listkids||| +list||| +load_module_nocontext|||vn +load_module|5.006000||pv +localize||| +looks_like_bool||| +looks_like_number||| +lop||| +mPUSHi|5.009002||p +mPUSHn|5.009002||p +mPUSHp|5.009002||p +mPUSHs|5.011000||p +mPUSHu|5.009002||p +mXPUSHi|5.009002||p +mXPUSHn|5.009002||p +mXPUSHp|5.009002||p +mXPUSHs|5.011000||p +mXPUSHu|5.009002||p +mad_free||| +madlex||| +madparse||| +magic_clear_all_env||| +magic_clearenv||| +magic_clearhint||| +magic_clearisa||| +magic_clearpack||| +magic_clearsig||| +magic_dump||5.006000| +magic_existspack||| +magic_freearylen_p||| +magic_freeovrld||| +magic_getarylen||| +magic_getdefelem||| +magic_getnkeys||| +magic_getpack||| +magic_getpos||| +magic_getsig||| +magic_getsubstr||| +magic_gettaint||| +magic_getuvar||| +magic_getvec||| +magic_get||| +magic_killbackrefs||| +magic_len||| +magic_methcall||| +magic_methpack||| +magic_nextpack||| +magic_regdata_cnt||| +magic_regdatum_get||| +magic_regdatum_set||| +magic_scalarpack||| +magic_set_all_env||| +magic_setamagic||| +magic_setarylen||| +magic_setcollxfrm||| +magic_setdbline||| +magic_setdefelem||| +magic_setenv||| +magic_sethint||| +magic_setisa||| +magic_setmglob||| +magic_setnkeys||| +magic_setpack||| +magic_setpos||| +magic_setregexp||| +magic_setsig||| +magic_setsubstr||| +magic_settaint||| +magic_setutf8||| +magic_setuvar||| +magic_setvec||| +magic_set||| +magic_sizepack||| +magic_wipepack||| +make_matcher||| +make_trie_failtable||| +make_trie||| +malloc_good_size|||n +malloced_size|||n +malloc||5.007002|n +markstack_grow||| +matcher_matches_sv||| +measure_struct||| +memEQ|5.004000||p +memNE|5.004000||p +mem_collxfrm||| +mem_log_common|||n +mess_alloc||| +mess_nocontext|||vn +mess||5.006000|v +method_common||| +mfree||5.007002|n +mg_clear||| +mg_copy||| +mg_dup||| +mg_find||| +mg_free||| +mg_get||| +mg_length||5.005000| +mg_localize||| +mg_magical||| +mg_set||| +mg_size||5.005000| +mini_mktime||5.007002| +missingterm||| +mode_from_discipline||| +modkids||| +mod||| +more_bodies||| +more_sv||| +moreswitches||| +mro_get_from_name||5.011000| +mro_get_linear_isa_dfs||| +mro_get_linear_isa||5.009005| +mro_get_private_data||5.011000| +mro_isa_changed_in||| +mro_meta_dup||| +mro_meta_init||| +mro_method_changed_in||5.009005| +mro_register||5.011000| +mro_set_mro||5.011000| +mro_set_private_data||5.011000| +mul128||| +mulexp10|||n +my_atof2||5.007002| +my_atof||5.006000| +my_attrs||| +my_bcopy|||n +my_betoh16|||n +my_betoh32|||n +my_betoh64|||n +my_betohi|||n +my_betohl|||n +my_betohs|||n +my_bzero|||n +my_chsize||| +my_clearenv||| +my_cxt_index||| +my_cxt_init||| +my_dirfd||5.009005| +my_exit_jump||| +my_exit||| +my_failure_exit||5.004000| +my_fflush_all||5.006000| +my_fork||5.007003|n +my_htobe16|||n +my_htobe32|||n +my_htobe64|||n +my_htobei|||n +my_htobel|||n +my_htobes|||n +my_htole16|||n +my_htole32|||n +my_htole64|||n +my_htolei|||n +my_htolel|||n +my_htoles|||n +my_htonl||| +my_kid||| +my_letoh16|||n +my_letoh32|||n +my_letoh64|||n +my_letohi|||n +my_letohl|||n +my_letohs|||n +my_lstat||| +my_memcmp||5.004000|n +my_memset|||n +my_ntohl||| +my_pclose||5.004000| +my_popen_list||5.007001| +my_popen||5.004000| +my_setenv||| +my_snprintf|5.009004||pvn +my_socketpair||5.007003|n +my_sprintf|5.009003||pvn +my_stat||| +my_strftime||5.007002| +my_strlcat|5.009004||pn +my_strlcpy|5.009004||pn +my_swabn|||n +my_swap||| +my_unexec||| +my_vsnprintf||5.009004|n +need_utf8|||n +newANONATTRSUB||5.006000| +newANONHASH||| +newANONLIST||| +newANONSUB||| +newASSIGNOP||| +newATTRSUB||5.006000| +newAVREF||| +newAV||| +newBINOP||| +newCONDOP||| +newCONSTSUB|5.004050||p +newCVREF||| +newDEFSVOP||| +newFORM||| +newFOROP||| +newGIVENOP||5.009003| +newGIVWHENOP||| +newGP||| +newGVOP||| +newGVREF||| +newGVgen||| +newHVREF||| +newHVhv||5.005000| +newHV||| +newIO||| +newLISTOP||| +newLOGOP||| +newLOOPEX||| +newLOOPOP||| +newMADPROP||| +newMADsv||| +newMYSUB||| +newNULLLIST||| +newOP||| +newPADOP||| +newPMOP||| +newPROG||| +newPVOP||| +newRANGE||| +newRV_inc|5.004000||p +newRV_noinc|5.004000||p +newRV||| +newSLICEOP||| +newSTATEOP||| +newSUB||| +newSVOP||| +newSVREF||| +newSV_type|5.009005||p +newSVhek||5.009003| +newSViv||| +newSVnv||| +newSVpvf_nocontext|||vn +newSVpvf||5.004000|v +newSVpvn_flags|5.011000||p +newSVpvn_share|5.007001||p +newSVpvn_utf8|5.011000||p +newSVpvn|5.004050||p +newSVpvs_flags|5.011000||p +newSVpvs_share||5.009003| +newSVpvs|5.009003||p +newSVpv||| +newSVrv||| +newSVsv||| +newSVuv|5.006000||p +newSV||| +newTOKEN||| +newUNOP||| +newWHENOP||5.009003| +newWHILEOP||5.009003| +newXS_flags||5.009004| +newXSproto||5.006000| +newXS||5.006000| +new_collate||5.006000| +new_constant||| +new_ctype||5.006000| +new_he||| +new_logop||| +new_numeric||5.006000| +new_stackinfo||5.005000| +new_version||5.009000| +new_warnings_bitfield||| +next_symbol||| +nextargv||| +nextchar||| +ninstr||| +no_bareword_allowed||| +no_fh_allowed||| +no_op||| +not_a_number||| +nothreadhook||5.008000| +nuke_stacks||| +num_overflow|||n +offer_nice_chunk||| +oopsAV||| +oopsHV||| +op_clear||| +op_const_sv||| +op_dump||5.006000| +op_free||| +op_getmad_weak||| +op_getmad||| +op_null||5.007002| +op_refcnt_dec||| +op_refcnt_inc||| +op_refcnt_lock||5.009002| +op_refcnt_unlock||5.009002| +op_xmldump||| +open_script||| +pMY_CXT_|5.007003||p +pMY_CXT|5.007003||p +pTHX_|5.006000||p +pTHX|5.006000||p +packWARN|5.007003||p +pack_cat||5.007003| +pack_rec||| +package||| +packlist||5.008001| +pad_add_anon||| +pad_add_name||| +pad_alloc||| +pad_block_start||| +pad_check_dup||| +pad_compname_type||| +pad_findlex||| +pad_findmy||| +pad_fixup_inner_anons||| +pad_free||| +pad_leavemy||| +pad_new||| +pad_peg|||n +pad_push||| +pad_reset||| +pad_setsv||| +pad_sv||5.011000| +pad_swipe||| +pad_tidy||| +pad_undef||| +parse_body||| +parse_unicode_opts||| +parser_dup||| +parser_free||| +path_is_absolute|||n +peep||| +pending_Slabs_to_ro||| +perl_alloc_using|||n +perl_alloc|||n +perl_clone_using|||n +perl_clone|||n +perl_construct|||n +perl_destruct||5.007003|n +perl_free|||n +perl_parse||5.006000|n +perl_run|||n +pidgone||| +pm_description||| +pmflag||| +pmop_dump||5.006000| +pmop_xmldump||| +pmruntime||| +pmtrans||| +pop_scope||| +pregcomp||5.009005| +pregexec||| +pregfree2||5.011000| +pregfree||| +prepend_elem||| +prepend_madprops||| +printbuf||| +printf_nocontext|||vn +process_special_blocks||| +ptr_table_clear||5.009005| +ptr_table_fetch||5.009005| +ptr_table_find|||n +ptr_table_free||5.009005| +ptr_table_new||5.009005| +ptr_table_split||5.009005| +ptr_table_store||5.009005| +push_scope||| +put_byte||| +pv_display|5.006000||p +pv_escape|5.009004||p +pv_pretty|5.009004||p +pv_uni_display||5.007003| +qerror||| +qsortsvu||| +re_compile||5.009005| +re_croak2||| +re_dup_guts||| +re_intuit_start||5.009005| +re_intuit_string||5.006000| +readpipe_override||| +realloc||5.007002|n +reentrant_free||| +reentrant_init||| +reentrant_retry|||vn +reentrant_size||| +ref_array_or_hash||| +refcounted_he_chain_2hv||| +refcounted_he_fetch||| +refcounted_he_free||| +refcounted_he_new_common||| +refcounted_he_new||| +refcounted_he_value||| +refkids||| +refto||| +ref||5.011000| +reg_check_named_buff_matched||| +reg_named_buff_all||5.009005| +reg_named_buff_exists||5.009005| +reg_named_buff_fetch||5.009005| +reg_named_buff_firstkey||5.009005| +reg_named_buff_iter||| +reg_named_buff_nextkey||5.009005| +reg_named_buff_scalar||5.009005| +reg_named_buff||| +reg_namedseq||| +reg_node||| +reg_numbered_buff_fetch||| +reg_numbered_buff_length||| +reg_numbered_buff_store||| +reg_qr_package||| +reg_recode||| +reg_scan_name||| +reg_skipcomment||| +reg_temp_copy||| +reganode||| +regatom||| +regbranch||| +regclass_swash||5.009004| +regclass||| +regcppop||| +regcppush||| +regcurly|||n +regdump_extflags||| +regdump||5.005000| +regdupe_internal||| +regexec_flags||5.005000| +regfree_internal||5.009005| +reghop3|||n +reghop4|||n +reghopmaybe3|||n +reginclass||| +reginitcolors||5.006000| +reginsert||| +regmatch||| +regnext||5.005000| +regpiece||| +regpposixcc||| +regprop||| +regrepeat||| +regtail_study||| +regtail||| +regtry||| +reguni||| +regwhite|||n +reg||| +repeatcpy||| +report_evil_fh||| +report_uninit||| +require_pv||5.006000| +require_tie_mod||| +restore_magic||| +rninstr||| +rsignal_restore||| +rsignal_save||| +rsignal_state||5.004000| +rsignal||5.004000| +run_body||| +run_user_filter||| +runops_debug||5.005000| +runops_standard||5.005000| +rvpv_dup||| +rxres_free||| +rxres_restore||| +rxres_save||| +safesyscalloc||5.006000|n +safesysfree||5.006000|n +safesysmalloc||5.006000|n +safesysrealloc||5.006000|n +same_dirent||| +save_I16||5.004000| +save_I32||| +save_I8||5.006000| +save_adelete||5.011000| +save_aelem||5.004050| +save_alloc||5.006000| +save_aptr||| +save_ary||| +save_bool||5.008001| +save_clearsv||| +save_delete||| +save_destructor_x||5.006000| +save_destructor||5.006000| +save_freeop||| +save_freepv||| +save_freesv||| +save_generic_pvref||5.006001| +save_generic_svref||5.005030| +save_gp||5.004000| +save_hash||| +save_hek_flags|||n +save_helem_flags||5.011000| +save_helem||5.004050| +save_hints||| +save_hptr||| +save_int||| +save_item||| +save_iv||5.005000| +save_lines||| +save_list||| +save_long||| +save_magic||| +save_mortalizesv||5.007001| +save_nogv||| +save_op||| +save_padsv_and_mortalize||5.011000| +save_pptr||| +save_pushi32ptr||| +save_pushptri32ptr||| +save_pushptrptr||| +save_pushptr||5.011000| +save_re_context||5.006000| +save_scalar_at||| +save_scalar||| +save_set_svflags||5.009000| +save_shared_pvref||5.007003| +save_sptr||| +save_svref||| +save_vptr||5.006000| +savepvn||| +savepvs||5.009003| +savepv||| +savesharedpvn||5.009005| +savesharedpv||5.007003| +savestack_grow_cnt||5.008001| +savestack_grow||| +savesvpv||5.009002| +sawparens||| +scalar_mod_type|||n +scalarboolean||| +scalarkids||| +scalarseq||| +scalarvoid||| +scalar||| +scan_bin||5.006000| +scan_commit||| +scan_const||| +scan_formline||| +scan_heredoc||| +scan_hex||| +scan_ident||| +scan_inputsymbol||| +scan_num||5.007001| +scan_oct||| +scan_pat||| +scan_str||| +scan_subst||| +scan_trans||| +scan_version||5.009001| +scan_vstring||5.009005| +scan_word||| +scope||| +screaminstr||5.005000| +search_const||| +seed||5.008001| +sequence_num||| +sequence_tail||| +sequence||| +set_context||5.006000|n +set_numeric_local||5.006000| +set_numeric_radix||5.006000| +set_numeric_standard||5.006000| +setdefout||| +share_hek_flags||| +share_hek||5.004000| +si_dup||| +sighandler|||n +simplify_sort||| +skipspace0||| +skipspace1||| +skipspace2||| +skipspace||| +softref2xv||| +sortcv_stacked||| +sortcv_xsub||| +sortcv||| +sortsv_flags||5.009003| +sortsv||5.007003| +space_join_names_mortal||| +ss_dup||| +stack_grow||| +start_force||| +start_glob||| +start_subparse||5.004000| +stashpv_hvname_match||5.011000| +stdize_locale||| +store_cop_label||| +strEQ||| +strGE||| +strGT||| +strLE||| +strLT||| +strNE||| +str_to_version||5.006000| +strip_return||| +strnEQ||| +strnNE||| +study_chunk||| +sub_crush_depth||| +sublex_done||| +sublex_push||| +sublex_start||| +sv_2bool||| +sv_2cv||| +sv_2io||| +sv_2iuv_common||| +sv_2iuv_non_preserve||| +sv_2iv_flags||5.009001| +sv_2iv||| +sv_2mortal||| +sv_2num||| +sv_2nv||| +sv_2pv_flags|5.007002||p +sv_2pv_nolen|5.006000||p +sv_2pvbyte_nolen|5.006000||p +sv_2pvbyte|5.006000||p +sv_2pvutf8_nolen||5.006000| +sv_2pvutf8||5.006000| +sv_2pv||| +sv_2uv_flags||5.009001| +sv_2uv|5.004000||p +sv_add_arena||| +sv_add_backref||| +sv_backoff||| +sv_bless||| +sv_cat_decode||5.008001| +sv_catpv_mg|5.004050||p +sv_catpvf_mg_nocontext|||pvn +sv_catpvf_mg|5.006000|5.004000|pv +sv_catpvf_nocontext|||vn +sv_catpvf||5.004000|v +sv_catpvn_flags||5.007002| +sv_catpvn_mg|5.004050||p +sv_catpvn_nomg|5.007002||p +sv_catpvn||| +sv_catpvs|5.009003||p +sv_catpv||| +sv_catsv_flags||5.007002| +sv_catsv_mg|5.004050||p +sv_catsv_nomg|5.007002||p +sv_catsv||| +sv_catxmlpvn||| +sv_catxmlsv||| +sv_chop||| +sv_clean_all||| +sv_clean_objs||| +sv_clear||| +sv_cmp_locale||5.004000| +sv_cmp||| +sv_collxfrm||| +sv_compile_2op||5.008001| +sv_copypv||5.007003| +sv_dec||| +sv_del_backref||| +sv_derived_from||5.004000| +sv_destroyable||5.010000| +sv_does||5.009004| +sv_dump||| +sv_dup_inc_multiple||| +sv_dup||| +sv_eq||| +sv_exp_grow||| +sv_force_normal_flags||5.007001| +sv_force_normal||5.006000| +sv_free2||| +sv_free_arenas||| +sv_free||| +sv_gets||5.004000| +sv_grow||| +sv_i_ncmp||| +sv_inc||| +sv_insert_flags||5.011000| +sv_insert||| +sv_isa||| +sv_isobject||| +sv_iv||5.005000| +sv_kill_backrefs||| +sv_len_utf8||5.006000| +sv_len||| +sv_magic_portable|5.011000|5.004000|p +sv_magicext||5.007003| +sv_magic||| +sv_mortalcopy||| +sv_ncmp||| +sv_newmortal||| +sv_newref||| +sv_nolocking||5.007003| +sv_nosharing||5.007003| +sv_nounlocking||| +sv_nv||5.005000| +sv_peek||5.005000| +sv_pos_b2u_midway||| +sv_pos_b2u||5.006000| +sv_pos_u2b_cached||| +sv_pos_u2b_forwards|||n +sv_pos_u2b_midway|||n +sv_pos_u2b||5.006000| +sv_pvbyten_force||5.006000| +sv_pvbyten||5.006000| +sv_pvbyte||5.006000| +sv_pvn_force_flags|5.007002||p +sv_pvn_force||| +sv_pvn_nomg|5.007003|5.005000|p +sv_pvn||5.005000| +sv_pvutf8n_force||5.006000| +sv_pvutf8n||5.006000| +sv_pvutf8||5.006000| +sv_pv||5.006000| +sv_recode_to_utf8||5.007003| +sv_reftype||| +sv_release_COW||| +sv_replace||| +sv_report_used||| +sv_reset||| +sv_rvweaken||5.006000| +sv_setiv_mg|5.004050||p +sv_setiv||| +sv_setnv_mg|5.006000||p +sv_setnv||| +sv_setpv_mg|5.004050||p +sv_setpvf_mg_nocontext|||pvn +sv_setpvf_mg|5.006000|5.004000|pv +sv_setpvf_nocontext|||vn +sv_setpvf||5.004000|v +sv_setpviv_mg||5.008001| +sv_setpviv||5.008001| +sv_setpvn_mg|5.004050||p +sv_setpvn||| +sv_setpvs|5.009004||p +sv_setpv||| +sv_setref_iv||| +sv_setref_nv||| +sv_setref_pvn||| +sv_setref_pv||| +sv_setref_uv||5.007001| +sv_setsv_cow||| +sv_setsv_flags||5.007002| +sv_setsv_mg|5.004050||p +sv_setsv_nomg|5.007002||p +sv_setsv||| +sv_setuv_mg|5.004050||p +sv_setuv|5.004000||p +sv_tainted||5.004000| +sv_taint||5.004000| +sv_true||5.005000| +sv_unglob||| +sv_uni_display||5.007003| +sv_unmagic||| +sv_unref_flags||5.007001| +sv_unref||| +sv_untaint||5.004000| +sv_upgrade||| +sv_usepvn_flags||5.009004| +sv_usepvn_mg|5.004050||p +sv_usepvn||| +sv_utf8_decode||5.006000| +sv_utf8_downgrade||5.006000| +sv_utf8_encode||5.006000| +sv_utf8_upgrade_flags_grow||5.011000| +sv_utf8_upgrade_flags||5.007002| +sv_utf8_upgrade_nomg||5.007002| +sv_utf8_upgrade||5.007001| +sv_uv|5.005000||p +sv_vcatpvf_mg|5.006000|5.004000|p +sv_vcatpvfn||5.004000| +sv_vcatpvf|5.006000|5.004000|p +sv_vsetpvf_mg|5.006000|5.004000|p +sv_vsetpvfn||5.004000| +sv_vsetpvf|5.006000|5.004000|p +sv_xmlpeek||| +svtype||| +swallow_bom||| +swap_match_buff||| +swash_fetch||5.007002| +swash_get||| +swash_init||5.006000| +sys_init3||5.010000|n +sys_init||5.010000|n +sys_intern_clear||| +sys_intern_dup||| +sys_intern_init||| +sys_term||5.010000|n +taint_env||| +taint_proper||| +tmps_grow||5.006000| +toLOWER||| +toUPPER||| +to_byte_substr||| +to_uni_fold||5.007003| +to_uni_lower_lc||5.006000| +to_uni_lower||5.007003| +to_uni_title_lc||5.006000| +to_uni_title||5.007003| +to_uni_upper_lc||5.006000| +to_uni_upper||5.007003| +to_utf8_case||5.007003| +to_utf8_fold||5.007003| +to_utf8_lower||5.007003| +to_utf8_substr||| +to_utf8_title||5.007003| +to_utf8_upper||5.007003| +token_free||| +token_getmad||| +tokenize_use||| +tokeq||| +tokereport||| +too_few_arguments||| +too_many_arguments||| +uiv_2buf|||n +unlnk||| +unpack_rec||| +unpack_str||5.007003| +unpackstring||5.008001| +unshare_hek_or_pvn||| +unshare_hek||| +unsharepvn||5.004000| +unwind_handler_stack||| +update_debugger_info||| +upg_version||5.009005| +usage||| +utf16_to_utf8_reversed||5.006001| +utf16_to_utf8||5.006001| +utf8_distance||5.006000| +utf8_hop||5.006000| +utf8_length||5.007001| +utf8_mg_pos_cache_update||| +utf8_to_bytes||5.006001| +utf8_to_uvchr||5.007001| +utf8_to_uvuni||5.007001| +utf8n_to_uvchr||| +utf8n_to_uvuni||5.007001| +utilize||| +uvchr_to_utf8_flags||5.007003| +uvchr_to_utf8||| +uvuni_to_utf8_flags||5.007003| +uvuni_to_utf8||5.007001| +validate_suid||| +varname||| +vcmp||5.009000| +vcroak||5.006000| +vdeb||5.007003| +vdie_common||| +vdie_croak_common||| +vdie||| +vform||5.006000| +visit||| +vivify_defelem||| +vivify_ref||| +vload_module|5.006000||p +vmess||5.006000| +vnewSVpvf|5.006000|5.004000|p +vnormal||5.009002| +vnumify||5.009000| +vstringify||5.009000| +vverify||5.009003| +vwarner||5.006000| +vwarn||5.006000| +wait4pid||| +warn_nocontext|||vn +warner_nocontext|||vn +warner|5.006000|5.004000|pv +warn|||v +watch||| +whichsig||| +write_no_mem||| +write_to_stderr||| +xmldump_all||| +xmldump_attr||| +xmldump_eval||| +xmldump_form||| +xmldump_indent|||v +xmldump_packsubs||| +xmldump_sub||| +xmldump_vindent||| +yyerror||| +yylex||| +yyparse||| +yywarn||| +); + +if (exists $opt{'list-unsupported'}) { + my $f; + for $f (sort { lc $a cmp lc $b } keys %API) { + next unless $API{$f}{todo}; + print "$f ", '.'x(40-length($f)), " ", format_version($API{$f}{todo}), "\n"; + } + exit 0; +} + +# Scan for possible replacement candidates + +my(%replace, %need, %hints, %warnings, %depends); +my $replace = 0; +my($hint, $define, $function); + +sub find_api +{ + my $code = shift; + $code =~ s{ + / (?: \*[^*]*\*+(?:[^$ccs][^*]*\*+)* / | /[^\r\n]*) + | "[^"\\]*(?:\\.[^"\\]*)*" + | '[^'\\]*(?:\\.[^'\\]*)*' }{}egsx; + grep { exists $API{$_} } $code =~ /(\w+)/mg; +} + +while (<DATA>) { + if ($hint) { + my $h = $hint->[0] eq 'Hint' ? \%hints : \%warnings; + if (m{^\s*\*\s(.*?)\s*$}) { + for (@{$hint->[1]}) { + $h->{$_} ||= ''; # suppress warning with older perls + $h->{$_} .= "$1\n"; + } + } + else { undef $hint } + } + + $hint = [$1, [split /,?\s+/, $2]] + if m{^\s*$rccs\s+(Hint|Warning):\s+(\w+(?:,?\s+\w+)*)\s*$}; + + if ($define) { + if ($define->[1] =~ /\\$/) { + $define->[1] .= $_; + } + else { + if (exists $API{$define->[0]} && $define->[1] !~ /^DPPP_\(/) { + my @n = find_api($define->[1]); + push @{$depends{$define->[0]}}, @n if @n + } + undef $define; + } + } + + $define = [$1, $2] if m{^\s*#\s*define\s+(\w+)(?:\([^)]*\))?\s+(.*)}; + + if ($function) { + if (/^}/) { + if (exists $API{$function->[0]}) { + my @n = find_api($function->[1]); + push @{$depends{$function->[0]}}, @n if @n + } + undef $function; + } + else { + $function->[1] .= $_; + } + } + + $function = [$1, ''] if m{^DPPP_\(my_(\w+)\)}; + + $replace = $1 if m{^\s*$rccs\s+Replace:\s+(\d+)\s+$rcce\s*$}; + $replace{$2} = $1 if $replace and m{^\s*#\s*define\s+(\w+)(?:\([^)]*\))?\s+(\w+)}; + $replace{$2} = $1 if m{^\s*#\s*define\s+(\w+)(?:\([^)]*\))?\s+(\w+).*$rccs\s+Replace\s+$rcce}; + $replace{$1} = $2 if m{^\s*$rccs\s+Replace (\w+) with (\w+)\s+$rcce\s*$}; + + if (m{^\s*$rccs\s+(\w+(\s*,\s*\w+)*)\s+depends\s+on\s+(\w+(\s*,\s*\w+)*)\s+$rcce\s*$}) { + my @deps = map { s/\s+//g; $_ } split /,/, $3; + my $d; + for $d (map { s/\s+//g; $_ } split /,/, $1) { + push @{$depends{$d}}, @deps; + } + } + + $need{$1} = 1 if m{^#if\s+defined\(NEED_(\w+)(?:_GLOBAL)?\)}; +} + +for (values %depends) { + my %s; + $_ = [sort grep !$s{$_}++, @$_]; +} + +if (exists $opt{'api-info'}) { + my $f; + my $count = 0; + my $match = $opt{'api-info'} =~ m!^/(.*)/$! ? $1 : "^\Q$opt{'api-info'}\E\$"; + for $f (sort { lc $a cmp lc $b } keys %API) { + next unless $f =~ /$match/; + print "\n=== $f ===\n\n"; + my $info = 0; + if ($API{$f}{base} || $API{$f}{todo}) { + my $base = format_version($API{$f}{base} || $API{$f}{todo}); + print "Supported at least starting from perl-$base.\n"; + $info++; + } + if ($API{$f}{provided}) { + my $todo = $API{$f}{todo} ? format_version($API{$f}{todo}) : "5.003"; + print "Support by $ppport provided back to perl-$todo.\n"; + print "Support needs to be explicitly requested by NEED_$f.\n" if exists $need{$f}; + print "Depends on: ", join(', ', @{$depends{$f}}), ".\n" if exists $depends{$f}; + print "\n$hints{$f}" if exists $hints{$f}; + print "\nWARNING:\n$warnings{$f}" if exists $warnings{$f}; + $info++; + } + print "No portability information available.\n" unless $info; + $count++; + } + $count or print "Found no API matching '$opt{'api-info'}'."; + print "\n"; + exit 0; +} + +if (exists $opt{'list-provided'}) { + my $f; + for $f (sort { lc $a cmp lc $b } keys %API) { + next unless $API{$f}{provided}; + my @flags; + push @flags, 'explicit' if exists $need{$f}; + push @flags, 'depend' if exists $depends{$f}; + push @flags, 'hint' if exists $hints{$f}; + push @flags, 'warning' if exists $warnings{$f}; + my $flags = @flags ? ' ['.join(', ', @flags).']' : ''; + print "$f$flags\n"; + } + exit 0; +} + +my @files; +my @srcext = qw( .xs .c .h .cc .cpp -c.inc -xs.inc ); +my $srcext = join '|', map { quotemeta $_ } @srcext; + +if (@ARGV) { + my %seen; + for (@ARGV) { + if (-e) { + if (-f) { + push @files, $_ unless $seen{$_}++; + } + else { warn "'$_' is not a file.\n" } + } + else { + my @new = grep { -f } glob $_ + or warn "'$_' does not exist.\n"; + push @files, grep { !$seen{$_}++ } @new; + } + } +} +else { + eval { + require File::Find; + File::Find::find(sub { + $File::Find::name =~ /($srcext)$/i + and push @files, $File::Find::name; + }, '.'); + }; + if ($@) { + @files = map { glob "*$_" } @srcext; + } +} + +if (!@ARGV || $opt{filter}) { + my(@in, @out); + my %xsc = map { /(.*)\.xs$/ ? ("$1.c" => 1, "$1.cc" => 1) : () } @files; + for (@files) { + my $out = exists $xsc{$_} || /\b\Q$ppport\E$/i || !/($srcext)$/i; + push @{ $out ? \@out : \@in }, $_; + } + if (@ARGV && @out) { + warning("Skipping the following files (use --nofilter to avoid this):\n| ", join "\n| ", @out); + } + @files = @in; +} + +die "No input files given!\n" unless @files; + +my(%files, %global, %revreplace); +%revreplace = reverse %replace; +my $filename; +my $patch_opened = 0; + +for $filename (@files) { + unless (open IN, "<$filename") { + warn "Unable to read from $filename: $!\n"; + next; + } + + info("Scanning $filename ..."); + + my $c = do { local $/; <IN> }; + close IN; + + my %file = (orig => $c, changes => 0); + + # Temporarily remove C/XS comments and strings from the code + my @ccom; + + $c =~ s{ + ( ^$HS*\#$HS*include\b[^\r\n]+\b(?:\Q$ppport\E|XSUB\.h)\b[^\r\n]* + | ^$HS*\#$HS*(?:define|elif|if(?:def)?)\b[^\r\n]* ) + | ( ^$HS*\#[^\r\n]* + | "[^"\\]*(?:\\.[^"\\]*)*" + | '[^'\\]*(?:\\.[^'\\]*)*' + | / (?: \*[^*]*\*+(?:[^$ccs][^*]*\*+)* / | /[^\r\n]* ) ) + }{ defined $2 and push @ccom, $2; + defined $1 ? $1 : "$ccs$#ccom$cce" }mgsex; + + $file{ccom} = \@ccom; + $file{code} = $c; + $file{has_inc_ppport} = $c =~ /^$HS*#$HS*include[^\r\n]+\b\Q$ppport\E\b/m; + + my $func; + + for $func (keys %API) { + my $match = $func; + $match .= "|$revreplace{$func}" if exists $revreplace{$func}; + if ($c =~ /\b(?:Perl_)?($match)\b/) { + $file{uses_replace}{$1}++ if exists $revreplace{$func} && $1 eq $revreplace{$func}; + $file{uses_Perl}{$func}++ if $c =~ /\bPerl_$func\b/; + if (exists $API{$func}{provided}) { + $file{uses_provided}{$func}++; + if (!exists $API{$func}{base} || $API{$func}{base} > $opt{'compat-version'}) { + $file{uses}{$func}++; + my @deps = rec_depend($func); + if (@deps) { + $file{uses_deps}{$func} = \@deps; + for (@deps) { + $file{uses}{$_} = 0 unless exists $file{uses}{$_}; + } + } + for ($func, @deps) { + $file{needs}{$_} = 'static' if exists $need{$_}; + } + } + } + if (exists $API{$func}{todo} && $API{$func}{todo} > $opt{'compat-version'}) { + if ($c =~ /\b$func\b/) { + $file{uses_todo}{$func}++; + } + } + } + } + + while ($c =~ /^$HS*#$HS*define$HS+(NEED_(\w+?)(_GLOBAL)?)\b/mg) { + if (exists $need{$2}) { + $file{defined $3 ? 'needed_global' : 'needed_static'}{$2}++; + } + else { warning("Possibly wrong #define $1 in $filename") } + } + + for (qw(uses needs uses_todo needed_global needed_static)) { + for $func (keys %{$file{$_}}) { + push @{$global{$_}{$func}}, $filename; + } + } + + $files{$filename} = \%file; +} + +# Globally resolve NEED_'s +my $need; +for $need (keys %{$global{needs}}) { + if (@{$global{needs}{$need}} > 1) { + my @targets = @{$global{needs}{$need}}; + my @t = grep $files{$_}{needed_global}{$need}, @targets; + @targets = @t if @t; + @t = grep /\.xs$/i, @targets; + @targets = @t if @t; + my $target = shift @targets; + $files{$target}{needs}{$need} = 'global'; + for (@{$global{needs}{$need}}) { + $files{$_}{needs}{$need} = 'extern' if $_ ne $target; + } + } +} + +for $filename (@files) { + exists $files{$filename} or next; + + info("=== Analyzing $filename ==="); + + my %file = %{$files{$filename}}; + my $func; + my $c = $file{code}; + my $warnings = 0; + + for $func (sort keys %{$file{uses_Perl}}) { + if ($API{$func}{varargs}) { + unless ($API{$func}{nothxarg}) { + my $changes = ($c =~ s{\b(Perl_$func\s*\(\s*)(?!aTHX_?)(\)|[^\s)]*\))} + { $1 . ($2 eq ')' ? 'aTHX' : 'aTHX_ ') . $2 }ge); + if ($changes) { + warning("Doesn't pass interpreter argument aTHX to Perl_$func"); + $file{changes} += $changes; + } + } + } + else { + warning("Uses Perl_$func instead of $func"); + $file{changes} += ($c =~ s{\bPerl_$func(\s*)\((\s*aTHX_?)?\s*} + {$func$1(}g); + } + } + + for $func (sort keys %{$file{uses_replace}}) { + warning("Uses $func instead of $replace{$func}"); + $file{changes} += ($c =~ s/\b$func\b/$replace{$func}/g); + } + + for $func (sort keys %{$file{uses_provided}}) { + if ($file{uses}{$func}) { + if (exists $file{uses_deps}{$func}) { + diag("Uses $func, which depends on ", join(', ', @{$file{uses_deps}{$func}})); + } + else { + diag("Uses $func"); + } + } + $warnings += hint($func); + } + + unless ($opt{quiet}) { + for $func (sort keys %{$file{uses_todo}}) { + print "*** WARNING: Uses $func, which may not be portable below perl ", + format_version($API{$func}{todo}), ", even with '$ppport'\n"; + $warnings++; + } + } + + for $func (sort keys %{$file{needed_static}}) { + my $message = ''; + if (not exists $file{uses}{$func}) { + $message = "No need to define NEED_$func if $func is never used"; + } + elsif (exists $file{needs}{$func} && $file{needs}{$func} ne 'static') { + $message = "No need to define NEED_$func when already needed globally"; + } + if ($message) { + diag($message); + $file{changes} += ($c =~ s/^$HS*#$HS*define$HS+NEED_$func\b.*$LF//mg); + } + } + + for $func (sort keys %{$file{needed_global}}) { + my $message = ''; + if (not exists $global{uses}{$func}) { + $message = "No need to define NEED_${func}_GLOBAL if $func is never used"; + } + elsif (exists $file{needs}{$func}) { + if ($file{needs}{$func} eq 'extern') { + $message = "No need to define NEED_${func}_GLOBAL when already needed globally"; + } + elsif ($file{needs}{$func} eq 'static') { + $message = "No need to define NEED_${func}_GLOBAL when only used in this file"; + } + } + if ($message) { + diag($message); + $file{changes} += ($c =~ s/^$HS*#$HS*define$HS+NEED_${func}_GLOBAL\b.*$LF//mg); + } + } + + $file{needs_inc_ppport} = keys %{$file{uses}}; + + if ($file{needs_inc_ppport}) { + my $pp = ''; + + for $func (sort keys %{$file{needs}}) { + my $type = $file{needs}{$func}; + next if $type eq 'extern'; + my $suffix = $type eq 'global' ? '_GLOBAL' : ''; + unless (exists $file{"needed_$type"}{$func}) { + if ($type eq 'global') { + diag("Files [@{$global{needs}{$func}}] need $func, adding global request"); + } + else { + diag("File needs $func, adding static request"); + } + $pp .= "#define NEED_$func$suffix\n"; + } + } + + if ($pp && ($c =~ s/^(?=$HS*#$HS*define$HS+NEED_\w+)/$pp/m)) { + $pp = ''; + $file{changes}++; + } + + unless ($file{has_inc_ppport}) { + diag("Needs to include '$ppport'"); + $pp .= qq(#include "$ppport"\n) + } + + if ($pp) { + $file{changes} += ($c =~ s/^($HS*#$HS*define$HS+NEED_\w+.*?)^/$1$pp/ms) + || ($c =~ s/^(?=$HS*#$HS*include.*\Q$ppport\E)/$pp/m) + || ($c =~ s/^($HS*#$HS*include.*XSUB.*\s*?)^/$1$pp/m) + || ($c =~ s/^/$pp/); + } + } + else { + if ($file{has_inc_ppport}) { + diag("No need to include '$ppport'"); + $file{changes} += ($c =~ s/^$HS*?#$HS*include.*\Q$ppport\E.*?$LF//m); + } + } + + # put back in our C comments + my $ix; + my $cppc = 0; + my @ccom = @{$file{ccom}}; + for $ix (0 .. $#ccom) { + if (!$opt{cplusplus} && $ccom[$ix] =~ s!^//!!) { + $cppc++; + $file{changes} += $c =~ s/$rccs$ix$rcce/$ccs$ccom[$ix] $cce/; + } + else { + $c =~ s/$rccs$ix$rcce/$ccom[$ix]/; + } + } + + if ($cppc) { + my $s = $cppc != 1 ? 's' : ''; + warning("Uses $cppc C++ style comment$s, which is not portable"); + } + + my $s = $warnings != 1 ? 's' : ''; + my $warn = $warnings ? " ($warnings warning$s)" : ''; + info("Analysis completed$warn"); + + if ($file{changes}) { + if (exists $opt{copy}) { + my $newfile = "$filename$opt{copy}"; + if (-e $newfile) { + error("'$newfile' already exists, refusing to write copy of '$filename'"); + } + else { + local *F; + if (open F, ">$newfile") { + info("Writing copy of '$filename' with changes to '$newfile'"); + print F $c; + close F; + } + else { + error("Cannot open '$newfile' for writing: $!"); + } + } + } + elsif (exists $opt{patch} || $opt{changes}) { + if (exists $opt{patch}) { + unless ($patch_opened) { + if (open PATCH, ">$opt{patch}") { + $patch_opened = 1; + } + else { + error("Cannot open '$opt{patch}' for writing: $!"); + delete $opt{patch}; + $opt{changes} = 1; + goto fallback; + } + } + mydiff(\*PATCH, $filename, $c); + } + else { +fallback: + info("Suggested changes:"); + mydiff(\*STDOUT, $filename, $c); + } + } + else { + my $s = $file{changes} == 1 ? '' : 's'; + info("$file{changes} potentially required change$s detected"); + } + } + else { + info("Looks good"); + } +} + +close PATCH if $patch_opened; + +exit 0; + + +sub try_use { eval "use @_;"; return $@ eq '' } + +sub mydiff +{ + local *F = shift; + my($file, $str) = @_; + my $diff; + + if (exists $opt{diff}) { + $diff = run_diff($opt{diff}, $file, $str); + } + + if (!defined $diff and try_use('Text::Diff')) { + $diff = Text::Diff::diff($file, \$str, { STYLE => 'Unified' }); + $diff = <<HEADER . $diff; +--- $file ++++ $file.patched +HEADER + } + + if (!defined $diff) { + $diff = run_diff('diff -u', $file, $str); + } + + if (!defined $diff) { + $diff = run_diff('diff', $file, $str); + } + + if (!defined $diff) { + error("Cannot generate a diff. Please install Text::Diff or use --copy."); + return; + } + + print F $diff; +} + +sub run_diff +{ + my($prog, $file, $str) = @_; + my $tmp = 'dppptemp'; + my $suf = 'aaa'; + my $diff = ''; + local *F; + + while (-e "$tmp.$suf") { $suf++ } + $tmp = "$tmp.$suf"; + + if (open F, ">$tmp") { + print F $str; + close F; + + if (open F, "$prog $file $tmp |") { + while (<F>) { + s/\Q$tmp\E/$file.patched/; + $diff .= $_; + } + close F; + unlink $tmp; + return $diff; + } + + unlink $tmp; + } + else { + error("Cannot open '$tmp' for writing: $!"); + } + + return undef; +} + +sub rec_depend +{ + my($func, $seen) = @_; + return () unless exists $depends{$func}; + $seen = {%{$seen||{}}}; + return () if $seen->{$func}++; + my %s; + grep !$s{$_}++, map { ($_, rec_depend($_, $seen)) } @{$depends{$func}}; +} + +sub parse_version +{ + my $ver = shift; + + if ($ver =~ /^(\d+)\.(\d+)\.(\d+)$/) { + return ($1, $2, $3); + } + elsif ($ver !~ /^\d+\.[\d_]+$/) { + die "cannot parse version '$ver'\n"; + } + + $ver =~ s/_//g; + $ver =~ s/$/000000/; + + my($r,$v,$s) = $ver =~ /(\d+)\.(\d{3})(\d{3})/; + + $v = int $v; + $s = int $s; + + if ($r < 5 || ($r == 5 && $v < 6)) { + if ($s % 10) { + die "cannot parse version '$ver'\n"; + } + } + + return ($r, $v, $s); +} + +sub format_version +{ + my $ver = shift; + + $ver =~ s/$/000000/; + my($r,$v,$s) = $ver =~ /(\d+)\.(\d{3})(\d{3})/; + + $v = int $v; + $s = int $s; + + if ($r < 5 || ($r == 5 && $v < 6)) { + if ($s % 10) { + die "invalid version '$ver'\n"; + } + $s /= 10; + + $ver = sprintf "%d.%03d", $r, $v; + $s > 0 and $ver .= sprintf "_%02d", $s; + + return $ver; + } + + return sprintf "%d.%d.%d", $r, $v, $s; +} + +sub info +{ + $opt{quiet} and return; + print @_, "\n"; +} + +sub diag +{ + $opt{quiet} and return; + $opt{diag} and print @_, "\n"; +} + +sub warning +{ + $opt{quiet} and return; + print "*** ", @_, "\n"; +} + +sub error +{ + print "*** ERROR: ", @_, "\n"; +} + +my %given_hints; +my %given_warnings; +sub hint +{ + $opt{quiet} and return; + my $func = shift; + my $rv = 0; + if (exists $warnings{$func} && !$given_warnings{$func}++) { + my $warn = $warnings{$func}; + $warn =~ s!^!*** !mg; + print "*** WARNING: $func\n", $warn; + $rv++; + } + if ($opt{hints} && exists $hints{$func} && !$given_hints{$func}++) { + my $hint = $hints{$func}; + $hint =~ s/^/ /mg; + print " --- hint for $func ---\n", $hint; + } + $rv; +} + +sub usage +{ + my($usage) = do { local(@ARGV,$/)=($0); <> } =~ /^=head\d$HS+SYNOPSIS\s*^(.*?)\s*^=/ms; + my %M = ( 'I' => '*' ); + $usage =~ s/^\s*perl\s+\S+/$^X $0/; + $usage =~ s/([A-Z])<([^>]+)>/$M{$1}$2$M{$1}/g; + + print <<ENDUSAGE; + +Usage: $usage + +See perldoc $0 for details. + +ENDUSAGE + + exit 2; +} + +sub strip +{ + my $self = do { local(@ARGV,$/)=($0); <> }; + my($copy) = $self =~ /^=head\d\s+COPYRIGHT\s*^(.*?)^=\w+/ms; + $copy =~ s/^(?=\S+)/ /gms; + $self =~ s/^$HS+Do NOT edit.*?(?=^-)/$copy/ms; + $self =~ s/^SKIP.*(?=^__DATA__)/SKIP +if (\@ARGV && \$ARGV[0] eq '--unstrip') { + eval { require Devel::PPPort }; + \$@ and die "Cannot require Devel::PPPort, please install.\\n"; + if (eval \$Devel::PPPort::VERSION < $VERSION) { + die "$0 was originally generated with Devel::PPPort $VERSION.\\n" + . "Your Devel::PPPort is only version \$Devel::PPPort::VERSION.\\n" + . "Please install a newer version, or --unstrip will not work.\\n"; + } + Devel::PPPort::WriteFile(\$0); + exit 0; +} +print <<END; + +Sorry, but this is a stripped version of \$0. + +To be able to use its original script and doc functionality, +please try to regenerate this file using: + + \$^X \$0 --unstrip + +END +/ms; + my($pl, $c) = $self =~ /(.*^__DATA__)(.*)/ms; + $c =~ s{ + / (?: \*[^*]*\*+(?:[^$ccs][^*]*\*+)* / | /[^\r\n]*) + | ( "[^"\\]*(?:\\.[^"\\]*)*" + | '[^'\\]*(?:\\.[^'\\]*)*' ) + | ($HS+) }{ defined $2 ? ' ' : ($1 || '') }gsex; + $c =~ s!\s+$!!mg; + $c =~ s!^$LF!!mg; + $c =~ s!^\s*#\s*!#!mg; + $c =~ s!^\s+!!mg; + + open OUT, ">$0" or die "cannot strip $0: $!\n"; + print OUT "$pl$c\n"; + + exit 0; +} + +__DATA__ +*/ + +#ifndef _P_P_PORTABILITY_H_ +#define _P_P_PORTABILITY_H_ + +#ifndef DPPP_NAMESPACE +# define DPPP_NAMESPACE DPPP_ +#endif + +#define DPPP_CAT2(x,y) CAT2(x,y) +#define DPPP_(name) DPPP_CAT2(DPPP_NAMESPACE, name) + +#ifndef PERL_REVISION +# if !defined(__PATCHLEVEL_H_INCLUDED__) && !(defined(PATCHLEVEL) && defined(SUBVERSION)) +# define PERL_PATCHLEVEL_H_IMPLICIT +# include <patchlevel.h> +# endif +# if !(defined(PERL_VERSION) || (defined(SUBVERSION) && defined(PATCHLEVEL))) +# include <could_not_find_Perl_patchlevel.h> +# endif +# ifndef PERL_REVISION +# define PERL_REVISION (5) + /* Replace: 1 */ +# define PERL_VERSION PATCHLEVEL +# define PERL_SUBVERSION SUBVERSION + /* Replace PERL_PATCHLEVEL with PERL_VERSION */ + /* Replace: 0 */ +# endif +#endif + +#define _dpppDEC2BCD(dec) ((((dec)/100)<<8)|((((dec)%100)/10)<<4)|((dec)%10)) +#define PERL_BCDVERSION ((_dpppDEC2BCD(PERL_REVISION)<<24)|(_dpppDEC2BCD(PERL_VERSION)<<12)|_dpppDEC2BCD(PERL_SUBVERSION)) + +/* It is very unlikely that anyone will try to use this with Perl 6 + (or greater), but who knows. + */ +#if PERL_REVISION != 5 +# error ppport.h only works with Perl version 5 +#endif /* PERL_REVISION != 5 */ +#ifndef dTHR +# define dTHR dNOOP +#endif +#ifndef dTHX +# define dTHX dNOOP +#endif + +#ifndef dTHXa +# define dTHXa(x) dNOOP +#endif +#ifndef pTHX +# define pTHX void +#endif + +#ifndef pTHX_ +# define pTHX_ +#endif + +#ifndef aTHX +# define aTHX +#endif + +#ifndef aTHX_ +# define aTHX_ +#endif + +#if (PERL_BCDVERSION < 0x5006000) +# ifdef USE_THREADS +# define aTHXR thr +# define aTHXR_ thr, +# else +# define aTHXR +# define aTHXR_ +# endif +# define dTHXR dTHR +#else +# define aTHXR aTHX +# define aTHXR_ aTHX_ +# define dTHXR dTHX +#endif +#ifndef dTHXoa +# define dTHXoa(x) dTHXa(x) +#endif + +#ifdef I_LIMITS +# include <limits.h> +#endif + +#ifndef PERL_UCHAR_MIN +# define PERL_UCHAR_MIN ((unsigned char)0) +#endif + +#ifndef PERL_UCHAR_MAX +# ifdef UCHAR_MAX +# define PERL_UCHAR_MAX ((unsigned char)UCHAR_MAX) +# else +# ifdef MAXUCHAR +# define PERL_UCHAR_MAX ((unsigned char)MAXUCHAR) +# else +# define PERL_UCHAR_MAX ((unsigned char)~(unsigned)0) +# endif +# endif +#endif + +#ifndef PERL_USHORT_MIN +# define PERL_USHORT_MIN ((unsigned short)0) +#endif + +#ifndef PERL_USHORT_MAX +# ifdef USHORT_MAX +# define PERL_USHORT_MAX ((unsigned short)USHORT_MAX) +# else +# ifdef MAXUSHORT +# define PERL_USHORT_MAX ((unsigned short)MAXUSHORT) +# else +# ifdef USHRT_MAX +# define PERL_USHORT_MAX ((unsigned short)USHRT_MAX) +# else +# define PERL_USHORT_MAX ((unsigned short)~(unsigned)0) +# endif +# endif +# endif +#endif + +#ifndef PERL_SHORT_MAX +# ifdef SHORT_MAX +# define PERL_SHORT_MAX ((short)SHORT_MAX) +# else +# ifdef MAXSHORT /* Often used in <values.h> */ +# define PERL_SHORT_MAX ((short)MAXSHORT) +# else +# ifdef SHRT_MAX +# define PERL_SHORT_MAX ((short)SHRT_MAX) +# else +# define PERL_SHORT_MAX ((short) (PERL_USHORT_MAX >> 1)) +# endif +# endif +# endif +#endif + +#ifndef PERL_SHORT_MIN +# ifdef SHORT_MIN +# define PERL_SHORT_MIN ((short)SHORT_MIN) +# else +# ifdef MINSHORT +# define PERL_SHORT_MIN ((short)MINSHORT) +# else +# ifdef SHRT_MIN +# define PERL_SHORT_MIN ((short)SHRT_MIN) +# else +# define PERL_SHORT_MIN (-PERL_SHORT_MAX - ((3 & -1) == 3)) +# endif +# endif +# endif +#endif + +#ifndef PERL_UINT_MAX +# ifdef UINT_MAX +# define PERL_UINT_MAX ((unsigned int)UINT_MAX) +# else +# ifdef MAXUINT +# define PERL_UINT_MAX ((unsigned int)MAXUINT) +# else +# define PERL_UINT_MAX (~(unsigned int)0) +# endif +# endif +#endif + +#ifndef PERL_UINT_MIN +# define PERL_UINT_MIN ((unsigned int)0) +#endif + +#ifndef PERL_INT_MAX +# ifdef INT_MAX +# define PERL_INT_MAX ((int)INT_MAX) +# else +# ifdef MAXINT /* Often used in <values.h> */ +# define PERL_INT_MAX ((int)MAXINT) +# else +# define PERL_INT_MAX ((int)(PERL_UINT_MAX >> 1)) +# endif +# endif +#endif + +#ifndef PERL_INT_MIN +# ifdef INT_MIN +# define PERL_INT_MIN ((int)INT_MIN) +# else +# ifdef MININT +# define PERL_INT_MIN ((int)MININT) +# else +# define PERL_INT_MIN (-PERL_INT_MAX - ((3 & -1) == 3)) +# endif +# endif +#endif + +#ifndef PERL_ULONG_MAX +# ifdef ULONG_MAX +# define PERL_ULONG_MAX ((unsigned long)ULONG_MAX) +# else +# ifdef MAXULONG +# define PERL_ULONG_MAX ((unsigned long)MAXULONG) +# else +# define PERL_ULONG_MAX (~(unsigned long)0) +# endif +# endif +#endif + +#ifndef PERL_ULONG_MIN +# define PERL_ULONG_MIN ((unsigned long)0L) +#endif + +#ifndef PERL_LONG_MAX +# ifdef LONG_MAX +# define PERL_LONG_MAX ((long)LONG_MAX) +# else +# ifdef MAXLONG +# define PERL_LONG_MAX ((long)MAXLONG) +# else +# define PERL_LONG_MAX ((long) (PERL_ULONG_MAX >> 1)) +# endif +# endif +#endif + +#ifndef PERL_LONG_MIN +# ifdef LONG_MIN +# define PERL_LONG_MIN ((long)LONG_MIN) +# else +# ifdef MINLONG +# define PERL_LONG_MIN ((long)MINLONG) +# else +# define PERL_LONG_MIN (-PERL_LONG_MAX - ((3 & -1) == 3)) +# endif +# endif +#endif + +#if defined(HAS_QUAD) && (defined(convex) || defined(uts)) +# ifndef PERL_UQUAD_MAX +# ifdef ULONGLONG_MAX +# define PERL_UQUAD_MAX ((unsigned long long)ULONGLONG_MAX) +# else +# ifdef MAXULONGLONG +# define PERL_UQUAD_MAX ((unsigned long long)MAXULONGLONG) +# else +# define PERL_UQUAD_MAX (~(unsigned long long)0) +# endif +# endif +# endif + +# ifndef PERL_UQUAD_MIN +# define PERL_UQUAD_MIN ((unsigned long long)0L) +# endif + +# ifndef PERL_QUAD_MAX +# ifdef LONGLONG_MAX +# define PERL_QUAD_MAX ((long long)LONGLONG_MAX) +# else +# ifdef MAXLONGLONG +# define PERL_QUAD_MAX ((long long)MAXLONGLONG) +# else +# define PERL_QUAD_MAX ((long long) (PERL_UQUAD_MAX >> 1)) +# endif +# endif +# endif + +# ifndef PERL_QUAD_MIN +# ifdef LONGLONG_MIN +# define PERL_QUAD_MIN ((long long)LONGLONG_MIN) +# else +# ifdef MINLONGLONG +# define PERL_QUAD_MIN ((long long)MINLONGLONG) +# else +# define PERL_QUAD_MIN (-PERL_QUAD_MAX - ((3 & -1) == 3)) +# endif +# endif +# endif +#endif + +/* This is based on code from 5.003 perl.h */ +#ifdef HAS_QUAD +# ifdef cray +#ifndef IVTYPE +# define IVTYPE int +#endif + +#ifndef IV_MIN +# define IV_MIN PERL_INT_MIN +#endif + +#ifndef IV_MAX +# define IV_MAX PERL_INT_MAX +#endif + +#ifndef UV_MIN +# define UV_MIN PERL_UINT_MIN +#endif + +#ifndef UV_MAX +# define UV_MAX PERL_UINT_MAX +#endif + +# ifdef INTSIZE +#ifndef IVSIZE +# define IVSIZE INTSIZE +#endif + +# endif +# else +# if defined(convex) || defined(uts) +#ifndef IVTYPE +# define IVTYPE long long +#endif + +#ifndef IV_MIN +# define IV_MIN PERL_QUAD_MIN +#endif + +#ifndef IV_MAX +# define IV_MAX PERL_QUAD_MAX +#endif + +#ifndef UV_MIN +# define UV_MIN PERL_UQUAD_MIN +#endif + +#ifndef UV_MAX +# define UV_MAX PERL_UQUAD_MAX +#endif + +# ifdef LONGLONGSIZE +#ifndef IVSIZE +# define IVSIZE LONGLONGSIZE +#endif + +# endif +# else +#ifndef IVTYPE +# define IVTYPE long +#endif + +#ifndef IV_MIN +# define IV_MIN PERL_LONG_MIN +#endif + +#ifndef IV_MAX +# define IV_MAX PERL_LONG_MAX +#endif + +#ifndef UV_MIN +# define UV_MIN PERL_ULONG_MIN +#endif + +#ifndef UV_MAX +# define UV_MAX PERL_ULONG_MAX +#endif + +# ifdef LONGSIZE +#ifndef IVSIZE +# define IVSIZE LONGSIZE +#endif + +# endif +# endif +# endif +#ifndef IVSIZE +# define IVSIZE 8 +#endif + +#ifndef PERL_QUAD_MIN +# define PERL_QUAD_MIN IV_MIN +#endif + +#ifndef PERL_QUAD_MAX +# define PERL_QUAD_MAX IV_MAX +#endif + +#ifndef PERL_UQUAD_MIN +# define PERL_UQUAD_MIN UV_MIN +#endif + +#ifndef PERL_UQUAD_MAX +# define PERL_UQUAD_MAX UV_MAX +#endif + +#else +#ifndef IVTYPE +# define IVTYPE long +#endif + +#ifndef IV_MIN +# define IV_MIN PERL_LONG_MIN +#endif + +#ifndef IV_MAX +# define IV_MAX PERL_LONG_MAX +#endif + +#ifndef UV_MIN +# define UV_MIN PERL_ULONG_MIN +#endif + +#ifndef UV_MAX +# define UV_MAX PERL_ULONG_MAX +#endif + +#endif + +#ifndef IVSIZE +# ifdef LONGSIZE +# define IVSIZE LONGSIZE +# else +# define IVSIZE 4 /* A bold guess, but the best we can make. */ +# endif +#endif +#ifndef UVTYPE +# define UVTYPE unsigned IVTYPE +#endif + +#ifndef UVSIZE +# define UVSIZE IVSIZE +#endif +#ifndef sv_setuv +# define sv_setuv(sv, uv) \ + STMT_START { \ + UV TeMpUv = uv; \ + if (TeMpUv <= IV_MAX) \ + sv_setiv(sv, TeMpUv); \ + else \ + sv_setnv(sv, (double)TeMpUv); \ + } STMT_END +#endif +#ifndef newSVuv +# define newSVuv(uv) ((uv) <= IV_MAX ? newSViv((IV)uv) : newSVnv((NV)uv)) +#endif +#ifndef sv_2uv +# define sv_2uv(sv) ((PL_Sv = (sv)), (UV) (SvNOK(PL_Sv) ? SvNV(PL_Sv) : sv_2nv(PL_Sv))) +#endif + +#ifndef SvUVX +# define SvUVX(sv) ((UV)SvIVX(sv)) +#endif + +#ifndef SvUVXx +# define SvUVXx(sv) SvUVX(sv) +#endif + +#ifndef SvUV +# define SvUV(sv) (SvIOK(sv) ? SvUVX(sv) : sv_2uv(sv)) +#endif + +#ifndef SvUVx +# define SvUVx(sv) ((PL_Sv = (sv)), SvUV(PL_Sv)) +#endif + +/* Hint: sv_uv + * Always use the SvUVx() macro instead of sv_uv(). + */ +#ifndef sv_uv +# define sv_uv(sv) SvUVx(sv) +#endif + +#if !defined(SvUOK) && defined(SvIOK_UV) +# define SvUOK(sv) SvIOK_UV(sv) +#endif +#ifndef XST_mUV +# define XST_mUV(i,v) (ST(i) = sv_2mortal(newSVuv(v)) ) +#endif + +#ifndef XSRETURN_UV +# define XSRETURN_UV(v) STMT_START { XST_mUV(0,v); XSRETURN(1); } STMT_END +#endif +#ifndef PUSHu +# define PUSHu(u) STMT_START { sv_setuv(TARG, (UV)(u)); PUSHTARG; } STMT_END +#endif + +#ifndef XPUSHu +# define XPUSHu(u) STMT_START { sv_setuv(TARG, (UV)(u)); XPUSHTARG; } STMT_END +#endif + +#ifdef HAS_MEMCMP +#ifndef memNE +# define memNE(s1,s2,l) (memcmp(s1,s2,l)) +#endif + +#ifndef memEQ +# define memEQ(s1,s2,l) (!memcmp(s1,s2,l)) +#endif + +#else +#ifndef memNE +# define memNE(s1,s2,l) (bcmp(s1,s2,l)) +#endif + +#ifndef memEQ +# define memEQ(s1,s2,l) (!bcmp(s1,s2,l)) +#endif + +#endif +#ifndef MoveD +# define MoveD(s,d,n,t) memmove((char*)(d),(char*)(s), (n) * sizeof(t)) +#endif + +#ifndef CopyD +# define CopyD(s,d,n,t) memcpy((char*)(d),(char*)(s), (n) * sizeof(t)) +#endif + +#ifdef HAS_MEMSET +#ifndef ZeroD +# define ZeroD(d,n,t) memzero((char*)(d), (n) * sizeof(t)) +#endif + +#else +#ifndef ZeroD +# define ZeroD(d,n,t) ((void)memzero((char*)(d), (n) * sizeof(t)), d) +#endif + +#endif +#ifndef PoisonWith +# define PoisonWith(d,n,t,b) (void)memset((char*)(d), (U8)(b), (n) * sizeof(t)) +#endif + +#ifndef PoisonNew +# define PoisonNew(d,n,t) PoisonWith(d,n,t,0xAB) +#endif + +#ifndef PoisonFree +# define PoisonFree(d,n,t) PoisonWith(d,n,t,0xEF) +#endif + +#ifndef Poison +# define Poison(d,n,t) PoisonFree(d,n,t) +#endif +#ifndef Newx +# define Newx(v,n,t) New(0,v,n,t) +#endif + +#ifndef Newxc +# define Newxc(v,n,t,c) Newc(0,v,n,t,c) +#endif + +#ifndef Newxz +# define Newxz(v,n,t) Newz(0,v,n,t) +#endif + +#ifndef PERL_UNUSED_DECL +# ifdef HASATTRIBUTE +# if (defined(__GNUC__) && defined(__cplusplus)) || defined(__INTEL_COMPILER) +# define PERL_UNUSED_DECL +# else +# define PERL_UNUSED_DECL __attribute__((unused)) +# endif +# else +# define PERL_UNUSED_DECL +# endif +#endif + +#ifndef PERL_UNUSED_ARG +# if defined(lint) && defined(S_SPLINT_S) /* www.splint.org */ +# include <note.h> +# define PERL_UNUSED_ARG(x) NOTE(ARGUNUSED(x)) +# else +# define PERL_UNUSED_ARG(x) ((void)x) +# endif +#endif + +#ifndef PERL_UNUSED_VAR +# define PERL_UNUSED_VAR(x) ((void)x) +#endif + +#ifndef PERL_UNUSED_CONTEXT +# ifdef USE_ITHREADS +# define PERL_UNUSED_CONTEXT PERL_UNUSED_ARG(my_perl) +# else +# define PERL_UNUSED_CONTEXT +# endif +#endif +#ifndef NOOP +# define NOOP /*EMPTY*/(void)0 +#endif + +#ifndef dNOOP +# define dNOOP extern int /*@unused@*/ Perl___notused PERL_UNUSED_DECL +#endif + +#ifndef NVTYPE +# if defined(USE_LONG_DOUBLE) && defined(HAS_LONG_DOUBLE) +# define NVTYPE long double +# else +# define NVTYPE double +# endif +typedef NVTYPE NV; +#endif + +#ifndef INT2PTR +# if (IVSIZE == PTRSIZE) && (UVSIZE == PTRSIZE) +# define PTRV UV +# define INT2PTR(any,d) (any)(d) +# else +# if PTRSIZE == LONGSIZE +# define PTRV unsigned long +# else +# define PTRV unsigned +# endif +# define INT2PTR(any,d) (any)(PTRV)(d) +# endif +#endif + +#ifndef PTR2ul +# if PTRSIZE == LONGSIZE +# define PTR2ul(p) (unsigned long)(p) +# else +# define PTR2ul(p) INT2PTR(unsigned long,p) +# endif +#endif +#ifndef PTR2nat +# define PTR2nat(p) (PTRV)(p) +#endif + +#ifndef NUM2PTR +# define NUM2PTR(any,d) (any)PTR2nat(d) +#endif + +#ifndef PTR2IV +# define PTR2IV(p) INT2PTR(IV,p) +#endif + +#ifndef PTR2UV +# define PTR2UV(p) INT2PTR(UV,p) +#endif + +#ifndef PTR2NV +# define PTR2NV(p) NUM2PTR(NV,p) +#endif + +#undef START_EXTERN_C +#undef END_EXTERN_C +#undef EXTERN_C +#ifdef __cplusplus +# define START_EXTERN_C extern "C" { +# define END_EXTERN_C } +# define EXTERN_C extern "C" +#else +# define START_EXTERN_C +# define END_EXTERN_C +# define EXTERN_C extern +#endif + +#if defined(PERL_GCC_PEDANTIC) +# ifndef PERL_GCC_BRACE_GROUPS_FORBIDDEN +# define PERL_GCC_BRACE_GROUPS_FORBIDDEN +# endif +#endif + +#if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN) && !defined(__cplusplus) +# ifndef PERL_USE_GCC_BRACE_GROUPS +# define PERL_USE_GCC_BRACE_GROUPS +# endif +#endif + +#undef STMT_START +#undef STMT_END +#ifdef PERL_USE_GCC_BRACE_GROUPS +# define STMT_START (void)( /* gcc supports ``({ STATEMENTS; })'' */ +# define STMT_END ) +#else +# if defined(VOIDFLAGS) && (VOIDFLAGS) && (defined(sun) || defined(__sun__)) && !defined(__GNUC__) +# define STMT_START if (1) +# define STMT_END else (void)0 +# else +# define STMT_START do +# define STMT_END while (0) +# endif +#endif +#ifndef boolSV +# define boolSV(b) ((b) ? &PL_sv_yes : &PL_sv_no) +#endif + +/* DEFSV appears first in 5.004_56 */ +#ifndef DEFSV +# define DEFSV GvSV(PL_defgv) +#endif + +#ifndef SAVE_DEFSV +# define SAVE_DEFSV SAVESPTR(GvSV(PL_defgv)) +#endif + +#ifndef DEFSV_set +# define DEFSV_set(sv) (DEFSV = (sv)) +#endif + +/* Older perls (<=5.003) lack AvFILLp */ +#ifndef AvFILLp +# define AvFILLp AvFILL +#endif +#ifndef ERRSV +# define ERRSV get_sv("@",FALSE) +#endif + +/* Hint: gv_stashpvn + * This function's backport doesn't support the length parameter, but + * rather ignores it. Portability can only be ensured if the length + * parameter is used for speed reasons, but the length can always be + * correctly computed from the string argument. + */ +#ifndef gv_stashpvn +# define gv_stashpvn(str,len,create) gv_stashpv(str,create) +#endif + +/* Replace: 1 */ +#ifndef get_cv +# define get_cv perl_get_cv +#endif + +#ifndef get_sv +# define get_sv perl_get_sv +#endif + +#ifndef get_av +# define get_av perl_get_av +#endif + +#ifndef get_hv +# define get_hv perl_get_hv +#endif + +/* Replace: 0 */ +#ifndef dUNDERBAR +# define dUNDERBAR dNOOP +#endif + +#ifndef UNDERBAR +# define UNDERBAR DEFSV +#endif +#ifndef dAX +# define dAX I32 ax = MARK - PL_stack_base + 1 +#endif + +#ifndef dITEMS +# define dITEMS I32 items = SP - MARK +#endif +#ifndef dXSTARG +# define dXSTARG SV * targ = sv_newmortal() +#endif +#ifndef dAXMARK +# define dAXMARK I32 ax = POPMARK; \ + register SV ** const mark = PL_stack_base + ax++ +#endif +#ifndef XSprePUSH +# define XSprePUSH (sp = PL_stack_base + ax - 1) +#endif + +#if (PERL_BCDVERSION < 0x5005000) +# undef XSRETURN +# define XSRETURN(off) \ + STMT_START { \ + PL_stack_sp = PL_stack_base + ax + ((off) - 1); \ + return; \ + } STMT_END +#endif +#ifndef XSPROTO +# define XSPROTO(name) void name(pTHX_ CV* cv) +#endif + +#ifndef SVfARG +# define SVfARG(p) ((void*)(p)) +#endif +#ifndef PERL_ABS +# define PERL_ABS(x) ((x) < 0 ? -(x) : (x)) +#endif +#ifndef dVAR +# define dVAR dNOOP +#endif +#ifndef SVf +# define SVf "_" +#endif +#ifndef UTF8_MAXBYTES +# define UTF8_MAXBYTES UTF8_MAXLEN +#endif +#ifndef CPERLscope +# define CPERLscope(x) x +#endif +#ifndef PERL_HASH +# define PERL_HASH(hash,str,len) \ + STMT_START { \ + const char *s_PeRlHaSh = str; \ + I32 i_PeRlHaSh = len; \ + U32 hash_PeRlHaSh = 0; \ + while (i_PeRlHaSh--) \ + hash_PeRlHaSh = hash_PeRlHaSh * 33 + *s_PeRlHaSh++; \ + (hash) = hash_PeRlHaSh; \ + } STMT_END +#endif + +#ifndef PERLIO_FUNCS_DECL +# ifdef PERLIO_FUNCS_CONST +# define PERLIO_FUNCS_DECL(funcs) const PerlIO_funcs funcs +# define PERLIO_FUNCS_CAST(funcs) (PerlIO_funcs*)(funcs) +# else +# define PERLIO_FUNCS_DECL(funcs) PerlIO_funcs funcs +# define PERLIO_FUNCS_CAST(funcs) (funcs) +# endif +#endif + +/* provide these typedefs for older perls */ +#if (PERL_BCDVERSION < 0x5009003) + +# ifdef ARGSproto +typedef OP* (CPERLscope(*Perl_ppaddr_t))(ARGSproto); +# else +typedef OP* (CPERLscope(*Perl_ppaddr_t))(pTHX); +# endif + +typedef OP* (CPERLscope(*Perl_check_t)) (pTHX_ OP*); + +#endif +#ifndef isPSXSPC +# define isPSXSPC(c) (isSPACE(c) || (c) == '\v') +#endif + +#ifndef isBLANK +# define isBLANK(c) ((c) == ' ' || (c) == '\t') +#endif + +#ifdef EBCDIC +#ifndef isALNUMC +# define isALNUMC(c) isalnum(c) +#endif + +#ifndef isASCII +# define isASCII(c) isascii(c) +#endif + +#ifndef isCNTRL +# define isCNTRL(c) iscntrl(c) +#endif + +#ifndef isGRAPH +# define isGRAPH(c) isgraph(c) +#endif + +#ifndef isPRINT +# define isPRINT(c) isprint(c) +#endif + +#ifndef isPUNCT +# define isPUNCT(c) ispunct(c) +#endif + +#ifndef isXDIGIT +# define isXDIGIT(c) isxdigit(c) +#endif + +#else +# if (PERL_BCDVERSION < 0x5010000) +/* Hint: isPRINT + * The implementation in older perl versions includes all of the + * isSPACE() characters, which is wrong. The version provided by + * Devel::PPPort always overrides a present buggy version. + */ +# undef isPRINT +# endif +#ifndef isALNUMC +# define isALNUMC(c) (isALPHA(c) || isDIGIT(c)) +#endif + +#ifndef isASCII +# define isASCII(c) ((c) <= 127) +#endif + +#ifndef isCNTRL +# define isCNTRL(c) ((c) < ' ' || (c) == 127) +#endif + +#ifndef isGRAPH +# define isGRAPH(c) (isALNUM(c) || isPUNCT(c)) +#endif + +#ifndef isPRINT +# define isPRINT(c) (((c) >= 32 && (c) < 127)) +#endif + +#ifndef isPUNCT +# define isPUNCT(c) (((c) >= 33 && (c) <= 47) || ((c) >= 58 && (c) <= 64) || ((c) >= 91 && (c) <= 96) || ((c) >= 123 && (c) <= 126)) +#endif + +#ifndef isXDIGIT +# define isXDIGIT(c) (isDIGIT(c) || ((c) >= 'a' && (c) <= 'f') || ((c) >= 'A' && (c) <= 'F')) +#endif + +#endif + +#ifndef PERL_SIGNALS_UNSAFE_FLAG + +#define PERL_SIGNALS_UNSAFE_FLAG 0x0001 + +#if (PERL_BCDVERSION < 0x5008000) +# define D_PPP_PERL_SIGNALS_INIT PERL_SIGNALS_UNSAFE_FLAG +#else +# define D_PPP_PERL_SIGNALS_INIT 0 +#endif + +#if defined(NEED_PL_signals) +static U32 DPPP_(my_PL_signals) = D_PPP_PERL_SIGNALS_INIT; +#elif defined(NEED_PL_signals_GLOBAL) +U32 DPPP_(my_PL_signals) = D_PPP_PERL_SIGNALS_INIT; +#else +extern U32 DPPP_(my_PL_signals); +#endif +#define PL_signals DPPP_(my_PL_signals) + +#endif + +/* Hint: PL_ppaddr + * Calling an op via PL_ppaddr requires passing a context argument + * for threaded builds. Since the context argument is different for + * 5.005 perls, you can use aTHXR (supplied by ppport.h), which will + * automatically be defined as the correct argument. + */ + +#if (PERL_BCDVERSION <= 0x5005005) +/* Replace: 1 */ +# define PL_ppaddr ppaddr +# define PL_no_modify no_modify +/* Replace: 0 */ +#endif + +#if (PERL_BCDVERSION <= 0x5004005) +/* Replace: 1 */ +# define PL_DBsignal DBsignal +# define PL_DBsingle DBsingle +# define PL_DBsub DBsub +# define PL_DBtrace DBtrace +# define PL_Sv Sv +# define PL_bufend bufend +# define PL_bufptr bufptr +# define PL_compiling compiling +# define PL_copline copline +# define PL_curcop curcop +# define PL_curstash curstash +# define PL_debstash debstash +# define PL_defgv defgv +# define PL_diehook diehook +# define PL_dirty dirty +# define PL_dowarn dowarn +# define PL_errgv errgv +# define PL_error_count error_count +# define PL_expect expect +# define PL_hexdigit hexdigit +# define PL_hints hints +# define PL_in_my in_my +# define PL_laststatval laststatval +# define PL_lex_state lex_state +# define PL_lex_stuff lex_stuff +# define PL_linestr linestr +# define PL_na na +# define PL_perl_destruct_level perl_destruct_level +# define PL_perldb perldb +# define PL_rsfp_filters rsfp_filters +# define PL_rsfp rsfp +# define PL_stack_base stack_base +# define PL_stack_sp stack_sp +# define PL_statcache statcache +# define PL_stdingv stdingv +# define PL_sv_arenaroot sv_arenaroot +# define PL_sv_no sv_no +# define PL_sv_undef sv_undef +# define PL_sv_yes sv_yes +# define PL_tainted tainted +# define PL_tainting tainting +# define PL_tokenbuf tokenbuf +/* Replace: 0 */ +#endif + +/* Warning: PL_parser + * For perl versions earlier than 5.9.5, this is an always + * non-NULL dummy. Also, it cannot be dereferenced. Don't + * use it if you can avoid is and unless you absolutely know + * what you're doing. + * If you always check that PL_parser is non-NULL, you can + * define DPPP_PL_parser_NO_DUMMY to avoid the creation of + * a dummy parser structure. + */ + +#if (PERL_BCDVERSION >= 0x5009005) +# ifdef DPPP_PL_parser_NO_DUMMY +# define D_PPP_my_PL_parser_var(var) ((PL_parser ? PL_parser : \ + (croak("panic: PL_parser == NULL in %s:%d", \ + __FILE__, __LINE__), (yy_parser *) NULL))->var) +# else +# ifdef DPPP_PL_parser_NO_DUMMY_WARNING +# define D_PPP_parser_dummy_warning(var) +# else +# define D_PPP_parser_dummy_warning(var) \ + warn("warning: dummy PL_" #var " used in %s:%d", __FILE__, __LINE__), +# endif +# define D_PPP_my_PL_parser_var(var) ((PL_parser ? PL_parser : \ + (D_PPP_parser_dummy_warning(var) &DPPP_(dummy_PL_parser)))->var) +#if defined(NEED_PL_parser) +static yy_parser DPPP_(dummy_PL_parser); +#elif defined(NEED_PL_parser_GLOBAL) +yy_parser DPPP_(dummy_PL_parser); +#else +extern yy_parser DPPP_(dummy_PL_parser); +#endif + +# endif + +/* PL_expect, PL_copline, PL_rsfp, PL_rsfp_filters, PL_linestr, PL_bufptr, PL_bufend, PL_lex_state, PL_lex_stuff, PL_tokenbuf depends on PL_parser */ +/* Warning: PL_expect, PL_copline, PL_rsfp, PL_rsfp_filters, PL_linestr, PL_bufptr, PL_bufend, PL_lex_state, PL_lex_stuff, PL_tokenbuf + * Do not use this variable unless you know exactly what you're + * doint. It is internal to the perl parser and may change or even + * be removed in the future. As of perl 5.9.5, you have to check + * for (PL_parser != NULL) for this variable to have any effect. + * An always non-NULL PL_parser dummy is provided for earlier + * perl versions. + * If PL_parser is NULL when you try to access this variable, a + * dummy is being accessed instead and a warning is issued unless + * you define DPPP_PL_parser_NO_DUMMY_WARNING. + * If DPPP_PL_parser_NO_DUMMY is defined, the code trying to access + * this variable will croak with a panic message. + */ + +# define PL_expect D_PPP_my_PL_parser_var(expect) +# define PL_copline D_PPP_my_PL_parser_var(copline) +# define PL_rsfp D_PPP_my_PL_parser_var(rsfp) +# define PL_rsfp_filters D_PPP_my_PL_parser_var(rsfp_filters) +# define PL_linestr D_PPP_my_PL_parser_var(linestr) +# define PL_bufptr D_PPP_my_PL_parser_var(bufptr) +# define PL_bufend D_PPP_my_PL_parser_var(bufend) +# define PL_lex_state D_PPP_my_PL_parser_var(lex_state) +# define PL_lex_stuff D_PPP_my_PL_parser_var(lex_stuff) +# define PL_tokenbuf D_PPP_my_PL_parser_var(tokenbuf) +# define PL_in_my D_PPP_my_PL_parser_var(in_my) +# define PL_in_my_stash D_PPP_my_PL_parser_var(in_my_stash) +# define PL_error_count D_PPP_my_PL_parser_var(error_count) + + +#else + +/* ensure that PL_parser != NULL and cannot be dereferenced */ +# define PL_parser ((void *) 1) + +#endif +#ifndef mPUSHs +# define mPUSHs(s) PUSHs(sv_2mortal(s)) +#endif + +#ifndef PUSHmortal +# define PUSHmortal PUSHs(sv_newmortal()) +#endif + +#ifndef mPUSHp +# define mPUSHp(p,l) sv_setpvn(PUSHmortal, (p), (l)) +#endif + +#ifndef mPUSHn +# define mPUSHn(n) sv_setnv(PUSHmortal, (NV)(n)) +#endif + +#ifndef mPUSHi +# define mPUSHi(i) sv_setiv(PUSHmortal, (IV)(i)) +#endif + +#ifndef mPUSHu +# define mPUSHu(u) sv_setuv(PUSHmortal, (UV)(u)) +#endif +#ifndef mXPUSHs +# define mXPUSHs(s) XPUSHs(sv_2mortal(s)) +#endif + +#ifndef XPUSHmortal +# define XPUSHmortal XPUSHs(sv_newmortal()) +#endif + +#ifndef mXPUSHp +# define mXPUSHp(p,l) STMT_START { EXTEND(sp,1); sv_setpvn(PUSHmortal, (p), (l)); } STMT_END +#endif + +#ifndef mXPUSHn +# define mXPUSHn(n) STMT_START { EXTEND(sp,1); sv_setnv(PUSHmortal, (NV)(n)); } STMT_END +#endif + +#ifndef mXPUSHi +# define mXPUSHi(i) STMT_START { EXTEND(sp,1); sv_setiv(PUSHmortal, (IV)(i)); } STMT_END +#endif + +#ifndef mXPUSHu +# define mXPUSHu(u) STMT_START { EXTEND(sp,1); sv_setuv(PUSHmortal, (UV)(u)); } STMT_END +#endif + +/* Replace: 1 */ +#ifndef call_sv +# define call_sv perl_call_sv +#endif + +#ifndef call_pv +# define call_pv perl_call_pv +#endif + +#ifndef call_argv +# define call_argv perl_call_argv +#endif + +#ifndef call_method +# define call_method perl_call_method +#endif +#ifndef eval_sv +# define eval_sv perl_eval_sv +#endif + +/* Replace: 0 */ +#ifndef PERL_LOADMOD_DENY +# define PERL_LOADMOD_DENY 0x1 +#endif + +#ifndef PERL_LOADMOD_NOIMPORT +# define PERL_LOADMOD_NOIMPORT 0x2 +#endif + +#ifndef PERL_LOADMOD_IMPORT_OPS +# define PERL_LOADMOD_IMPORT_OPS 0x4 +#endif + +#ifndef G_METHOD +# define G_METHOD 64 +# ifdef call_sv +# undef call_sv +# endif +# if (PERL_BCDVERSION < 0x5006000) +# define call_sv(sv, flags) ((flags) & G_METHOD ? perl_call_method((char *) SvPV_nolen_const(sv), \ + (flags) & ~G_METHOD) : perl_call_sv(sv, flags)) +# else +# define call_sv(sv, flags) ((flags) & G_METHOD ? Perl_call_method(aTHX_ (char *) SvPV_nolen_const(sv), \ + (flags) & ~G_METHOD) : Perl_call_sv(aTHX_ sv, flags)) +# endif +#endif + +/* Replace perl_eval_pv with eval_pv */ + +#ifndef eval_pv +#if defined(NEED_eval_pv) +static SV* DPPP_(my_eval_pv)(char *p, I32 croak_on_error); +static +#else +extern SV* DPPP_(my_eval_pv)(char *p, I32 croak_on_error); +#endif + +#ifdef eval_pv +# undef eval_pv +#endif +#define eval_pv(a,b) DPPP_(my_eval_pv)(aTHX_ a,b) +#define Perl_eval_pv DPPP_(my_eval_pv) + +#if defined(NEED_eval_pv) || defined(NEED_eval_pv_GLOBAL) + +SV* +DPPP_(my_eval_pv)(char *p, I32 croak_on_error) +{ + dSP; + SV* sv = newSVpv(p, 0); + + PUSHMARK(sp); + eval_sv(sv, G_SCALAR); + SvREFCNT_dec(sv); + + SPAGAIN; + sv = POPs; + PUTBACK; + + if (croak_on_error && SvTRUE(GvSV(errgv))) + croak(SvPVx(GvSV(errgv), na)); + + return sv; +} + +#endif +#endif + +#ifndef vload_module +#if defined(NEED_vload_module) +static void DPPP_(my_vload_module)(U32 flags, SV *name, SV *ver, va_list *args); +static +#else +extern void DPPP_(my_vload_module)(U32 flags, SV *name, SV *ver, va_list *args); +#endif + +#ifdef vload_module +# undef vload_module +#endif +#define vload_module(a,b,c,d) DPPP_(my_vload_module)(aTHX_ a,b,c,d) +#define Perl_vload_module DPPP_(my_vload_module) + +#if defined(NEED_vload_module) || defined(NEED_vload_module_GLOBAL) + +void +DPPP_(my_vload_module)(U32 flags, SV *name, SV *ver, va_list *args) +{ + dTHR; + dVAR; + OP *veop, *imop; + + OP * const modname = newSVOP(OP_CONST, 0, name); + /* 5.005 has a somewhat hacky force_normal that doesn't croak on + SvREADONLY() if PL_compling is true. Current perls take care in + ck_require() to correctly turn off SvREADONLY before calling + force_normal_flags(). This seems a better fix than fudging PL_compling + */ + SvREADONLY_off(((SVOP*)modname)->op_sv); + modname->op_private |= OPpCONST_BARE; + if (ver) { + veop = newSVOP(OP_CONST, 0, ver); + } + else + veop = NULL; + if (flags & PERL_LOADMOD_NOIMPORT) { + imop = sawparens(newNULLLIST()); + } + else if (flags & PERL_LOADMOD_IMPORT_OPS) { + imop = va_arg(*args, OP*); + } + else { + SV *sv; + imop = NULL; + sv = va_arg(*args, SV*); + while (sv) { + imop = append_elem(OP_LIST, imop, newSVOP(OP_CONST, 0, sv)); + sv = va_arg(*args, SV*); + } + } + { + const line_t ocopline = PL_copline; + COP * const ocurcop = PL_curcop; + const int oexpect = PL_expect; + +#if (PERL_BCDVERSION >= 0x5004000) + utilize(!(flags & PERL_LOADMOD_DENY), start_subparse(FALSE, 0), + veop, modname, imop); +#else + utilize(!(flags & PERL_LOADMOD_DENY), start_subparse(), + modname, imop); +#endif + PL_expect = oexpect; + PL_copline = ocopline; + PL_curcop = ocurcop; + } +} + +#endif +#endif + +#ifndef load_module +#if defined(NEED_load_module) +static void DPPP_(my_load_module)(U32 flags, SV *name, SV *ver, ...); +static +#else +extern void DPPP_(my_load_module)(U32 flags, SV *name, SV *ver, ...); +#endif + +#ifdef load_module +# undef load_module +#endif +#define load_module DPPP_(my_load_module) +#define Perl_load_module DPPP_(my_load_module) + +#if defined(NEED_load_module) || defined(NEED_load_module_GLOBAL) + +void +DPPP_(my_load_module)(U32 flags, SV *name, SV *ver, ...) +{ + va_list args; + va_start(args, ver); + vload_module(flags, name, ver, &args); + va_end(args); +} + +#endif +#endif +#ifndef newRV_inc +# define newRV_inc(sv) newRV(sv) /* Replace */ +#endif + +#ifndef newRV_noinc +#if defined(NEED_newRV_noinc) +static SV * DPPP_(my_newRV_noinc)(SV *sv); +static +#else +extern SV * DPPP_(my_newRV_noinc)(SV *sv); +#endif + +#ifdef newRV_noinc +# undef newRV_noinc +#endif +#define newRV_noinc(a) DPPP_(my_newRV_noinc)(aTHX_ a) +#define Perl_newRV_noinc DPPP_(my_newRV_noinc) + +#if defined(NEED_newRV_noinc) || defined(NEED_newRV_noinc_GLOBAL) +SV * +DPPP_(my_newRV_noinc)(SV *sv) +{ + SV *rv = (SV *)newRV(sv); + SvREFCNT_dec(sv); + return rv; +} +#endif +#endif + +/* Hint: newCONSTSUB + * Returns a CV* as of perl-5.7.1. This return value is not supported + * by Devel::PPPort. + */ + +/* newCONSTSUB from IO.xs is in the core starting with 5.004_63 */ +#if (PERL_BCDVERSION < 0x5004063) && (PERL_BCDVERSION != 0x5004005) +#if defined(NEED_newCONSTSUB) +static void DPPP_(my_newCONSTSUB)(HV *stash, const char *name, SV *sv); +static +#else +extern void DPPP_(my_newCONSTSUB)(HV *stash, const char *name, SV *sv); +#endif + +#ifdef newCONSTSUB +# undef newCONSTSUB +#endif +#define newCONSTSUB(a,b,c) DPPP_(my_newCONSTSUB)(aTHX_ a,b,c) +#define Perl_newCONSTSUB DPPP_(my_newCONSTSUB) + +#if defined(NEED_newCONSTSUB) || defined(NEED_newCONSTSUB_GLOBAL) + +/* This is just a trick to avoid a dependency of newCONSTSUB on PL_parser */ +/* (There's no PL_parser in perl < 5.005, so this is completely safe) */ +#define D_PPP_PL_copline PL_copline + +void +DPPP_(my_newCONSTSUB)(HV *stash, const char *name, SV *sv) +{ + U32 oldhints = PL_hints; + HV *old_cop_stash = PL_curcop->cop_stash; + HV *old_curstash = PL_curstash; + line_t oldline = PL_curcop->cop_line; + PL_curcop->cop_line = D_PPP_PL_copline; + + PL_hints &= ~HINT_BLOCK_SCOPE; + if (stash) + PL_curstash = PL_curcop->cop_stash = stash; + + newSUB( + +#if (PERL_BCDVERSION < 0x5003022) + start_subparse(), +#elif (PERL_BCDVERSION == 0x5003022) + start_subparse(0), +#else /* 5.003_23 onwards */ + start_subparse(FALSE, 0), +#endif + + newSVOP(OP_CONST, 0, newSVpv((char *) name, 0)), + newSVOP(OP_CONST, 0, &PL_sv_no), /* SvPV(&PL_sv_no) == "" -- GMB */ + newSTATEOP(0, Nullch, newSVOP(OP_CONST, 0, sv)) + ); + + PL_hints = oldhints; + PL_curcop->cop_stash = old_cop_stash; + PL_curstash = old_curstash; + PL_curcop->cop_line = oldline; +} +#endif +#endif + +/* + * Boilerplate macros for initializing and accessing interpreter-local + * data from C. All statics in extensions should be reworked to use + * this, if you want to make the extension thread-safe. See ext/re/re.xs + * for an example of the use of these macros. + * + * Code that uses these macros is responsible for the following: + * 1. #define MY_CXT_KEY to a unique string, e.g. "DynaLoader_guts" + * 2. Declare a typedef named my_cxt_t that is a structure that contains + * all the data that needs to be interpreter-local. + * 3. Use the START_MY_CXT macro after the declaration of my_cxt_t. + * 4. Use the MY_CXT_INIT macro such that it is called exactly once + * (typically put in the BOOT: section). + * 5. Use the members of the my_cxt_t structure everywhere as + * MY_CXT.member. + * 6. Use the dMY_CXT macro (a declaration) in all the functions that + * access MY_CXT. + */ + +#if defined(MULTIPLICITY) || defined(PERL_OBJECT) || \ + defined(PERL_CAPI) || defined(PERL_IMPLICIT_CONTEXT) + +#ifndef START_MY_CXT + +/* This must appear in all extensions that define a my_cxt_t structure, + * right after the definition (i.e. at file scope). The non-threads + * case below uses it to declare the data as static. */ +#define START_MY_CXT + +#if (PERL_BCDVERSION < 0x5004068) +/* Fetches the SV that keeps the per-interpreter data. */ +#define dMY_CXT_SV \ + SV *my_cxt_sv = get_sv(MY_CXT_KEY, FALSE) +#else /* >= perl5.004_68 */ +#define dMY_CXT_SV \ + SV *my_cxt_sv = *hv_fetch(PL_modglobal, MY_CXT_KEY, \ + sizeof(MY_CXT_KEY)-1, TRUE) +#endif /* < perl5.004_68 */ + +/* This declaration should be used within all functions that use the + * interpreter-local data. */ +#define dMY_CXT \ + dMY_CXT_SV; \ + my_cxt_t *my_cxtp = INT2PTR(my_cxt_t*,SvUV(my_cxt_sv)) + +/* Creates and zeroes the per-interpreter data. + * (We allocate my_cxtp in a Perl SV so that it will be released when + * the interpreter goes away.) */ +#define MY_CXT_INIT \ + dMY_CXT_SV; \ + /* newSV() allocates one more than needed */ \ + my_cxt_t *my_cxtp = (my_cxt_t*)SvPVX(newSV(sizeof(my_cxt_t)-1));\ + Zero(my_cxtp, 1, my_cxt_t); \ + sv_setuv(my_cxt_sv, PTR2UV(my_cxtp)) + +/* This macro must be used to access members of the my_cxt_t structure. + * e.g. MYCXT.some_data */ +#define MY_CXT (*my_cxtp) + +/* Judicious use of these macros can reduce the number of times dMY_CXT + * is used. Use is similar to pTHX, aTHX etc. */ +#define pMY_CXT my_cxt_t *my_cxtp +#define pMY_CXT_ pMY_CXT, +#define _pMY_CXT ,pMY_CXT +#define aMY_CXT my_cxtp +#define aMY_CXT_ aMY_CXT, +#define _aMY_CXT ,aMY_CXT + +#endif /* START_MY_CXT */ + +#ifndef MY_CXT_CLONE +/* Clones the per-interpreter data. */ +#define MY_CXT_CLONE \ + dMY_CXT_SV; \ + my_cxt_t *my_cxtp = (my_cxt_t*)SvPVX(newSV(sizeof(my_cxt_t)-1));\ + Copy(INT2PTR(my_cxt_t*, SvUV(my_cxt_sv)), my_cxtp, 1, my_cxt_t);\ + sv_setuv(my_cxt_sv, PTR2UV(my_cxtp)) +#endif + +#else /* single interpreter */ + +#ifndef START_MY_CXT + +#define START_MY_CXT static my_cxt_t my_cxt; +#define dMY_CXT_SV dNOOP +#define dMY_CXT dNOOP +#define MY_CXT_INIT NOOP +#define MY_CXT my_cxt + +#define pMY_CXT void +#define pMY_CXT_ +#define _pMY_CXT +#define aMY_CXT +#define aMY_CXT_ +#define _aMY_CXT + +#endif /* START_MY_CXT */ + +#ifndef MY_CXT_CLONE +#define MY_CXT_CLONE NOOP +#endif + +#endif + +#ifndef IVdf +# if IVSIZE == LONGSIZE +# define IVdf "ld" +# define UVuf "lu" +# define UVof "lo" +# define UVxf "lx" +# define UVXf "lX" +# else +# if IVSIZE == INTSIZE +# define IVdf "d" +# define UVuf "u" +# define UVof "o" +# define UVxf "x" +# define UVXf "X" +# endif +# endif +#endif + +#ifndef NVef +# if defined(USE_LONG_DOUBLE) && defined(HAS_LONG_DOUBLE) && \ + defined(PERL_PRIfldbl) && (PERL_BCDVERSION != 0x5006000) + /* Not very likely, but let's try anyway. */ +# define NVef PERL_PRIeldbl +# define NVff PERL_PRIfldbl +# define NVgf PERL_PRIgldbl +# else +# define NVef "e" +# define NVff "f" +# define NVgf "g" +# endif +#endif + +#ifndef SvREFCNT_inc +# ifdef PERL_USE_GCC_BRACE_GROUPS +# define SvREFCNT_inc(sv) \ + ({ \ + SV * const _sv = (SV*)(sv); \ + if (_sv) \ + (SvREFCNT(_sv))++; \ + _sv; \ + }) +# else +# define SvREFCNT_inc(sv) \ + ((PL_Sv=(SV*)(sv)) ? (++(SvREFCNT(PL_Sv)),PL_Sv) : NULL) +# endif +#endif + +#ifndef SvREFCNT_inc_simple +# ifdef PERL_USE_GCC_BRACE_GROUPS +# define SvREFCNT_inc_simple(sv) \ + ({ \ + if (sv) \ + (SvREFCNT(sv))++; \ + (SV *)(sv); \ + }) +# else +# define SvREFCNT_inc_simple(sv) \ + ((sv) ? (SvREFCNT(sv)++,(SV*)(sv)) : NULL) +# endif +#endif + +#ifndef SvREFCNT_inc_NN +# ifdef PERL_USE_GCC_BRACE_GROUPS +# define SvREFCNT_inc_NN(sv) \ + ({ \ + SV * const _sv = (SV*)(sv); \ + SvREFCNT(_sv)++; \ + _sv; \ + }) +# else +# define SvREFCNT_inc_NN(sv) \ + (PL_Sv=(SV*)(sv),++(SvREFCNT(PL_Sv)),PL_Sv) +# endif +#endif + +#ifndef SvREFCNT_inc_void +# ifdef PERL_USE_GCC_BRACE_GROUPS +# define SvREFCNT_inc_void(sv) \ + ({ \ + SV * const _sv = (SV*)(sv); \ + if (_sv) \ + (void)(SvREFCNT(_sv)++); \ + }) +# else +# define SvREFCNT_inc_void(sv) \ + (void)((PL_Sv=(SV*)(sv)) ? ++(SvREFCNT(PL_Sv)) : 0) +# endif +#endif +#ifndef SvREFCNT_inc_simple_void +# define SvREFCNT_inc_simple_void(sv) STMT_START { if (sv) SvREFCNT(sv)++; } STMT_END +#endif + +#ifndef SvREFCNT_inc_simple_NN +# define SvREFCNT_inc_simple_NN(sv) (++SvREFCNT(sv), (SV*)(sv)) +#endif + +#ifndef SvREFCNT_inc_void_NN +# define SvREFCNT_inc_void_NN(sv) (void)(++SvREFCNT((SV*)(sv))) +#endif + +#ifndef SvREFCNT_inc_simple_void_NN +# define SvREFCNT_inc_simple_void_NN(sv) (void)(++SvREFCNT((SV*)(sv))) +#endif + +#ifndef newSV_type + +#if defined(NEED_newSV_type) +static SV* DPPP_(my_newSV_type)(pTHX_ svtype const t); +static +#else +extern SV* DPPP_(my_newSV_type)(pTHX_ svtype const t); +#endif + +#ifdef newSV_type +# undef newSV_type +#endif +#define newSV_type(a) DPPP_(my_newSV_type)(aTHX_ a) +#define Perl_newSV_type DPPP_(my_newSV_type) + +#if defined(NEED_newSV_type) || defined(NEED_newSV_type_GLOBAL) + +SV* +DPPP_(my_newSV_type)(pTHX_ svtype const t) +{ + SV* const sv = newSV(0); + sv_upgrade(sv, t); + return sv; +} + +#endif + +#endif + +#if (PERL_BCDVERSION < 0x5006000) +# define D_PPP_CONSTPV_ARG(x) ((char *) (x)) +#else +# define D_PPP_CONSTPV_ARG(x) (x) +#endif +#ifndef newSVpvn +# define newSVpvn(data,len) ((data) \ + ? ((len) ? newSVpv((data), (len)) : newSVpv("", 0)) \ + : newSV(0)) +#endif +#ifndef newSVpvn_utf8 +# define newSVpvn_utf8(s, len, u) newSVpvn_flags((s), (len), (u) ? SVf_UTF8 : 0) +#endif +#ifndef SVf_UTF8 +# define SVf_UTF8 0 +#endif + +#ifndef newSVpvn_flags + +#if defined(NEED_newSVpvn_flags) +static SV * DPPP_(my_newSVpvn_flags)(pTHX_ const char *s, STRLEN len, U32 flags); +static +#else +extern SV * DPPP_(my_newSVpvn_flags)(pTHX_ const char *s, STRLEN len, U32 flags); +#endif + +#ifdef newSVpvn_flags +# undef newSVpvn_flags +#endif +#define newSVpvn_flags(a,b,c) DPPP_(my_newSVpvn_flags)(aTHX_ a,b,c) +#define Perl_newSVpvn_flags DPPP_(my_newSVpvn_flags) + +#if defined(NEED_newSVpvn_flags) || defined(NEED_newSVpvn_flags_GLOBAL) + +SV * +DPPP_(my_newSVpvn_flags)(pTHX_ const char *s, STRLEN len, U32 flags) +{ + SV *sv = newSVpvn(D_PPP_CONSTPV_ARG(s), len); + SvFLAGS(sv) |= (flags & SVf_UTF8); + return (flags & SVs_TEMP) ? sv_2mortal(sv) : sv; +} + +#endif + +#endif + +/* Backwards compatibility stuff... :-( */ +#if !defined(NEED_sv_2pv_flags) && defined(NEED_sv_2pv_nolen) +# define NEED_sv_2pv_flags +#endif +#if !defined(NEED_sv_2pv_flags_GLOBAL) && defined(NEED_sv_2pv_nolen_GLOBAL) +# define NEED_sv_2pv_flags_GLOBAL +#endif + +/* Hint: sv_2pv_nolen + * Use the SvPV_nolen() or SvPV_nolen_const() macros instead of sv_2pv_nolen(). + */ +#ifndef sv_2pv_nolen +# define sv_2pv_nolen(sv) SvPV_nolen(sv) +#endif + +#ifdef SvPVbyte + +/* Hint: SvPVbyte + * Does not work in perl-5.6.1, ppport.h implements a version + * borrowed from perl-5.7.3. + */ + +#if (PERL_BCDVERSION < 0x5007000) + +#if defined(NEED_sv_2pvbyte) +static char * DPPP_(my_sv_2pvbyte)(pTHX_ SV *sv, STRLEN *lp); +static +#else +extern char * DPPP_(my_sv_2pvbyte)(pTHX_ SV *sv, STRLEN *lp); +#endif + +#ifdef sv_2pvbyte +# undef sv_2pvbyte +#endif +#define sv_2pvbyte(a,b) DPPP_(my_sv_2pvbyte)(aTHX_ a,b) +#define Perl_sv_2pvbyte DPPP_(my_sv_2pvbyte) + +#if defined(NEED_sv_2pvbyte) || defined(NEED_sv_2pvbyte_GLOBAL) + +char * +DPPP_(my_sv_2pvbyte)(pTHX_ SV *sv, STRLEN *lp) +{ + sv_utf8_downgrade(sv,0); + return SvPV(sv,*lp); +} + +#endif + +/* Hint: sv_2pvbyte + * Use the SvPVbyte() macro instead of sv_2pvbyte(). + */ + +#undef SvPVbyte + +#define SvPVbyte(sv, lp) \ + ((SvFLAGS(sv) & (SVf_POK|SVf_UTF8)) == (SVf_POK) \ + ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_2pvbyte(sv, &lp)) + +#endif + +#else + +# define SvPVbyte SvPV +# define sv_2pvbyte sv_2pv + +#endif +#ifndef sv_2pvbyte_nolen +# define sv_2pvbyte_nolen(sv) sv_2pv_nolen(sv) +#endif + +/* Hint: sv_pvn + * Always use the SvPV() macro instead of sv_pvn(). + */ + +/* Hint: sv_pvn_force + * Always use the SvPV_force() macro instead of sv_pvn_force(). + */ + +/* If these are undefined, they're not handled by the core anyway */ +#ifndef SV_IMMEDIATE_UNREF +# define SV_IMMEDIATE_UNREF 0 +#endif + +#ifndef SV_GMAGIC +# define SV_GMAGIC 0 +#endif + +#ifndef SV_COW_DROP_PV +# define SV_COW_DROP_PV 0 +#endif + +#ifndef SV_UTF8_NO_ENCODING +# define SV_UTF8_NO_ENCODING 0 +#endif + +#ifndef SV_NOSTEAL +# define SV_NOSTEAL 0 +#endif + +#ifndef SV_CONST_RETURN +# define SV_CONST_RETURN 0 +#endif + +#ifndef SV_MUTABLE_RETURN +# define SV_MUTABLE_RETURN 0 +#endif + +#ifndef SV_SMAGIC +# define SV_SMAGIC 0 +#endif + +#ifndef SV_HAS_TRAILING_NUL +# define SV_HAS_TRAILING_NUL 0 +#endif + +#ifndef SV_COW_SHARED_HASH_KEYS +# define SV_COW_SHARED_HASH_KEYS 0 +#endif + +#if (PERL_BCDVERSION < 0x5007002) + +#if defined(NEED_sv_2pv_flags) +static char * DPPP_(my_sv_2pv_flags)(pTHX_ SV *sv, STRLEN *lp, I32 flags); +static +#else +extern char * DPPP_(my_sv_2pv_flags)(pTHX_ SV *sv, STRLEN *lp, I32 flags); +#endif + +#ifdef sv_2pv_flags +# undef sv_2pv_flags +#endif +#define sv_2pv_flags(a,b,c) DPPP_(my_sv_2pv_flags)(aTHX_ a,b,c) +#define Perl_sv_2pv_flags DPPP_(my_sv_2pv_flags) + +#if defined(NEED_sv_2pv_flags) || defined(NEED_sv_2pv_flags_GLOBAL) + +char * +DPPP_(my_sv_2pv_flags)(pTHX_ SV *sv, STRLEN *lp, I32 flags) +{ + STRLEN n_a = (STRLEN) flags; + return sv_2pv(sv, lp ? lp : &n_a); +} + +#endif + +#if defined(NEED_sv_pvn_force_flags) +static char * DPPP_(my_sv_pvn_force_flags)(pTHX_ SV *sv, STRLEN *lp, I32 flags); +static +#else +extern char * DPPP_(my_sv_pvn_force_flags)(pTHX_ SV *sv, STRLEN *lp, I32 flags); +#endif + +#ifdef sv_pvn_force_flags +# undef sv_pvn_force_flags +#endif +#define sv_pvn_force_flags(a,b,c) DPPP_(my_sv_pvn_force_flags)(aTHX_ a,b,c) +#define Perl_sv_pvn_force_flags DPPP_(my_sv_pvn_force_flags) + +#if defined(NEED_sv_pvn_force_flags) || defined(NEED_sv_pvn_force_flags_GLOBAL) + +char * +DPPP_(my_sv_pvn_force_flags)(pTHX_ SV *sv, STRLEN *lp, I32 flags) +{ + STRLEN n_a = (STRLEN) flags; + return sv_pvn_force(sv, lp ? lp : &n_a); +} + +#endif + +#endif + +#if (PERL_BCDVERSION < 0x5008008) || ( (PERL_BCDVERSION >= 0x5009000) && (PERL_BCDVERSION < 0x5009003) ) +# define DPPP_SVPV_NOLEN_LP_ARG &PL_na +#else +# define DPPP_SVPV_NOLEN_LP_ARG 0 +#endif +#ifndef SvPV_const +# define SvPV_const(sv, lp) SvPV_flags_const(sv, lp, SV_GMAGIC) +#endif + +#ifndef SvPV_mutable +# define SvPV_mutable(sv, lp) SvPV_flags_mutable(sv, lp, SV_GMAGIC) +#endif +#ifndef SvPV_flags +# define SvPV_flags(sv, lp, flags) \ + ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \ + ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_2pv_flags(sv, &lp, flags)) +#endif +#ifndef SvPV_flags_const +# define SvPV_flags_const(sv, lp, flags) \ + ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \ + ? ((lp = SvCUR(sv)), SvPVX_const(sv)) : \ + (const char*) sv_2pv_flags(sv, &lp, flags|SV_CONST_RETURN)) +#endif +#ifndef SvPV_flags_const_nolen +# define SvPV_flags_const_nolen(sv, flags) \ + ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \ + ? SvPVX_const(sv) : \ + (const char*) sv_2pv_flags(sv, DPPP_SVPV_NOLEN_LP_ARG, flags|SV_CONST_RETURN)) +#endif +#ifndef SvPV_flags_mutable +# define SvPV_flags_mutable(sv, lp, flags) \ + ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \ + ? ((lp = SvCUR(sv)), SvPVX_mutable(sv)) : \ + sv_2pv_flags(sv, &lp, flags|SV_MUTABLE_RETURN)) +#endif +#ifndef SvPV_force +# define SvPV_force(sv, lp) SvPV_force_flags(sv, lp, SV_GMAGIC) +#endif + +#ifndef SvPV_force_nolen +# define SvPV_force_nolen(sv) SvPV_force_flags_nolen(sv, SV_GMAGIC) +#endif + +#ifndef SvPV_force_mutable +# define SvPV_force_mutable(sv, lp) SvPV_force_flags_mutable(sv, lp, SV_GMAGIC) +#endif + +#ifndef SvPV_force_nomg +# define SvPV_force_nomg(sv, lp) SvPV_force_flags(sv, lp, 0) +#endif + +#ifndef SvPV_force_nomg_nolen +# define SvPV_force_nomg_nolen(sv) SvPV_force_flags_nolen(sv, 0) +#endif +#ifndef SvPV_force_flags +# define SvPV_force_flags(sv, lp, flags) \ + ((SvFLAGS(sv) & (SVf_POK|SVf_THINKFIRST)) == SVf_POK \ + ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_pvn_force_flags(sv, &lp, flags)) +#endif +#ifndef SvPV_force_flags_nolen +# define SvPV_force_flags_nolen(sv, flags) \ + ((SvFLAGS(sv) & (SVf_POK|SVf_THINKFIRST)) == SVf_POK \ + ? SvPVX(sv) : sv_pvn_force_flags(sv, DPPP_SVPV_NOLEN_LP_ARG, flags)) +#endif +#ifndef SvPV_force_flags_mutable +# define SvPV_force_flags_mutable(sv, lp, flags) \ + ((SvFLAGS(sv) & (SVf_POK|SVf_THINKFIRST)) == SVf_POK \ + ? ((lp = SvCUR(sv)), SvPVX_mutable(sv)) \ + : sv_pvn_force_flags(sv, &lp, flags|SV_MUTABLE_RETURN)) +#endif +#ifndef SvPV_nolen +# define SvPV_nolen(sv) \ + ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \ + ? SvPVX(sv) : sv_2pv_flags(sv, DPPP_SVPV_NOLEN_LP_ARG, SV_GMAGIC)) +#endif +#ifndef SvPV_nolen_const +# define SvPV_nolen_const(sv) \ + ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \ + ? SvPVX_const(sv) : sv_2pv_flags(sv, DPPP_SVPV_NOLEN_LP_ARG, SV_GMAGIC|SV_CONST_RETURN)) +#endif +#ifndef SvPV_nomg +# define SvPV_nomg(sv, lp) SvPV_flags(sv, lp, 0) +#endif + +#ifndef SvPV_nomg_const +# define SvPV_nomg_const(sv, lp) SvPV_flags_const(sv, lp, 0) +#endif + +#ifndef SvPV_nomg_const_nolen +# define SvPV_nomg_const_nolen(sv) SvPV_flags_const_nolen(sv, 0) +#endif +#ifndef SvPV_renew +# define SvPV_renew(sv,n) STMT_START { SvLEN_set(sv, n); \ + SvPV_set((sv), (char *) saferealloc( \ + (Malloc_t)SvPVX(sv), (MEM_SIZE)((n)))); \ + } STMT_END +#endif +#ifndef SvMAGIC_set +# define SvMAGIC_set(sv, val) \ + STMT_START { assert(SvTYPE(sv) >= SVt_PVMG); \ + (((XPVMG*) SvANY(sv))->xmg_magic = (val)); } STMT_END +#endif + +#if (PERL_BCDVERSION < 0x5009003) +#ifndef SvPVX_const +# define SvPVX_const(sv) ((const char*) (0 + SvPVX(sv))) +#endif + +#ifndef SvPVX_mutable +# define SvPVX_mutable(sv) (0 + SvPVX(sv)) +#endif +#ifndef SvRV_set +# define SvRV_set(sv, val) \ + STMT_START { assert(SvTYPE(sv) >= SVt_RV); \ + (((XRV*) SvANY(sv))->xrv_rv = (val)); } STMT_END +#endif + +#else +#ifndef SvPVX_const +# define SvPVX_const(sv) ((const char*)((sv)->sv_u.svu_pv)) +#endif + +#ifndef SvPVX_mutable +# define SvPVX_mutable(sv) ((sv)->sv_u.svu_pv) +#endif +#ifndef SvRV_set +# define SvRV_set(sv, val) \ + STMT_START { assert(SvTYPE(sv) >= SVt_RV); \ + ((sv)->sv_u.svu_rv = (val)); } STMT_END +#endif + +#endif +#ifndef SvSTASH_set +# define SvSTASH_set(sv, val) \ + STMT_START { assert(SvTYPE(sv) >= SVt_PVMG); \ + (((XPVMG*) SvANY(sv))->xmg_stash = (val)); } STMT_END +#endif + +#if (PERL_BCDVERSION < 0x5004000) +#ifndef SvUV_set +# define SvUV_set(sv, val) \ + STMT_START { assert(SvTYPE(sv) == SVt_IV || SvTYPE(sv) >= SVt_PVIV); \ + (((XPVIV*) SvANY(sv))->xiv_iv = (IV) (val)); } STMT_END +#endif + +#else +#ifndef SvUV_set +# define SvUV_set(sv, val) \ + STMT_START { assert(SvTYPE(sv) == SVt_IV || SvTYPE(sv) >= SVt_PVIV); \ + (((XPVUV*) SvANY(sv))->xuv_uv = (val)); } STMT_END +#endif + +#endif + +#if (PERL_BCDVERSION >= 0x5004000) && !defined(vnewSVpvf) +#if defined(NEED_vnewSVpvf) +static SV * DPPP_(my_vnewSVpvf)(pTHX_ const char *pat, va_list *args); +static +#else +extern SV * DPPP_(my_vnewSVpvf)(pTHX_ const char *pat, va_list *args); +#endif + +#ifdef vnewSVpvf +# undef vnewSVpvf +#endif +#define vnewSVpvf(a,b) DPPP_(my_vnewSVpvf)(aTHX_ a,b) +#define Perl_vnewSVpvf DPPP_(my_vnewSVpvf) + +#if defined(NEED_vnewSVpvf) || defined(NEED_vnewSVpvf_GLOBAL) + +SV * +DPPP_(my_vnewSVpvf)(pTHX_ const char *pat, va_list *args) +{ + register SV *sv = newSV(0); + sv_vsetpvfn(sv, pat, strlen(pat), args, Null(SV**), 0, Null(bool*)); + return sv; +} + +#endif +#endif + +#if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_vcatpvf) +# define sv_vcatpvf(sv, pat, args) sv_vcatpvfn(sv, pat, strlen(pat), args, Null(SV**), 0, Null(bool*)) +#endif + +#if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_vsetpvf) +# define sv_vsetpvf(sv, pat, args) sv_vsetpvfn(sv, pat, strlen(pat), args, Null(SV**), 0, Null(bool*)) +#endif + +#if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_catpvf_mg) +#if defined(NEED_sv_catpvf_mg) +static void DPPP_(my_sv_catpvf_mg)(pTHX_ SV *sv, const char *pat, ...); +static +#else +extern void DPPP_(my_sv_catpvf_mg)(pTHX_ SV *sv, const char *pat, ...); +#endif + +#define Perl_sv_catpvf_mg DPPP_(my_sv_catpvf_mg) + +#if defined(NEED_sv_catpvf_mg) || defined(NEED_sv_catpvf_mg_GLOBAL) + +void +DPPP_(my_sv_catpvf_mg)(pTHX_ SV *sv, const char *pat, ...) +{ + va_list args; + va_start(args, pat); + sv_vcatpvfn(sv, pat, strlen(pat), &args, Null(SV**), 0, Null(bool*)); + SvSETMAGIC(sv); + va_end(args); +} + +#endif +#endif + +#ifdef PERL_IMPLICIT_CONTEXT +#if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_catpvf_mg_nocontext) +#if defined(NEED_sv_catpvf_mg_nocontext) +static void DPPP_(my_sv_catpvf_mg_nocontext)(SV *sv, const char *pat, ...); +static +#else +extern void DPPP_(my_sv_catpvf_mg_nocontext)(SV *sv, const char *pat, ...); +#endif + +#define sv_catpvf_mg_nocontext DPPP_(my_sv_catpvf_mg_nocontext) +#define Perl_sv_catpvf_mg_nocontext DPPP_(my_sv_catpvf_mg_nocontext) + +#if defined(NEED_sv_catpvf_mg_nocontext) || defined(NEED_sv_catpvf_mg_nocontext_GLOBAL) + +void +DPPP_(my_sv_catpvf_mg_nocontext)(SV *sv, const char *pat, ...) +{ + dTHX; + va_list args; + va_start(args, pat); + sv_vcatpvfn(sv, pat, strlen(pat), &args, Null(SV**), 0, Null(bool*)); + SvSETMAGIC(sv); + va_end(args); +} + +#endif +#endif +#endif + +/* sv_catpvf_mg depends on sv_catpvf_mg_nocontext */ +#ifndef sv_catpvf_mg +# ifdef PERL_IMPLICIT_CONTEXT +# define sv_catpvf_mg Perl_sv_catpvf_mg_nocontext +# else +# define sv_catpvf_mg Perl_sv_catpvf_mg +# endif +#endif + +#if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_vcatpvf_mg) +# define sv_vcatpvf_mg(sv, pat, args) \ + STMT_START { \ + sv_vcatpvfn(sv, pat, strlen(pat), args, Null(SV**), 0, Null(bool*)); \ + SvSETMAGIC(sv); \ + } STMT_END +#endif + +#if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_setpvf_mg) +#if defined(NEED_sv_setpvf_mg) +static void DPPP_(my_sv_setpvf_mg)(pTHX_ SV *sv, const char *pat, ...); +static +#else +extern void DPPP_(my_sv_setpvf_mg)(pTHX_ SV *sv, const char *pat, ...); +#endif + +#define Perl_sv_setpvf_mg DPPP_(my_sv_setpvf_mg) + +#if defined(NEED_sv_setpvf_mg) || defined(NEED_sv_setpvf_mg_GLOBAL) + +void +DPPP_(my_sv_setpvf_mg)(pTHX_ SV *sv, const char *pat, ...) +{ + va_list args; + va_start(args, pat); + sv_vsetpvfn(sv, pat, strlen(pat), &args, Null(SV**), 0, Null(bool*)); + SvSETMAGIC(sv); + va_end(args); +} + +#endif +#endif + +#ifdef PERL_IMPLICIT_CONTEXT +#if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_setpvf_mg_nocontext) +#if defined(NEED_sv_setpvf_mg_nocontext) +static void DPPP_(my_sv_setpvf_mg_nocontext)(SV *sv, const char *pat, ...); +static +#else +extern void DPPP_(my_sv_setpvf_mg_nocontext)(SV *sv, const char *pat, ...); +#endif + +#define sv_setpvf_mg_nocontext DPPP_(my_sv_setpvf_mg_nocontext) +#define Perl_sv_setpvf_mg_nocontext DPPP_(my_sv_setpvf_mg_nocontext) + +#if defined(NEED_sv_setpvf_mg_nocontext) || defined(NEED_sv_setpvf_mg_nocontext_GLOBAL) + +void +DPPP_(my_sv_setpvf_mg_nocontext)(SV *sv, const char *pat, ...) +{ + dTHX; + va_list args; + va_start(args, pat); + sv_vsetpvfn(sv, pat, strlen(pat), &args, Null(SV**), 0, Null(bool*)); + SvSETMAGIC(sv); + va_end(args); +} + +#endif +#endif +#endif + +/* sv_setpvf_mg depends on sv_setpvf_mg_nocontext */ +#ifndef sv_setpvf_mg +# ifdef PERL_IMPLICIT_CONTEXT +# define sv_setpvf_mg Perl_sv_setpvf_mg_nocontext +# else +# define sv_setpvf_mg Perl_sv_setpvf_mg +# endif +#endif + +#if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_vsetpvf_mg) +# define sv_vsetpvf_mg(sv, pat, args) \ + STMT_START { \ + sv_vsetpvfn(sv, pat, strlen(pat), args, Null(SV**), 0, Null(bool*)); \ + SvSETMAGIC(sv); \ + } STMT_END +#endif + +#ifndef newSVpvn_share + +#if defined(NEED_newSVpvn_share) +static SV * DPPP_(my_newSVpvn_share)(pTHX_ const char *src, I32 len, U32 hash); +static +#else +extern SV * DPPP_(my_newSVpvn_share)(pTHX_ const char *src, I32 len, U32 hash); +#endif + +#ifdef newSVpvn_share +# undef newSVpvn_share +#endif +#define newSVpvn_share(a,b,c) DPPP_(my_newSVpvn_share)(aTHX_ a,b,c) +#define Perl_newSVpvn_share DPPP_(my_newSVpvn_share) + +#if defined(NEED_newSVpvn_share) || defined(NEED_newSVpvn_share_GLOBAL) + +SV * +DPPP_(my_newSVpvn_share)(pTHX_ const char *src, I32 len, U32 hash) +{ + SV *sv; + if (len < 0) + len = -len; + if (!hash) + PERL_HASH(hash, (char*) src, len); + sv = newSVpvn((char *) src, len); + sv_upgrade(sv, SVt_PVIV); + SvIVX(sv) = hash; + SvREADONLY_on(sv); + SvPOK_on(sv); + return sv; +} + +#endif + +#endif +#ifndef SvSHARED_HASH +# define SvSHARED_HASH(sv) (0 + SvUVX(sv)) +#endif +#ifndef HvNAME_get +# define HvNAME_get(hv) HvNAME(hv) +#endif +#ifndef HvNAMELEN_get +# define HvNAMELEN_get(hv) (HvNAME_get(hv) ? (I32)strlen(HvNAME_get(hv)) : 0) +#endif +#ifndef GvSVn +# define GvSVn(gv) GvSV(gv) +#endif + +#ifndef isGV_with_GP +# define isGV_with_GP(gv) isGV(gv) +#endif +#ifndef WARN_ALL +# define WARN_ALL 0 +#endif + +#ifndef WARN_CLOSURE +# define WARN_CLOSURE 1 +#endif + +#ifndef WARN_DEPRECATED +# define WARN_DEPRECATED 2 +#endif + +#ifndef WARN_EXITING +# define WARN_EXITING 3 +#endif + +#ifndef WARN_GLOB +# define WARN_GLOB 4 +#endif + +#ifndef WARN_IO +# define WARN_IO 5 +#endif + +#ifndef WARN_CLOSED +# define WARN_CLOSED 6 +#endif + +#ifndef WARN_EXEC +# define WARN_EXEC 7 +#endif + +#ifndef WARN_LAYER +# define WARN_LAYER 8 +#endif + +#ifndef WARN_NEWLINE +# define WARN_NEWLINE 9 +#endif + +#ifndef WARN_PIPE +# define WARN_PIPE 10 +#endif + +#ifndef WARN_UNOPENED +# define WARN_UNOPENED 11 +#endif + +#ifndef WARN_MISC +# define WARN_MISC 12 +#endif + +#ifndef WARN_NUMERIC +# define WARN_NUMERIC 13 +#endif + +#ifndef WARN_ONCE +# define WARN_ONCE 14 +#endif + +#ifndef WARN_OVERFLOW +# define WARN_OVERFLOW 15 +#endif + +#ifndef WARN_PACK +# define WARN_PACK 16 +#endif + +#ifndef WARN_PORTABLE +# define WARN_PORTABLE 17 +#endif + +#ifndef WARN_RECURSION +# define WARN_RECURSION 18 +#endif + +#ifndef WARN_REDEFINE +# define WARN_REDEFINE 19 +#endif + +#ifndef WARN_REGEXP +# define WARN_REGEXP 20 +#endif + +#ifndef WARN_SEVERE +# define WARN_SEVERE 21 +#endif + +#ifndef WARN_DEBUGGING +# define WARN_DEBUGGING 22 +#endif + +#ifndef WARN_INPLACE +# define WARN_INPLACE 23 +#endif + +#ifndef WARN_INTERNAL +# define WARN_INTERNAL 24 +#endif + +#ifndef WARN_MALLOC +# define WARN_MALLOC 25 +#endif + +#ifndef WARN_SIGNAL +# define WARN_SIGNAL 26 +#endif + +#ifndef WARN_SUBSTR +# define WARN_SUBSTR 27 +#endif + +#ifndef WARN_SYNTAX +# define WARN_SYNTAX 28 +#endif + +#ifndef WARN_AMBIGUOUS +# define WARN_AMBIGUOUS 29 +#endif + +#ifndef WARN_BAREWORD +# define WARN_BAREWORD 30 +#endif + +#ifndef WARN_DIGIT +# define WARN_DIGIT 31 +#endif + +#ifndef WARN_PARENTHESIS +# define WARN_PARENTHESIS 32 +#endif + +#ifndef WARN_PRECEDENCE +# define WARN_PRECEDENCE 33 +#endif + +#ifndef WARN_PRINTF +# define WARN_PRINTF 34 +#endif + +#ifndef WARN_PROTOTYPE +# define WARN_PROTOTYPE 35 +#endif + +#ifndef WARN_QW +# define WARN_QW 36 +#endif + +#ifndef WARN_RESERVED +# define WARN_RESERVED 37 +#endif + +#ifndef WARN_SEMICOLON +# define WARN_SEMICOLON 38 +#endif + +#ifndef WARN_TAINT +# define WARN_TAINT 39 +#endif + +#ifndef WARN_THREADS +# define WARN_THREADS 40 +#endif + +#ifndef WARN_UNINITIALIZED +# define WARN_UNINITIALIZED 41 +#endif + +#ifndef WARN_UNPACK +# define WARN_UNPACK 42 +#endif + +#ifndef WARN_UNTIE +# define WARN_UNTIE 43 +#endif + +#ifndef WARN_UTF8 +# define WARN_UTF8 44 +#endif + +#ifndef WARN_VOID +# define WARN_VOID 45 +#endif + +#ifndef WARN_ASSERTIONS +# define WARN_ASSERTIONS 46 +#endif +#ifndef packWARN +# define packWARN(a) (a) +#endif + +#ifndef ckWARN +# ifdef G_WARN_ON +# define ckWARN(a) (PL_dowarn & G_WARN_ON) +# else +# define ckWARN(a) PL_dowarn +# endif +#endif + +#if (PERL_BCDVERSION >= 0x5004000) && !defined(warner) +#if defined(NEED_warner) +static void DPPP_(my_warner)(U32 err, const char *pat, ...); +static +#else +extern void DPPP_(my_warner)(U32 err, const char *pat, ...); +#endif + +#define Perl_warner DPPP_(my_warner) + +#if defined(NEED_warner) || defined(NEED_warner_GLOBAL) + +void +DPPP_(my_warner)(U32 err, const char *pat, ...) +{ + SV *sv; + va_list args; + + PERL_UNUSED_ARG(err); + + va_start(args, pat); + sv = vnewSVpvf(pat, &args); + va_end(args); + sv_2mortal(sv); + warn("%s", SvPV_nolen(sv)); +} + +#define warner Perl_warner + +#define Perl_warner_nocontext Perl_warner + +#endif +#endif + +/* concatenating with "" ensures that only literal strings are accepted as argument + * note that STR_WITH_LEN() can't be used as argument to macros or functions that + * under some configurations might be macros + */ +#ifndef STR_WITH_LEN +# define STR_WITH_LEN(s) (s ""), (sizeof(s)-1) +#endif +#ifndef newSVpvs +# define newSVpvs(str) newSVpvn(str "", sizeof(str) - 1) +#endif + +#ifndef newSVpvs_flags +# define newSVpvs_flags(str, flags) newSVpvn_flags(str "", sizeof(str) - 1, flags) +#endif + +#ifndef sv_catpvs +# define sv_catpvs(sv, str) sv_catpvn(sv, str "", sizeof(str) - 1) +#endif + +#ifndef sv_setpvs +# define sv_setpvs(sv, str) sv_setpvn(sv, str "", sizeof(str) - 1) +#endif + +#ifndef hv_fetchs +# define hv_fetchs(hv, key, lval) hv_fetch(hv, key "", sizeof(key) - 1, lval) +#endif + +#ifndef hv_stores +# define hv_stores(hv, key, val) hv_store(hv, key "", sizeof(key) - 1, val, 0) +#endif +#ifndef gv_fetchpvn_flags +# define gv_fetchpvn_flags(name, len, flags, svt) gv_fetchpv(name, flags, svt) +#endif + +#ifndef gv_fetchpvs +# define gv_fetchpvs(name, flags, svt) gv_fetchpvn_flags(name "", sizeof(name) - 1, flags, svt) +#endif + +#ifndef gv_stashpvs +# define gv_stashpvs(name, flags) gv_stashpvn(name "", sizeof(name) - 1, flags) +#endif +#ifndef SvGETMAGIC +# define SvGETMAGIC(x) STMT_START { if (SvGMAGICAL(x)) mg_get(x); } STMT_END +#endif +#ifndef PERL_MAGIC_sv +# define PERL_MAGIC_sv '\0' +#endif + +#ifndef PERL_MAGIC_overload +# define PERL_MAGIC_overload 'A' +#endif + +#ifndef PERL_MAGIC_overload_elem +# define PERL_MAGIC_overload_elem 'a' +#endif + +#ifndef PERL_MAGIC_overload_table +# define PERL_MAGIC_overload_table 'c' +#endif + +#ifndef PERL_MAGIC_bm +# define PERL_MAGIC_bm 'B' +#endif + +#ifndef PERL_MAGIC_regdata +# define PERL_MAGIC_regdata 'D' +#endif + +#ifndef PERL_MAGIC_regdatum +# define PERL_MAGIC_regdatum 'd' +#endif + +#ifndef PERL_MAGIC_env +# define PERL_MAGIC_env 'E' +#endif + +#ifndef PERL_MAGIC_envelem +# define PERL_MAGIC_envelem 'e' +#endif + +#ifndef PERL_MAGIC_fm +# define PERL_MAGIC_fm 'f' +#endif + +#ifndef PERL_MAGIC_regex_global +# define PERL_MAGIC_regex_global 'g' +#endif + +#ifndef PERL_MAGIC_isa +# define PERL_MAGIC_isa 'I' +#endif + +#ifndef PERL_MAGIC_isaelem +# define PERL_MAGIC_isaelem 'i' +#endif + +#ifndef PERL_MAGIC_nkeys +# define PERL_MAGIC_nkeys 'k' +#endif + +#ifndef PERL_MAGIC_dbfile +# define PERL_MAGIC_dbfile 'L' +#endif + +#ifndef PERL_MAGIC_dbline +# define PERL_MAGIC_dbline 'l' +#endif + +#ifndef PERL_MAGIC_mutex +# define PERL_MAGIC_mutex 'm' +#endif + +#ifndef PERL_MAGIC_shared +# define PERL_MAGIC_shared 'N' +#endif + +#ifndef PERL_MAGIC_shared_scalar +# define PERL_MAGIC_shared_scalar 'n' +#endif + +#ifndef PERL_MAGIC_collxfrm +# define PERL_MAGIC_collxfrm 'o' +#endif + +#ifndef PERL_MAGIC_tied +# define PERL_MAGIC_tied 'P' +#endif + +#ifndef PERL_MAGIC_tiedelem +# define PERL_MAGIC_tiedelem 'p' +#endif + +#ifndef PERL_MAGIC_tiedscalar +# define PERL_MAGIC_tiedscalar 'q' +#endif + +#ifndef PERL_MAGIC_qr +# define PERL_MAGIC_qr 'r' +#endif + +#ifndef PERL_MAGIC_sig +# define PERL_MAGIC_sig 'S' +#endif + +#ifndef PERL_MAGIC_sigelem +# define PERL_MAGIC_sigelem 's' +#endif + +#ifndef PERL_MAGIC_taint +# define PERL_MAGIC_taint 't' +#endif + +#ifndef PERL_MAGIC_uvar +# define PERL_MAGIC_uvar 'U' +#endif + +#ifndef PERL_MAGIC_uvar_elem +# define PERL_MAGIC_uvar_elem 'u' +#endif + +#ifndef PERL_MAGIC_vstring +# define PERL_MAGIC_vstring 'V' +#endif + +#ifndef PERL_MAGIC_vec +# define PERL_MAGIC_vec 'v' +#endif + +#ifndef PERL_MAGIC_utf8 +# define PERL_MAGIC_utf8 'w' +#endif + +#ifndef PERL_MAGIC_substr +# define PERL_MAGIC_substr 'x' +#endif + +#ifndef PERL_MAGIC_defelem +# define PERL_MAGIC_defelem 'y' +#endif + +#ifndef PERL_MAGIC_glob +# define PERL_MAGIC_glob '*' +#endif + +#ifndef PERL_MAGIC_arylen +# define PERL_MAGIC_arylen '#' +#endif + +#ifndef PERL_MAGIC_pos +# define PERL_MAGIC_pos '.' +#endif + +#ifndef PERL_MAGIC_backref +# define PERL_MAGIC_backref '<' +#endif + +#ifndef PERL_MAGIC_ext +# define PERL_MAGIC_ext '~' +#endif + +/* That's the best we can do... */ +#ifndef sv_catpvn_nomg +# define sv_catpvn_nomg sv_catpvn +#endif + +#ifndef sv_catsv_nomg +# define sv_catsv_nomg sv_catsv +#endif + +#ifndef sv_setsv_nomg +# define sv_setsv_nomg sv_setsv +#endif + +#ifndef sv_pvn_nomg +# define sv_pvn_nomg sv_pvn +#endif + +#ifndef SvIV_nomg +# define SvIV_nomg SvIV +#endif + +#ifndef SvUV_nomg +# define SvUV_nomg SvUV +#endif + +#ifndef sv_catpv_mg +# define sv_catpv_mg(sv, ptr) \ + STMT_START { \ + SV *TeMpSv = sv; \ + sv_catpv(TeMpSv,ptr); \ + SvSETMAGIC(TeMpSv); \ + } STMT_END +#endif + +#ifndef sv_catpvn_mg +# define sv_catpvn_mg(sv, ptr, len) \ + STMT_START { \ + SV *TeMpSv = sv; \ + sv_catpvn(TeMpSv,ptr,len); \ + SvSETMAGIC(TeMpSv); \ + } STMT_END +#endif + +#ifndef sv_catsv_mg +# define sv_catsv_mg(dsv, ssv) \ + STMT_START { \ + SV *TeMpSv = dsv; \ + sv_catsv(TeMpSv,ssv); \ + SvSETMAGIC(TeMpSv); \ + } STMT_END +#endif + +#ifndef sv_setiv_mg +# define sv_setiv_mg(sv, i) \ + STMT_START { \ + SV *TeMpSv = sv; \ + sv_setiv(TeMpSv,i); \ + SvSETMAGIC(TeMpSv); \ + } STMT_END +#endif + +#ifndef sv_setnv_mg +# define sv_setnv_mg(sv, num) \ + STMT_START { \ + SV *TeMpSv = sv; \ + sv_setnv(TeMpSv,num); \ + SvSETMAGIC(TeMpSv); \ + } STMT_END +#endif + +#ifndef sv_setpv_mg +# define sv_setpv_mg(sv, ptr) \ + STMT_START { \ + SV *TeMpSv = sv; \ + sv_setpv(TeMpSv,ptr); \ + SvSETMAGIC(TeMpSv); \ + } STMT_END +#endif + +#ifndef sv_setpvn_mg +# define sv_setpvn_mg(sv, ptr, len) \ + STMT_START { \ + SV *TeMpSv = sv; \ + sv_setpvn(TeMpSv,ptr,len); \ + SvSETMAGIC(TeMpSv); \ + } STMT_END +#endif + +#ifndef sv_setsv_mg +# define sv_setsv_mg(dsv, ssv) \ + STMT_START { \ + SV *TeMpSv = dsv; \ + sv_setsv(TeMpSv,ssv); \ + SvSETMAGIC(TeMpSv); \ + } STMT_END +#endif + +#ifndef sv_setuv_mg +# define sv_setuv_mg(sv, i) \ + STMT_START { \ + SV *TeMpSv = sv; \ + sv_setuv(TeMpSv,i); \ + SvSETMAGIC(TeMpSv); \ + } STMT_END +#endif + +#ifndef sv_usepvn_mg +# define sv_usepvn_mg(sv, ptr, len) \ + STMT_START { \ + SV *TeMpSv = sv; \ + sv_usepvn(TeMpSv,ptr,len); \ + SvSETMAGIC(TeMpSv); \ + } STMT_END +#endif +#ifndef SvVSTRING_mg +# define SvVSTRING_mg(sv) (SvMAGICAL(sv) ? mg_find(sv, PERL_MAGIC_vstring) : NULL) +#endif + +/* Hint: sv_magic_portable + * This is a compatibility function that is only available with + * Devel::PPPort. It is NOT in the perl core. + * Its purpose is to mimic the 5.8.0 behaviour of sv_magic() when + * it is being passed a name pointer with namlen == 0. In that + * case, perl 5.8.0 and later store the pointer, not a copy of it. + * The compatibility can be provided back to perl 5.004. With + * earlier versions, the code will not compile. + */ + +#if (PERL_BCDVERSION < 0x5004000) + + /* code that uses sv_magic_portable will not compile */ + +#elif (PERL_BCDVERSION < 0x5008000) + +# define sv_magic_portable(sv, obj, how, name, namlen) \ + STMT_START { \ + SV *SvMp_sv = (sv); \ + char *SvMp_name = (char *) (name); \ + I32 SvMp_namlen = (namlen); \ + if (SvMp_name && SvMp_namlen == 0) \ + { \ + MAGIC *mg; \ + sv_magic(SvMp_sv, obj, how, 0, 0); \ + mg = SvMAGIC(SvMp_sv); \ + mg->mg_len = -42; /* XXX: this is the tricky part */ \ + mg->mg_ptr = SvMp_name; \ + } \ + else \ + { \ + sv_magic(SvMp_sv, obj, how, SvMp_name, SvMp_namlen); \ + } \ + } STMT_END + +#else + +# define sv_magic_portable(a, b, c, d, e) sv_magic(a, b, c, d, e) + +#endif + +#ifdef USE_ITHREADS +#ifndef CopFILE +# define CopFILE(c) ((c)->cop_file) +#endif + +#ifndef CopFILEGV +# define CopFILEGV(c) (CopFILE(c) ? gv_fetchfile(CopFILE(c)) : Nullgv) +#endif + +#ifndef CopFILE_set +# define CopFILE_set(c,pv) ((c)->cop_file = savepv(pv)) +#endif + +#ifndef CopFILESV +# define CopFILESV(c) (CopFILE(c) ? GvSV(gv_fetchfile(CopFILE(c))) : Nullsv) +#endif + +#ifndef CopFILEAV +# define CopFILEAV(c) (CopFILE(c) ? GvAV(gv_fetchfile(CopFILE(c))) : Nullav) +#endif + +#ifndef CopSTASHPV +# define CopSTASHPV(c) ((c)->cop_stashpv) +#endif + +#ifndef CopSTASHPV_set +# define CopSTASHPV_set(c,pv) ((c)->cop_stashpv = ((pv) ? savepv(pv) : Nullch)) +#endif + +#ifndef CopSTASH +# define CopSTASH(c) (CopSTASHPV(c) ? gv_stashpv(CopSTASHPV(c),GV_ADD) : Nullhv) +#endif + +#ifndef CopSTASH_set +# define CopSTASH_set(c,hv) CopSTASHPV_set(c, (hv) ? HvNAME(hv) : Nullch) +#endif + +#ifndef CopSTASH_eq +# define CopSTASH_eq(c,hv) ((hv) && (CopSTASHPV(c) == HvNAME(hv) \ + || (CopSTASHPV(c) && HvNAME(hv) \ + && strEQ(CopSTASHPV(c), HvNAME(hv))))) +#endif + +#else +#ifndef CopFILEGV +# define CopFILEGV(c) ((c)->cop_filegv) +#endif + +#ifndef CopFILEGV_set +# define CopFILEGV_set(c,gv) ((c)->cop_filegv = (GV*)SvREFCNT_inc(gv)) +#endif + +#ifndef CopFILE_set +# define CopFILE_set(c,pv) CopFILEGV_set((c), gv_fetchfile(pv)) +#endif + +#ifndef CopFILESV +# define CopFILESV(c) (CopFILEGV(c) ? GvSV(CopFILEGV(c)) : Nullsv) +#endif + +#ifndef CopFILEAV +# define CopFILEAV(c) (CopFILEGV(c) ? GvAV(CopFILEGV(c)) : Nullav) +#endif + +#ifndef CopFILE +# define CopFILE(c) (CopFILESV(c) ? SvPVX(CopFILESV(c)) : Nullch) +#endif + +#ifndef CopSTASH +# define CopSTASH(c) ((c)->cop_stash) +#endif + +#ifndef CopSTASH_set +# define CopSTASH_set(c,hv) ((c)->cop_stash = (hv)) +#endif + +#ifndef CopSTASHPV +# define CopSTASHPV(c) (CopSTASH(c) ? HvNAME(CopSTASH(c)) : Nullch) +#endif + +#ifndef CopSTASHPV_set +# define CopSTASHPV_set(c,pv) CopSTASH_set((c), gv_stashpv(pv,GV_ADD)) +#endif + +#ifndef CopSTASH_eq +# define CopSTASH_eq(c,hv) (CopSTASH(c) == (hv)) +#endif + +#endif /* USE_ITHREADS */ +#ifndef IN_PERL_COMPILETIME +# define IN_PERL_COMPILETIME (PL_curcop == &PL_compiling) +#endif + +#ifndef IN_LOCALE_RUNTIME +# define IN_LOCALE_RUNTIME (PL_curcop->op_private & HINT_LOCALE) +#endif + +#ifndef IN_LOCALE_COMPILETIME +# define IN_LOCALE_COMPILETIME (PL_hints & HINT_LOCALE) +#endif + +#ifndef IN_LOCALE +# define IN_LOCALE (IN_PERL_COMPILETIME ? IN_LOCALE_COMPILETIME : IN_LOCALE_RUNTIME) +#endif +#ifndef IS_NUMBER_IN_UV +# define IS_NUMBER_IN_UV 0x01 +#endif + +#ifndef IS_NUMBER_GREATER_THAN_UV_MAX +# define IS_NUMBER_GREATER_THAN_UV_MAX 0x02 +#endif + +#ifndef IS_NUMBER_NOT_INT +# define IS_NUMBER_NOT_INT 0x04 +#endif + +#ifndef IS_NUMBER_NEG +# define IS_NUMBER_NEG 0x08 +#endif + +#ifndef IS_NUMBER_INFINITY +# define IS_NUMBER_INFINITY 0x10 +#endif + +#ifndef IS_NUMBER_NAN +# define IS_NUMBER_NAN 0x20 +#endif +#ifndef GROK_NUMERIC_RADIX +# define GROK_NUMERIC_RADIX(sp, send) grok_numeric_radix(sp, send) +#endif +#ifndef PERL_SCAN_GREATER_THAN_UV_MAX +# define PERL_SCAN_GREATER_THAN_UV_MAX 0x02 +#endif + +#ifndef PERL_SCAN_SILENT_ILLDIGIT +# define PERL_SCAN_SILENT_ILLDIGIT 0x04 +#endif + +#ifndef PERL_SCAN_ALLOW_UNDERSCORES +# define PERL_SCAN_ALLOW_UNDERSCORES 0x01 +#endif + +#ifndef PERL_SCAN_DISALLOW_PREFIX +# define PERL_SCAN_DISALLOW_PREFIX 0x02 +#endif + +#ifndef grok_numeric_radix +#if defined(NEED_grok_numeric_radix) +static bool DPPP_(my_grok_numeric_radix)(pTHX_ const char ** sp, const char * send); +static +#else +extern bool DPPP_(my_grok_numeric_radix)(pTHX_ const char ** sp, const char * send); +#endif + +#ifdef grok_numeric_radix +# undef grok_numeric_radix +#endif +#define grok_numeric_radix(a,b) DPPP_(my_grok_numeric_radix)(aTHX_ a,b) +#define Perl_grok_numeric_radix DPPP_(my_grok_numeric_radix) + +#if defined(NEED_grok_numeric_radix) || defined(NEED_grok_numeric_radix_GLOBAL) +bool +DPPP_(my_grok_numeric_radix)(pTHX_ const char **sp, const char *send) +{ +#ifdef USE_LOCALE_NUMERIC +#ifdef PL_numeric_radix_sv + if (PL_numeric_radix_sv && IN_LOCALE) { + STRLEN len; + char* radix = SvPV(PL_numeric_radix_sv, len); + if (*sp + len <= send && memEQ(*sp, radix, len)) { + *sp += len; + return TRUE; + } + } +#else + /* older perls don't have PL_numeric_radix_sv so the radix + * must manually be requested from locale.h + */ +#include <locale.h> + dTHR; /* needed for older threaded perls */ + struct lconv *lc = localeconv(); + char *radix = lc->decimal_point; + if (radix && IN_LOCALE) { + STRLEN len = strlen(radix); + if (*sp + len <= send && memEQ(*sp, radix, len)) { + *sp += len; + return TRUE; + } + } +#endif +#endif /* USE_LOCALE_NUMERIC */ + /* always try "." if numeric radix didn't match because + * we may have data from different locales mixed */ + if (*sp < send && **sp == '.') { + ++*sp; + return TRUE; + } + return FALSE; +} +#endif +#endif + +#ifndef grok_number +#if defined(NEED_grok_number) +static int DPPP_(my_grok_number)(pTHX_ const char * pv, STRLEN len, UV * valuep); +static +#else +extern int DPPP_(my_grok_number)(pTHX_ const char * pv, STRLEN len, UV * valuep); +#endif + +#ifdef grok_number +# undef grok_number +#endif +#define grok_number(a,b,c) DPPP_(my_grok_number)(aTHX_ a,b,c) +#define Perl_grok_number DPPP_(my_grok_number) + +#if defined(NEED_grok_number) || defined(NEED_grok_number_GLOBAL) +int +DPPP_(my_grok_number)(pTHX_ const char *pv, STRLEN len, UV *valuep) +{ + const char *s = pv; + const char *send = pv + len; + const UV max_div_10 = UV_MAX / 10; + const char max_mod_10 = UV_MAX % 10; + int numtype = 0; + int sawinf = 0; + int sawnan = 0; + + while (s < send && isSPACE(*s)) + s++; + if (s == send) { + return 0; + } else if (*s == '-') { + s++; + numtype = IS_NUMBER_NEG; + } + else if (*s == '+') + s++; + + if (s == send) + return 0; + + /* next must be digit or the radix separator or beginning of infinity */ + if (isDIGIT(*s)) { + /* UVs are at least 32 bits, so the first 9 decimal digits cannot + overflow. */ + UV value = *s - '0'; + /* This construction seems to be more optimiser friendly. + (without it gcc does the isDIGIT test and the *s - '0' separately) + With it gcc on arm is managing 6 instructions (6 cycles) per digit. + In theory the optimiser could deduce how far to unroll the loop + before checking for overflow. */ + if (++s < send) { + int digit = *s - '0'; + if (digit >= 0 && digit <= 9) { + value = value * 10 + digit; + if (++s < send) { + digit = *s - '0'; + if (digit >= 0 && digit <= 9) { + value = value * 10 + digit; + if (++s < send) { + digit = *s - '0'; + if (digit >= 0 && digit <= 9) { + value = value * 10 + digit; + if (++s < send) { + digit = *s - '0'; + if (digit >= 0 && digit <= 9) { + value = value * 10 + digit; + if (++s < send) { + digit = *s - '0'; + if (digit >= 0 && digit <= 9) { + value = value * 10 + digit; + if (++s < send) { + digit = *s - '0'; + if (digit >= 0 && digit <= 9) { + value = value * 10 + digit; + if (++s < send) { + digit = *s - '0'; + if (digit >= 0 && digit <= 9) { + value = value * 10 + digit; + if (++s < send) { + digit = *s - '0'; + if (digit >= 0 && digit <= 9) { + value = value * 10 + digit; + if (++s < send) { + /* Now got 9 digits, so need to check + each time for overflow. */ + digit = *s - '0'; + while (digit >= 0 && digit <= 9 + && (value < max_div_10 + || (value == max_div_10 + && digit <= max_mod_10))) { + value = value * 10 + digit; + if (++s < send) + digit = *s - '0'; + else + break; + } + if (digit >= 0 && digit <= 9 + && (s < send)) { + /* value overflowed. + skip the remaining digits, don't + worry about setting *valuep. */ + do { + s++; + } while (s < send && isDIGIT(*s)); + numtype |= + IS_NUMBER_GREATER_THAN_UV_MAX; + goto skip_value; + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + numtype |= IS_NUMBER_IN_UV; + if (valuep) + *valuep = value; + + skip_value: + if (GROK_NUMERIC_RADIX(&s, send)) { + numtype |= IS_NUMBER_NOT_INT; + while (s < send && isDIGIT(*s)) /* optional digits after the radix */ + s++; + } + } + else if (GROK_NUMERIC_RADIX(&s, send)) { + numtype |= IS_NUMBER_NOT_INT | IS_NUMBER_IN_UV; /* valuep assigned below */ + /* no digits before the radix means we need digits after it */ + if (s < send && isDIGIT(*s)) { + do { + s++; + } while (s < send && isDIGIT(*s)); + if (valuep) { + /* integer approximation is valid - it's 0. */ + *valuep = 0; + } + } + else + return 0; + } else if (*s == 'I' || *s == 'i') { + s++; if (s == send || (*s != 'N' && *s != 'n')) return 0; + s++; if (s == send || (*s != 'F' && *s != 'f')) return 0; + s++; if (s < send && (*s == 'I' || *s == 'i')) { + s++; if (s == send || (*s != 'N' && *s != 'n')) return 0; + s++; if (s == send || (*s != 'I' && *s != 'i')) return 0; + s++; if (s == send || (*s != 'T' && *s != 't')) return 0; + s++; if (s == send || (*s != 'Y' && *s != 'y')) return 0; + s++; + } + sawinf = 1; + } else if (*s == 'N' || *s == 'n') { + /* XXX TODO: There are signaling NaNs and quiet NaNs. */ + s++; if (s == send || (*s != 'A' && *s != 'a')) return 0; + s++; if (s == send || (*s != 'N' && *s != 'n')) return 0; + s++; + sawnan = 1; + } else + return 0; + + if (sawinf) { + numtype &= IS_NUMBER_NEG; /* Keep track of sign */ + numtype |= IS_NUMBER_INFINITY | IS_NUMBER_NOT_INT; + } else if (sawnan) { + numtype &= IS_NUMBER_NEG; /* Keep track of sign */ + numtype |= IS_NUMBER_NAN | IS_NUMBER_NOT_INT; + } else if (s < send) { + /* we can have an optional exponent part */ + if (*s == 'e' || *s == 'E') { + /* The only flag we keep is sign. Blow away any "it's UV" */ + numtype &= IS_NUMBER_NEG; + numtype |= IS_NUMBER_NOT_INT; + s++; + if (s < send && (*s == '-' || *s == '+')) + s++; + if (s < send && isDIGIT(*s)) { + do { + s++; + } while (s < send && isDIGIT(*s)); + } + else + return 0; + } + } + while (s < send && isSPACE(*s)) + s++; + if (s >= send) + return numtype; + if (len == 10 && memEQ(pv, "0 but true", 10)) { + if (valuep) + *valuep = 0; + return IS_NUMBER_IN_UV; + } + return 0; +} +#endif +#endif + +/* + * The grok_* routines have been modified to use warn() instead of + * Perl_warner(). Also, 'hexdigit' was the former name of PL_hexdigit, + * which is why the stack variable has been renamed to 'xdigit'. + */ + +#ifndef grok_bin +#if defined(NEED_grok_bin) +static UV DPPP_(my_grok_bin)(pTHX_ const char * start, STRLEN * len_p, I32 * flags, NV * result); +static +#else +extern UV DPPP_(my_grok_bin)(pTHX_ const char * start, STRLEN * len_p, I32 * flags, NV * result); +#endif + +#ifdef grok_bin +# undef grok_bin +#endif +#define grok_bin(a,b,c,d) DPPP_(my_grok_bin)(aTHX_ a,b,c,d) +#define Perl_grok_bin DPPP_(my_grok_bin) + +#if defined(NEED_grok_bin) || defined(NEED_grok_bin_GLOBAL) +UV +DPPP_(my_grok_bin)(pTHX_ const char *start, STRLEN *len_p, I32 *flags, NV *result) +{ + const char *s = start; + STRLEN len = *len_p; + UV value = 0; + NV value_nv = 0; + + const UV max_div_2 = UV_MAX / 2; + bool allow_underscores = *flags & PERL_SCAN_ALLOW_UNDERSCORES; + bool overflowed = FALSE; + + if (!(*flags & PERL_SCAN_DISALLOW_PREFIX)) { + /* strip off leading b or 0b. + for compatibility silently suffer "b" and "0b" as valid binary + numbers. */ + if (len >= 1) { + if (s[0] == 'b') { + s++; + len--; + } + else if (len >= 2 && s[0] == '0' && s[1] == 'b') { + s+=2; + len-=2; + } + } + } + + for (; len-- && *s; s++) { + char bit = *s; + if (bit == '0' || bit == '1') { + /* Write it in this wonky order with a goto to attempt to get the + compiler to make the common case integer-only loop pretty tight. + With gcc seems to be much straighter code than old scan_bin. */ + redo: + if (!overflowed) { + if (value <= max_div_2) { + value = (value << 1) | (bit - '0'); + continue; + } + /* Bah. We're just overflowed. */ + warn("Integer overflow in binary number"); + overflowed = TRUE; + value_nv = (NV) value; + } + value_nv *= 2.0; + /* If an NV has not enough bits in its mantissa to + * represent a UV this summing of small low-order numbers + * is a waste of time (because the NV cannot preserve + * the low-order bits anyway): we could just remember when + * did we overflow and in the end just multiply value_nv by the + * right amount. */ + value_nv += (NV)(bit - '0'); + continue; + } + if (bit == '_' && len && allow_underscores && (bit = s[1]) + && (bit == '0' || bit == '1')) + { + --len; + ++s; + goto redo; + } + if (!(*flags & PERL_SCAN_SILENT_ILLDIGIT)) + warn("Illegal binary digit '%c' ignored", *s); + break; + } + + if ( ( overflowed && value_nv > 4294967295.0) +#if UVSIZE > 4 + || (!overflowed && value > 0xffffffff ) +#endif + ) { + warn("Binary number > 0b11111111111111111111111111111111 non-portable"); + } + *len_p = s - start; + if (!overflowed) { + *flags = 0; + return value; + } + *flags = PERL_SCAN_GREATER_THAN_UV_MAX; + if (result) + *result = value_nv; + return UV_MAX; +} +#endif +#endif + +#ifndef grok_hex +#if defined(NEED_grok_hex) +static UV DPPP_(my_grok_hex)(pTHX_ const char * start, STRLEN * len_p, I32 * flags, NV * result); +static +#else +extern UV DPPP_(my_grok_hex)(pTHX_ const char * start, STRLEN * len_p, I32 * flags, NV * result); +#endif + +#ifdef grok_hex +# undef grok_hex +#endif +#define grok_hex(a,b,c,d) DPPP_(my_grok_hex)(aTHX_ a,b,c,d) +#define Perl_grok_hex DPPP_(my_grok_hex) + +#if defined(NEED_grok_hex) || defined(NEED_grok_hex_GLOBAL) +UV +DPPP_(my_grok_hex)(pTHX_ const char *start, STRLEN *len_p, I32 *flags, NV *result) +{ + const char *s = start; + STRLEN len = *len_p; + UV value = 0; + NV value_nv = 0; + + const UV max_div_16 = UV_MAX / 16; + bool allow_underscores = *flags & PERL_SCAN_ALLOW_UNDERSCORES; + bool overflowed = FALSE; + const char *xdigit; + + if (!(*flags & PERL_SCAN_DISALLOW_PREFIX)) { + /* strip off leading x or 0x. + for compatibility silently suffer "x" and "0x" as valid hex numbers. + */ + if (len >= 1) { + if (s[0] == 'x') { + s++; + len--; + } + else if (len >= 2 && s[0] == '0' && s[1] == 'x') { + s+=2; + len-=2; + } + } + } + + for (; len-- && *s; s++) { + xdigit = strchr((char *) PL_hexdigit, *s); + if (xdigit) { + /* Write it in this wonky order with a goto to attempt to get the + compiler to make the common case integer-only loop pretty tight. + With gcc seems to be much straighter code than old scan_hex. */ + redo: + if (!overflowed) { + if (value <= max_div_16) { + value = (value << 4) | ((xdigit - PL_hexdigit) & 15); + continue; + } + warn("Integer overflow in hexadecimal number"); + overflowed = TRUE; + value_nv = (NV) value; + } + value_nv *= 16.0; + /* If an NV has not enough bits in its mantissa to + * represent a UV this summing of small low-order numbers + * is a waste of time (because the NV cannot preserve + * the low-order bits anyway): we could just remember when + * did we overflow and in the end just multiply value_nv by the + * right amount of 16-tuples. */ + value_nv += (NV)((xdigit - PL_hexdigit) & 15); + continue; + } + if (*s == '_' && len && allow_underscores && s[1] + && (xdigit = strchr((char *) PL_hexdigit, s[1]))) + { + --len; + ++s; + goto redo; + } + if (!(*flags & PERL_SCAN_SILENT_ILLDIGIT)) + warn("Illegal hexadecimal digit '%c' ignored", *s); + break; + } + + if ( ( overflowed && value_nv > 4294967295.0) +#if UVSIZE > 4 + || (!overflowed && value > 0xffffffff ) +#endif + ) { + warn("Hexadecimal number > 0xffffffff non-portable"); + } + *len_p = s - start; + if (!overflowed) { + *flags = 0; + return value; + } + *flags = PERL_SCAN_GREATER_THAN_UV_MAX; + if (result) + *result = value_nv; + return UV_MAX; +} +#endif +#endif + +#ifndef grok_oct +#if defined(NEED_grok_oct) +static UV DPPP_(my_grok_oct)(pTHX_ const char * start, STRLEN * len_p, I32 * flags, NV * result); +static +#else +extern UV DPPP_(my_grok_oct)(pTHX_ const char * start, STRLEN * len_p, I32 * flags, NV * result); +#endif + +#ifdef grok_oct +# undef grok_oct +#endif +#define grok_oct(a,b,c,d) DPPP_(my_grok_oct)(aTHX_ a,b,c,d) +#define Perl_grok_oct DPPP_(my_grok_oct) + +#if defined(NEED_grok_oct) || defined(NEED_grok_oct_GLOBAL) +UV +DPPP_(my_grok_oct)(pTHX_ const char *start, STRLEN *len_p, I32 *flags, NV *result) +{ + const char *s = start; + STRLEN len = *len_p; + UV value = 0; + NV value_nv = 0; + + const UV max_div_8 = UV_MAX / 8; + bool allow_underscores = *flags & PERL_SCAN_ALLOW_UNDERSCORES; + bool overflowed = FALSE; + + for (; len-- && *s; s++) { + /* gcc 2.95 optimiser not smart enough to figure that this subtraction + out front allows slicker code. */ + int digit = *s - '0'; + if (digit >= 0 && digit <= 7) { + /* Write it in this wonky order with a goto to attempt to get the + compiler to make the common case integer-only loop pretty tight. + */ + redo: + if (!overflowed) { + if (value <= max_div_8) { + value = (value << 3) | digit; + continue; + } + /* Bah. We're just overflowed. */ + warn("Integer overflow in octal number"); + overflowed = TRUE; + value_nv = (NV) value; + } + value_nv *= 8.0; + /* If an NV has not enough bits in its mantissa to + * represent a UV this summing of small low-order numbers + * is a waste of time (because the NV cannot preserve + * the low-order bits anyway): we could just remember when + * did we overflow and in the end just multiply value_nv by the + * right amount of 8-tuples. */ + value_nv += (NV)digit; + continue; + } + if (digit == ('_' - '0') && len && allow_underscores + && (digit = s[1] - '0') && (digit >= 0 && digit <= 7)) + { + --len; + ++s; + goto redo; + } + /* Allow \octal to work the DWIM way (that is, stop scanning + * as soon as non-octal characters are seen, complain only iff + * someone seems to want to use the digits eight and nine). */ + if (digit == 8 || digit == 9) { + if (!(*flags & PERL_SCAN_SILENT_ILLDIGIT)) + warn("Illegal octal digit '%c' ignored", *s); + } + break; + } + + if ( ( overflowed && value_nv > 4294967295.0) +#if UVSIZE > 4 + || (!overflowed && value > 0xffffffff ) +#endif + ) { + warn("Octal number > 037777777777 non-portable"); + } + *len_p = s - start; + if (!overflowed) { + *flags = 0; + return value; + } + *flags = PERL_SCAN_GREATER_THAN_UV_MAX; + if (result) + *result = value_nv; + return UV_MAX; +} +#endif +#endif + +#if !defined(my_snprintf) +#if defined(NEED_my_snprintf) +static int DPPP_(my_my_snprintf)(char * buffer, const Size_t len, const char * format, ...); +static +#else +extern int DPPP_(my_my_snprintf)(char * buffer, const Size_t len, const char * format, ...); +#endif + +#define my_snprintf DPPP_(my_my_snprintf) +#define Perl_my_snprintf DPPP_(my_my_snprintf) + +#if defined(NEED_my_snprintf) || defined(NEED_my_snprintf_GLOBAL) + +int +DPPP_(my_my_snprintf)(char *buffer, const Size_t len, const char *format, ...) +{ + dTHX; + int retval; + va_list ap; + va_start(ap, format); +#ifdef HAS_VSNPRINTF + retval = vsnprintf(buffer, len, format, ap); +#else + retval = vsprintf(buffer, format, ap); +#endif + va_end(ap); + if (retval < 0 || (len > 0 && (Size_t)retval >= len)) + Perl_croak(aTHX_ "panic: my_snprintf buffer overflow"); + return retval; +} + +#endif +#endif + +#if !defined(my_sprintf) +#if defined(NEED_my_sprintf) +static int DPPP_(my_my_sprintf)(char * buffer, const char * pat, ...); +static +#else +extern int DPPP_(my_my_sprintf)(char * buffer, const char * pat, ...); +#endif + +#define my_sprintf DPPP_(my_my_sprintf) +#define Perl_my_sprintf DPPP_(my_my_sprintf) + +#if defined(NEED_my_sprintf) || defined(NEED_my_sprintf_GLOBAL) + +int +DPPP_(my_my_sprintf)(char *buffer, const char* pat, ...) +{ + va_list args; + va_start(args, pat); + vsprintf(buffer, pat, args); + va_end(args); + return strlen(buffer); +} + +#endif +#endif + +#ifdef NO_XSLOCKS +# ifdef dJMPENV +# define dXCPT dJMPENV; int rEtV = 0 +# define XCPT_TRY_START JMPENV_PUSH(rEtV); if (rEtV == 0) +# define XCPT_TRY_END JMPENV_POP; +# define XCPT_CATCH if (rEtV != 0) +# define XCPT_RETHROW JMPENV_JUMP(rEtV) +# else +# define dXCPT Sigjmp_buf oldTOP; int rEtV = 0 +# define XCPT_TRY_START Copy(top_env, oldTOP, 1, Sigjmp_buf); rEtV = Sigsetjmp(top_env, 1); if (rEtV == 0) +# define XCPT_TRY_END Copy(oldTOP, top_env, 1, Sigjmp_buf); +# define XCPT_CATCH if (rEtV != 0) +# define XCPT_RETHROW Siglongjmp(top_env, rEtV) +# endif +#endif + +#if !defined(my_strlcat) +#if defined(NEED_my_strlcat) +static Size_t DPPP_(my_my_strlcat)(char * dst, const char * src, Size_t size); +static +#else +extern Size_t DPPP_(my_my_strlcat)(char * dst, const char * src, Size_t size); +#endif + +#define my_strlcat DPPP_(my_my_strlcat) +#define Perl_my_strlcat DPPP_(my_my_strlcat) + +#if defined(NEED_my_strlcat) || defined(NEED_my_strlcat_GLOBAL) + +Size_t +DPPP_(my_my_strlcat)(char *dst, const char *src, Size_t size) +{ + Size_t used, length, copy; + + used = strlen(dst); + length = strlen(src); + if (size > 0 && used < size - 1) { + copy = (length >= size - used) ? size - used - 1 : length; + memcpy(dst + used, src, copy); + dst[used + copy] = '\0'; + } + return used + length; +} +#endif +#endif + +#if !defined(my_strlcpy) +#if defined(NEED_my_strlcpy) +static Size_t DPPP_(my_my_strlcpy)(char * dst, const char * src, Size_t size); +static +#else +extern Size_t DPPP_(my_my_strlcpy)(char * dst, const char * src, Size_t size); +#endif + +#define my_strlcpy DPPP_(my_my_strlcpy) +#define Perl_my_strlcpy DPPP_(my_my_strlcpy) + +#if defined(NEED_my_strlcpy) || defined(NEED_my_strlcpy_GLOBAL) + +Size_t +DPPP_(my_my_strlcpy)(char *dst, const char *src, Size_t size) +{ + Size_t length, copy; + + length = strlen(src); + if (size > 0) { + copy = (length >= size) ? size - 1 : length; + memcpy(dst, src, copy); + dst[copy] = '\0'; + } + return length; +} + +#endif +#endif +#ifndef PERL_PV_ESCAPE_QUOTE +# define PERL_PV_ESCAPE_QUOTE 0x0001 +#endif + +#ifndef PERL_PV_PRETTY_QUOTE +# define PERL_PV_PRETTY_QUOTE PERL_PV_ESCAPE_QUOTE +#endif + +#ifndef PERL_PV_PRETTY_ELLIPSES +# define PERL_PV_PRETTY_ELLIPSES 0x0002 +#endif + +#ifndef PERL_PV_PRETTY_LTGT +# define PERL_PV_PRETTY_LTGT 0x0004 +#endif + +#ifndef PERL_PV_ESCAPE_FIRSTCHAR +# define PERL_PV_ESCAPE_FIRSTCHAR 0x0008 +#endif + +#ifndef PERL_PV_ESCAPE_UNI +# define PERL_PV_ESCAPE_UNI 0x0100 +#endif + +#ifndef PERL_PV_ESCAPE_UNI_DETECT +# define PERL_PV_ESCAPE_UNI_DETECT 0x0200 +#endif + +#ifndef PERL_PV_ESCAPE_ALL +# define PERL_PV_ESCAPE_ALL 0x1000 +#endif + +#ifndef PERL_PV_ESCAPE_NOBACKSLASH +# define PERL_PV_ESCAPE_NOBACKSLASH 0x2000 +#endif + +#ifndef PERL_PV_ESCAPE_NOCLEAR +# define PERL_PV_ESCAPE_NOCLEAR 0x4000 +#endif + +#ifndef PERL_PV_ESCAPE_RE +# define PERL_PV_ESCAPE_RE 0x8000 +#endif + +#ifndef PERL_PV_PRETTY_NOCLEAR +# define PERL_PV_PRETTY_NOCLEAR PERL_PV_ESCAPE_NOCLEAR +#endif +#ifndef PERL_PV_PRETTY_DUMP +# define PERL_PV_PRETTY_DUMP PERL_PV_PRETTY_ELLIPSES|PERL_PV_PRETTY_QUOTE +#endif + +#ifndef PERL_PV_PRETTY_REGPROP +# define PERL_PV_PRETTY_REGPROP PERL_PV_PRETTY_ELLIPSES|PERL_PV_PRETTY_LTGT|PERL_PV_ESCAPE_RE +#endif + +/* Hint: pv_escape + * Note that unicode functionality is only backported to + * those perl versions that support it. For older perl + * versions, the implementation will fall back to bytes. + */ + +#ifndef pv_escape +#if defined(NEED_pv_escape) +static char * DPPP_(my_pv_escape)(pTHX_ SV * dsv, char const * const str, const STRLEN count, const STRLEN max, STRLEN * const escaped, const U32 flags); +static +#else +extern char * DPPP_(my_pv_escape)(pTHX_ SV * dsv, char const * const str, const STRLEN count, const STRLEN max, STRLEN * const escaped, const U32 flags); +#endif + +#ifdef pv_escape +# undef pv_escape +#endif +#define pv_escape(a,b,c,d,e,f) DPPP_(my_pv_escape)(aTHX_ a,b,c,d,e,f) +#define Perl_pv_escape DPPP_(my_pv_escape) + +#if defined(NEED_pv_escape) || defined(NEED_pv_escape_GLOBAL) + +char * +DPPP_(my_pv_escape)(pTHX_ SV *dsv, char const * const str, + const STRLEN count, const STRLEN max, + STRLEN * const escaped, const U32 flags) +{ + const char esc = flags & PERL_PV_ESCAPE_RE ? '%' : '\\'; + const char dq = flags & PERL_PV_ESCAPE_QUOTE ? '"' : esc; + char octbuf[32] = "%123456789ABCDF"; + STRLEN wrote = 0; + STRLEN chsize = 0; + STRLEN readsize = 1; +#if defined(is_utf8_string) && defined(utf8_to_uvchr) + bool isuni = flags & PERL_PV_ESCAPE_UNI ? 1 : 0; +#endif + const char *pv = str; + const char * const end = pv + count; + octbuf[0] = esc; + + if (!(flags & PERL_PV_ESCAPE_NOCLEAR)) + sv_setpvs(dsv, ""); + +#if defined(is_utf8_string) && defined(utf8_to_uvchr) + if ((flags & PERL_PV_ESCAPE_UNI_DETECT) && is_utf8_string((U8*)pv, count)) + isuni = 1; +#endif + + for (; pv < end && (!max || wrote < max) ; pv += readsize) { + const UV u = +#if defined(is_utf8_string) && defined(utf8_to_uvchr) + isuni ? utf8_to_uvchr((U8*)pv, &readsize) : +#endif + (U8)*pv; + const U8 c = (U8)u & 0xFF; + + if (u > 255 || (flags & PERL_PV_ESCAPE_ALL)) { + if (flags & PERL_PV_ESCAPE_FIRSTCHAR) + chsize = my_snprintf(octbuf, sizeof octbuf, + "%"UVxf, u); + else + chsize = my_snprintf(octbuf, sizeof octbuf, + "%cx{%"UVxf"}", esc, u); + } else if (flags & PERL_PV_ESCAPE_NOBACKSLASH) { + chsize = 1; + } else { + if (c == dq || c == esc || !isPRINT(c)) { + chsize = 2; + switch (c) { + case '\\' : /* fallthrough */ + case '%' : if (c == esc) + octbuf[1] = esc; + else + chsize = 1; + break; + case '\v' : octbuf[1] = 'v'; break; + case '\t' : octbuf[1] = 't'; break; + case '\r' : octbuf[1] = 'r'; break; + case '\n' : octbuf[1] = 'n'; break; + case '\f' : octbuf[1] = 'f'; break; + case '"' : if (dq == '"') + octbuf[1] = '"'; + else + chsize = 1; + break; + default: chsize = my_snprintf(octbuf, sizeof octbuf, + pv < end && isDIGIT((U8)*(pv+readsize)) + ? "%c%03o" : "%c%o", esc, c); + } + } else { + chsize = 1; + } + } + if (max && wrote + chsize > max) { + break; + } else if (chsize > 1) { + sv_catpvn(dsv, octbuf, chsize); + wrote += chsize; + } else { + char tmp[2]; + my_snprintf(tmp, sizeof tmp, "%c", c); + sv_catpvn(dsv, tmp, 1); + wrote++; + } + if (flags & PERL_PV_ESCAPE_FIRSTCHAR) + break; + } + if (escaped != NULL) + *escaped= pv - str; + return SvPVX(dsv); +} + +#endif +#endif + +#ifndef pv_pretty +#if defined(NEED_pv_pretty) +static char * DPPP_(my_pv_pretty)(pTHX_ SV * dsv, char const * const str, const STRLEN count, const STRLEN max, char const * const start_color, char const * const end_color, const U32 flags); +static +#else +extern char * DPPP_(my_pv_pretty)(pTHX_ SV * dsv, char const * const str, const STRLEN count, const STRLEN max, char const * const start_color, char const * const end_color, const U32 flags); +#endif + +#ifdef pv_pretty +# undef pv_pretty +#endif +#define pv_pretty(a,b,c,d,e,f,g) DPPP_(my_pv_pretty)(aTHX_ a,b,c,d,e,f,g) +#define Perl_pv_pretty DPPP_(my_pv_pretty) + +#if defined(NEED_pv_pretty) || defined(NEED_pv_pretty_GLOBAL) + +char * +DPPP_(my_pv_pretty)(pTHX_ SV *dsv, char const * const str, const STRLEN count, + const STRLEN max, char const * const start_color, char const * const end_color, + const U32 flags) +{ + const U8 dq = (flags & PERL_PV_PRETTY_QUOTE) ? '"' : '%'; + STRLEN escaped; + + if (!(flags & PERL_PV_PRETTY_NOCLEAR)) + sv_setpvs(dsv, ""); + + if (dq == '"') + sv_catpvs(dsv, "\""); + else if (flags & PERL_PV_PRETTY_LTGT) + sv_catpvs(dsv, "<"); + + if (start_color != NULL) + sv_catpv(dsv, D_PPP_CONSTPV_ARG(start_color)); + + pv_escape(dsv, str, count, max, &escaped, flags | PERL_PV_ESCAPE_NOCLEAR); + + if (end_color != NULL) + sv_catpv(dsv, D_PPP_CONSTPV_ARG(end_color)); + + if (dq == '"') + sv_catpvs(dsv, "\""); + else if (flags & PERL_PV_PRETTY_LTGT) + sv_catpvs(dsv, ">"); + + if ((flags & PERL_PV_PRETTY_ELLIPSES) && escaped < count) + sv_catpvs(dsv, "..."); + + return SvPVX(dsv); +} + +#endif +#endif + +#ifndef pv_display +#if defined(NEED_pv_display) +static char * DPPP_(my_pv_display)(pTHX_ SV * dsv, const char * pv, STRLEN cur, STRLEN len, STRLEN pvlim); +static +#else +extern char * DPPP_(my_pv_display)(pTHX_ SV * dsv, const char * pv, STRLEN cur, STRLEN len, STRLEN pvlim); +#endif + +#ifdef pv_display +# undef pv_display +#endif +#define pv_display(a,b,c,d,e) DPPP_(my_pv_display)(aTHX_ a,b,c,d,e) +#define Perl_pv_display DPPP_(my_pv_display) + +#if defined(NEED_pv_display) || defined(NEED_pv_display_GLOBAL) + +char * +DPPP_(my_pv_display)(pTHX_ SV *dsv, const char *pv, STRLEN cur, STRLEN len, STRLEN pvlim) +{ + pv_pretty(dsv, pv, cur, pvlim, NULL, NULL, PERL_PV_PRETTY_DUMP); + if (len > cur && pv[cur] == '\0') + sv_catpvs(dsv, "\\0"); + return SvPVX(dsv); +} + +#endif +#endif + +#endif /* _P_P_PORTABILITY_H_ */ + +/* End of File ppport.h */ diff --git a/contrib/DNS-LDNS/t/DNS-LDNS.t b/contrib/DNS-LDNS/t/DNS-LDNS.t new file mode 100644 index 0000000000000..eeae54c6829bf --- /dev/null +++ b/contrib/DNS-LDNS/t/DNS-LDNS.t @@ -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. + diff --git a/contrib/DNS-LDNS/t/dnssec_datachain.t b/contrib/DNS-LDNS/t/dnssec_datachain.t new file mode 100644 index 0000000000000..3eff6f15760f8 --- /dev/null +++ b/contrib/DNS-LDNS/t/dnssec_datachain.t @@ -0,0 +1,56 @@ +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); + +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'); diff --git a/contrib/DNS-LDNS/t/dnssec_zone.t b/contrib/DNS-LDNS/t/dnssec_zone.t new file mode 100644 index 0000000000000..48115aa8e9c76 --- /dev/null +++ b/contrib/DNS-LDNS/t/dnssec_zone.t @@ -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'); diff --git a/contrib/DNS-LDNS/t/key.t b/contrib/DNS-LDNS/t/key.t new file mode 100644 index 0000000000000..f0aa08d763738 --- /dev/null +++ b/contrib/DNS-LDNS/t/key.t @@ -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'); diff --git a/contrib/DNS-LDNS/t/rdata.t b/contrib/DNS-LDNS/t/rdata.t new file mode 100644 index 0000000000000..81931c28f89ef --- /dev/null +++ b/contrib/DNS-LDNS/t/rdata.t @@ -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'); diff --git a/contrib/DNS-LDNS/t/resolver.t b/contrib/DNS-LDNS/t/resolver.t new file mode 100644 index 0000000000000..4716a8c2cad16 --- /dev/null +++ b/contrib/DNS-LDNS/t/resolver.t @@ -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"); diff --git a/contrib/DNS-LDNS/t/rr.t b/contrib/DNS-LDNS/t/rr.t new file mode 100644 index 0000000000000..45b3d9f62f33e --- /dev/null +++ b/contrib/DNS-LDNS/t/rr.t @@ -0,0 +1,47 @@ +use Test::More tests => 14; + +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'); diff --git a/contrib/DNS-LDNS/t/rrlist.t b/contrib/DNS-LDNS/t/rrlist.t new file mode 100644 index 0000000000000..1ff0b48ad4486 --- /dev/null +++ b/contrib/DNS-LDNS/t/rrlist.t @@ -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'); diff --git a/contrib/DNS-LDNS/t/testdata/key.private b/contrib/DNS-LDNS/t/testdata/key.private new file mode 100644 index 0000000000000..5b6601b666b10 --- /dev/null +++ b/contrib/DNS-LDNS/t/testdata/key.private @@ -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 diff --git a/contrib/DNS-LDNS/t/testdata/myzone.org b/contrib/DNS-LDNS/t/testdata/myzone.org new file mode 100644 index 0000000000000..a99a9fe54d892 --- /dev/null +++ b/contrib/DNS-LDNS/t/testdata/myzone.org @@ -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 diff --git a/contrib/DNS-LDNS/t/testdata/resolv.conf b/contrib/DNS-LDNS/t/testdata/resolv.conf new file mode 100644 index 0000000000000..b66ae5732fa34 --- /dev/null +++ b/contrib/DNS-LDNS/t/testdata/resolv.conf @@ -0,0 +1,3 @@ +nameserver 127.0.0.1 +nameserver 192.168.100.1 +search foo.bar.org diff --git a/contrib/DNS-LDNS/t/zone.t b/contrib/DNS-LDNS/t/zone.t new file mode 100644 index 0000000000000..522a85664db31 --- /dev/null +++ b/contrib/DNS-LDNS/t/zone.t @@ -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'); diff --git a/contrib/DNS-LDNS/typemap b/contrib/DNS-LDNS/typemap new file mode 100644 index 0000000000000..568404bbb4726 --- /dev/null +++ b/contrib/DNS-LDNS/typemap @@ -0,0 +1,67 @@ +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}\") + +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 +Mortal_PV + sv_setsv($arg, sv_2mortal(newSVpv($var, 0))); + free((void *)$var); |