ldns-1.6.17/0000755000175100017510000000000012264060171012113 5ustar willemwillemldns-1.6.17/packaging/0000775000175100017510000000000012264060151014037 5ustar willemwillemldns-1.6.17/packaging/libldns.pc.in0000664000175100017510000000044212264060151016417 0ustar willemwillemprefix=@prefix@ exec_prefix=@exec_prefix@ libdir=@libdir@ includedir=@includedir@ Name: ldns Description: Library for DNS programming URL: http://www.nlnetlabs.nl/projects/ldns Version: @PACKAGE_VERSION@ Requires: Libs: -L${libdir} -lldns Libs.private: @LDFLAGS@ Cflags: -I${includedir} ldns-1.6.17/packaging/ldns-config.in0000775000175100017510000000145712264060151016604 0ustar willemwillem#!/bin/sh prefix="@prefix@" exec_prefix="@exec_prefix@" VERSION="@PACKAGE_VERSION@" CFLAGS="@CFLAGS@" CPPFLAGS="@CPPFLAGS@ @LIBSSL_CPPFLAGS@ @PYTHON_CPPFLAGS@" LDFLAGS="@LDFLAGS@ @LIBSSL_LDFLAGS@ @PYTHON_LDFLAGS@" LIBS="@LIBS@ @LIBSSL_LIBS@" LIBDIR="@libdir@" INCLUDEDIR="@includedir@" LIBVERSION="@LIBLDNS_CURRENT@.@LIBLDNS_REVISION@.@LIBLDNS_AGE@" for arg in $@ do if [ $arg = "--cflags" ] then echo "-I${INCLUDEDIR}" fi if [ $arg = "--libs" ] then echo "${LDFLAGS} -L${LIBDIR} ${LIBS} -lldns" fi if [ $arg = "-h" ] || [ $arg = "--help" ] then echo "Usage: $0 [--cflags] [--libs] [--version]" fi if [ $arg = "--version" ] then echo "${VERSION}" fi if [ $arg = "--libversion" ] then echo "${LIBVERSION}" fi done ldns-1.6.17/packaging/ldns-config.10000664000175100017510000000201012264060151016315 0ustar willemwillem.TH ldns-config 1 "22 Sep 2011" .SH NAME ldns-config \- show compiler and linker flags for ldns usage. .SH SYNOPSIS .B ldns-config [ .IR OPTIONS ] .SH DESCRIPTION When writing programs using ldns, you have to tell the compiler where to look for include files and what libraries from which location to link to. \fBldns-config\fR can be used to find out what flags to use with the C compiler and the linker. .SH OPTIONS .TP \fB--cflags\fR Show the C compiler flags needed to compile with ldns .TP \fB--libs\fR Show the flags to be used to link with ldns .TP \fB--version\fR Shows the ldns version of the installed ldns library .TP \fB--libversion\fR Shows version of the binary api of the installed ldns library .TP \fB--help\fR Show \fBldns-config\fR usage description .SH AUTHOR Written by the ldns team. .SH REPORTING BUGS Report bugs to . .SH COPYRIGHT Copyright (C) 2011 NLnet Labs. This is free software. There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. ldns-1.6.17/packaging/fedora/0000775000175100017510000000000012264060151015277 5ustar willemwillemldns-1.6.17/packaging/fedora/ldns.spec0000664000175100017510000001475312264060151017125 0ustar willemwillem%{?!with_python: %global with_python 1} %if %{with_python} %{!?python_sitelib: %global python_sitelib %(%{__python} -c "from distutils.sysconfig import get_python_lib; print get_python_lib()")} %{!?python_sitearch: %global python_sitearch %(%{__python} -c "from distutils.sysconfig import get_python_lib; print get_python_lib(1)")} %endif Summary: Lowlevel DNS(SEC) library with API Name: ldns Version: 1.6.13 Release: 1%{?dist} License: BSD Url: http://www.nlnetlabs.nl/%{name}/ Source: http://www.nlnetlabs.nl/downloads/%{%name}/%{name}-%{version}.tar.gz Group: System Environment/Libraries BuildRoot: %{_tmppath}/%{name}-%{version}-%{release}-root-%(%{__id_u} -n) BuildRequires: perl, libpcap-devel, openssl-devel , gcc-c++, doxygen, # Only needed for builds from svn snapshot # BuildRequires: libtool, autoconf, automake %if %{with_python} BuildRequires: python-devel, swig %endif %description ldns is a library with the aim to simplify DNS programing in C. All lowlevel DNS/DNSSEC operations are supported. We also define a higher level API which allows a programmer to (for instance) create or sign packets. %package devel Summary: Development package that includes the ldns header files Group: Development/Libraries Requires: %{name} = %{version}-%{release} %description devel The devel package contains the ldns library and the include files %if %{with_python} %package python Summary: Python extensions for ldns Group: Applications/System Requires: %{name} = %{version}-%{release} %description python Python extensions for ldns %endif %prep %setup -q # To built svn snapshots # rm config.guess config.sub ltmain.sh # aclocal # libtoolize -c # autoreconf %build %configure --disable-rpath --disable-static --with-sha2 --disable-gost \ %if %{with_python} --with-pyldns %endif (cd drill ; %configure --disable-rpath --disable-static --with-sha2 --disable-gost --with-ldns=%{buildroot}/lib/ ) (cd examples ; %configure --disable-rpath --disable-static --with-sha2 --disable-gost --with-ldns=%{buildroot}/lib/ ) make %{?_smp_mflags} ( cd drill ; make %{?_smp_mflags} ) ( cd examples ; make %{?_smp_mflags} ) make %{?_smp_mflags} doc %install rm -rf %{buildroot} make DESTDIR=%{buildroot} INSTALL="%{__install} -p" install make DESTDIR=%{buildroot} INSTALL="%{__install} -p" install-doc # don't install another set of man pages from doc/ rm -rf doc/man/ # don't package building script for install-doc in doc section rm doc/doxyparse.pl # remove .la files rm -rf %{buildroot}%{_libdir}/*.la %{buildroot}%{python_sitearch}/*.la (cd drill ; make DESTDIR=%{buildroot} install) (cd examples; make DESTDIR=%{buildroot} install) %clean rm -rf %{buildroot} %files %defattr(-,root,root) %{_libdir}/libldns*so.* %{_bindir}/drill %{_bindir}/ldnsd %{_bindir}/ldns-chaos %{_bindir}/ldns-compare-zones %{_bindir}/ldns-[d-z]* %doc README LICENSE %{_mandir}/*/* %files devel %defattr(-,root,root,-) %{_libdir}/libldns*so %{_bindir}/ldns-config %dir %{_includedir}/ldns %{_includedir}/ldns/*.h %doc doc Changelog README %if %{with_python} %files python %defattr(-,root,root) %{python_sitearch}/* %endif %post -p /sbin/ldconfig %postun -p /sbin/ldconfig %changelog * Thu Sep 22 2011 Paul Wouters - 1.6.11-1 - Updated to 1.6.11 - Cleanup spec for - Python goes into sitearch, not sitelib * Wed Jun 08 2011 Paul Wouters - 1.6.10-1 - Updated to 1.6.10 - commented out build dependancies for svn snapshots * Sun Mar 27 2011 Paul Wouters - 1.6.9-1 - Updated to 1.6.9 * Mon Jan 24 2011 Paul Wouters - 1.6.8-1 - Updated to 1.6.8 * Thu Aug 26 2010 Paul Wouters - 1.6.6-1 - Upgraded to 1.6.6 * Mon Apr 26 2010 Paul Wouters - 1.6.4-4 - Disable a debug line that was added to find the LOC issue that causes unexpected output for automated tools using ldns-read-zone * Thu Feb 11 2010 Paul Wouters - 1.6.4-3 - Applied fix svn 3186 for LOC record parsing * Fri Jan 22 2010 Paul Wouters - 1.6.4-2 - libtool on EL-5 does not take --install as argument * Fri Jan 22 2010 Paul Wouters - 1.6.4-1 - Upgraded to 1.6.4 - Added ldns-python sub package - Patch for installing ldns-python files - Patch for rpath in ldns-python * Sun Aug 16 2009 Paul Wouters - 1.6.1-2 - Bump version, sources file was not updated. * Sun Aug 16 2009 Paul Wouters - 1.6.1-1 -Updated to 1.6.1 * Sat Jul 11 2009 Paul Wouters - 1.6.0-1 - Updated to 1.6.0 * Thu Apr 16 2009 Paul Wouters - 1.5.1-2 - Memory management bug when generating a sha256 key, see: https://bugzilla.redhat.com/show_bug.cgi?id=493953 * Fri Feb 13 2009 Paul Wouters - 1.5.1-1 - Upgrade to 1.5.1 (1.5.0 was a dud release) * Sun Nov 9 2008 Paul Wouters - 1.4.0-2 - libldns.so was missing in files section. * Sun Nov 9 2008 Paul Wouters - 1.4.0-1 - Updated to 1.4.0 - enable SHA2 functionality * Mon Jun 30 2008 Paul Wouters - 1.3.0-1 - Updated to latest release * Thu Nov 29 2007 Paul Wouters - 1.2.2-1 - Upgraded to 1.2.2. * Mon Sep 11 2006 Paul Wouters 1.0.1-4 - Commented out 1.1.0 make targets, put make 1.0.1 targets. * Mon Sep 11 2006 Paul Wouters 1.0.1-3 - Fixed changelog typo in date - Rebuild requested for PT_GNU_HASH support from gcc - Did not upgrade to 1.1.0 due to compile issues on x86_64 * Fri Jan 6 2006 Paul Wouters 1.0.1-1 - Upgraded to 1.0.1. Removed temporary clean hack from spec file. * Sun Dec 18 2005 Paul Wouters 1.0.0-8 - Cannot use make clean because there are no Makefiles. Use hardcoded rm. * Sun Dec 18 2005 Paul Wouters 1.0.0-7 - Patched 'make clean' target to get rid of object files shipped with 1.0.0 * Sun Dec 13 2005 Paul Wouters 1.0.0-6 - added a make clean for 2.3.3 since .o files were left behind upstream, causing failure on ppc platform * Sun Dec 11 2005 Tom "spot" Callaway 1.0.0-5 - minor cleanups * Wed Oct 5 2005 Paul Wouters 0.70_1205 - reworked for svn version * Sun Sep 25 2005 Paul Wouters - 0.70 - Initial version ldns-1.6.17/dnssec.c0000664000175100017510000013423012264060151013541 0ustar willemwillem/* * dnssec.c * * contains the cryptographic function needed for DNSSEC in ldns * The crypto library used is openssl * * (c) NLnet Labs, 2004-2008 * * See the file LICENSE for the license */ #include #include #include #include #include #ifdef HAVE_SSL #include #include #include #include #include #endif ldns_rr * ldns_dnssec_get_rrsig_for_name_and_type(const ldns_rdf *name, const ldns_rr_type type, const ldns_rr_list *rrs) { size_t i; ldns_rr *candidate; if (!name || !rrs) { return NULL; } for (i = 0; i < ldns_rr_list_rr_count(rrs); i++) { candidate = ldns_rr_list_rr(rrs, i); if (ldns_rr_get_type(candidate) == LDNS_RR_TYPE_RRSIG) { if (ldns_dname_compare(ldns_rr_owner(candidate), name) == 0 && ldns_rdf2rr_type(ldns_rr_rrsig_typecovered(candidate)) == type ) { return candidate; } } } return NULL; } ldns_rr * ldns_dnssec_get_dnskey_for_rrsig(const ldns_rr *rrsig, const ldns_rr_list *rrs) { size_t i; ldns_rr *candidate; if (!rrsig || !rrs) { return NULL; } for (i = 0; i < ldns_rr_list_rr_count(rrs); i++) { candidate = ldns_rr_list_rr(rrs, i); if (ldns_rr_get_type(candidate) == LDNS_RR_TYPE_DNSKEY) { if (ldns_dname_compare(ldns_rr_owner(candidate), ldns_rr_rrsig_signame(rrsig)) == 0 && ldns_rdf2native_int16(ldns_rr_rrsig_keytag(rrsig)) == ldns_calc_keytag(candidate) ) { return candidate; } } } return NULL; } ldns_rdf * ldns_nsec_get_bitmap(ldns_rr *nsec) { if (ldns_rr_get_type(nsec) == LDNS_RR_TYPE_NSEC) { return ldns_rr_rdf(nsec, 1); } else if (ldns_rr_get_type(nsec) == LDNS_RR_TYPE_NSEC3) { return ldns_rr_rdf(nsec, 5); } else { return NULL; } } /*return the owner name of the closest encloser for name from the list of rrs */ /* this is NOT the hash, but the original name! */ ldns_rdf * ldns_dnssec_nsec3_closest_encloser(ldns_rdf *qname, ATTR_UNUSED(ldns_rr_type qtype), ldns_rr_list *nsec3s) { /* remember parameters, they must match */ uint8_t algorithm; uint32_t iterations; uint8_t salt_length; uint8_t *salt; ldns_rdf *sname, *hashed_sname, *tmp; bool flag; bool exact_match_found; bool in_range_found; ldns_status status; ldns_rdf *zone_name; size_t nsec_i; ldns_rr *nsec; ldns_rdf *result = NULL; if (!qname || !nsec3s || ldns_rr_list_rr_count(nsec3s) < 1) { return NULL; } nsec = ldns_rr_list_rr(nsec3s, 0); algorithm = ldns_nsec3_algorithm(nsec); salt_length = ldns_nsec3_salt_length(nsec); salt = ldns_nsec3_salt_data(nsec); iterations = ldns_nsec3_iterations(nsec); sname = ldns_rdf_clone(qname); flag = false; zone_name = ldns_dname_left_chop(ldns_rr_owner(nsec)); /* algorithm from nsec3-07 8.3 */ while (ldns_dname_label_count(sname) > 0) { exact_match_found = false; in_range_found = false; hashed_sname = ldns_nsec3_hash_name(sname, algorithm, iterations, salt_length, salt); status = ldns_dname_cat(hashed_sname, zone_name); if(status != LDNS_STATUS_OK) { LDNS_FREE(salt); ldns_rdf_deep_free(zone_name); ldns_rdf_deep_free(sname); return NULL; } for (nsec_i = 0; nsec_i < ldns_rr_list_rr_count(nsec3s); nsec_i++) { nsec = ldns_rr_list_rr(nsec3s, nsec_i); /* check values of iterations etc! */ /* exact match? */ if (ldns_dname_compare(ldns_rr_owner(nsec), hashed_sname) == 0) { exact_match_found = true; } else if (ldns_nsec_covers_name(nsec, hashed_sname)) { in_range_found = true; } } if (!exact_match_found && in_range_found) { flag = true; } else if (exact_match_found && flag) { result = ldns_rdf_clone(sname); /* RFC 5155: 8.3. 2.** "The proof is complete" */ ldns_rdf_deep_free(hashed_sname); goto done; } else if (exact_match_found && !flag) { /* error! */ ldns_rdf_deep_free(hashed_sname); goto done; } else { flag = false; } ldns_rdf_deep_free(hashed_sname); tmp = sname; sname = ldns_dname_left_chop(sname); ldns_rdf_deep_free(tmp); } done: LDNS_FREE(salt); ldns_rdf_deep_free(zone_name); ldns_rdf_deep_free(sname); return result; } bool ldns_dnssec_pkt_has_rrsigs(const ldns_pkt *pkt) { size_t i; for (i = 0; i < ldns_pkt_ancount(pkt); i++) { if (ldns_rr_get_type(ldns_rr_list_rr(ldns_pkt_answer(pkt), i)) == LDNS_RR_TYPE_RRSIG) { return true; } } for (i = 0; i < ldns_pkt_nscount(pkt); i++) { if (ldns_rr_get_type(ldns_rr_list_rr(ldns_pkt_authority(pkt), i)) == LDNS_RR_TYPE_RRSIG) { return true; } } return false; } ldns_rr_list * ldns_dnssec_pkt_get_rrsigs_for_name_and_type(const ldns_pkt *pkt, ldns_rdf *name, ldns_rr_type type) { uint16_t t_netorder; ldns_rr_list *sigs; ldns_rr_list *sigs_covered; ldns_rdf *rdf_t; sigs = ldns_pkt_rr_list_by_name_and_type(pkt, name, LDNS_RR_TYPE_RRSIG, LDNS_SECTION_ANY_NOQUESTION ); t_netorder = htons(type); /* rdf are in network order! */ rdf_t = ldns_rdf_new(LDNS_RDF_TYPE_TYPE, LDNS_RDF_SIZE_WORD, &t_netorder); sigs_covered = ldns_rr_list_subtype_by_rdf(sigs, rdf_t, 0); ldns_rdf_free(rdf_t); ldns_rr_list_deep_free(sigs); return sigs_covered; } ldns_rr_list * ldns_dnssec_pkt_get_rrsigs_for_type(const ldns_pkt *pkt, ldns_rr_type type) { uint16_t t_netorder; ldns_rr_list *sigs; ldns_rr_list *sigs_covered; ldns_rdf *rdf_t; sigs = ldns_pkt_rr_list_by_type(pkt, LDNS_RR_TYPE_RRSIG, LDNS_SECTION_ANY_NOQUESTION ); t_netorder = htons(type); /* rdf are in network order! */ rdf_t = ldns_rdf_new(LDNS_RDF_TYPE_TYPE, 2, &t_netorder); sigs_covered = ldns_rr_list_subtype_by_rdf(sigs, rdf_t, 0); ldns_rdf_free(rdf_t); ldns_rr_list_deep_free(sigs); return sigs_covered; } /* used only on the public key RR */ uint16_t ldns_calc_keytag(const ldns_rr *key) { uint16_t ac16; ldns_buffer *keybuf; size_t keysize; if (!key) { return 0; } if (ldns_rr_get_type(key) != LDNS_RR_TYPE_DNSKEY && ldns_rr_get_type(key) != LDNS_RR_TYPE_KEY ) { return 0; } /* rdata to buf - only put the rdata in a buffer */ keybuf = ldns_buffer_new(LDNS_MIN_BUFLEN); /* grows */ if (!keybuf) { return 0; } (void)ldns_rr_rdata2buffer_wire(keybuf, key); /* the current pos in the buffer is the keysize */ keysize= ldns_buffer_position(keybuf); ac16 = ldns_calc_keytag_raw(ldns_buffer_begin(keybuf), keysize); ldns_buffer_free(keybuf); return ac16; } uint16_t ldns_calc_keytag_raw(uint8_t* key, size_t keysize) { unsigned int i; uint32_t ac32; uint16_t ac16; if(keysize < 4) { return 0; } /* look at the algorithm field, copied from 2535bis */ if (key[3] == LDNS_RSAMD5) { ac16 = 0; if (keysize > 4) { memmove(&ac16, key + keysize - 3, 2); } ac16 = ntohs(ac16); return (uint16_t) ac16; } else { ac32 = 0; for (i = 0; (size_t)i < keysize; ++i) { ac32 += (i & 1) ? key[i] : key[i] << 8; } ac32 += (ac32 >> 16) & 0xFFFF; return (uint16_t) (ac32 & 0xFFFF); } } #ifdef HAVE_SSL DSA * ldns_key_buf2dsa(ldns_buffer *key) { return ldns_key_buf2dsa_raw((unsigned char*)ldns_buffer_begin(key), ldns_buffer_position(key)); } DSA * ldns_key_buf2dsa_raw(unsigned char* key, size_t len) { uint8_t T; uint16_t length; uint16_t offset; DSA *dsa; BIGNUM *Q; BIGNUM *P; BIGNUM *G; BIGNUM *Y; if(len == 0) return NULL; T = (uint8_t)key[0]; length = (64 + T * 8); offset = 1; if (T > 8) { return NULL; } if(len < (size_t)1 + SHA_DIGEST_LENGTH + 3*length) return NULL; Q = BN_bin2bn(key+offset, SHA_DIGEST_LENGTH, NULL); offset += SHA_DIGEST_LENGTH; P = BN_bin2bn(key+offset, (int)length, NULL); offset += length; G = BN_bin2bn(key+offset, (int)length, NULL); offset += length; Y = BN_bin2bn(key+offset, (int)length, NULL); offset += length; /* create the key and set its properties */ if(!Q || !P || !G || !Y || !(dsa = DSA_new())) { BN_free(Q); BN_free(P); BN_free(G); BN_free(Y); return NULL; } #ifndef S_SPLINT_S dsa->p = P; dsa->q = Q; dsa->g = G; dsa->pub_key = Y; #endif /* splint */ return dsa; } RSA * ldns_key_buf2rsa(ldns_buffer *key) { return ldns_key_buf2rsa_raw((unsigned char*)ldns_buffer_begin(key), ldns_buffer_position(key)); } RSA * ldns_key_buf2rsa_raw(unsigned char* key, size_t len) { uint16_t offset; uint16_t exp; uint16_t int16; RSA *rsa; BIGNUM *modulus; BIGNUM *exponent; if (len == 0) return NULL; if (key[0] == 0) { if(len < 3) return NULL; /* need some smart comment here XXX*/ /* the exponent is too large so it's places * futher...???? */ memmove(&int16, key+1, 2); exp = ntohs(int16); offset = 3; } else { exp = key[0]; offset = 1; } /* key length at least one */ if(len < (size_t)offset + exp + 1) return NULL; /* Exponent */ exponent = BN_new(); if(!exponent) return NULL; (void) BN_bin2bn(key+offset, (int)exp, exponent); offset += exp; /* Modulus */ modulus = BN_new(); if(!modulus) { BN_free(exponent); return NULL; } /* length of the buffer must match the key length! */ (void) BN_bin2bn(key+offset, (int)(len - offset), modulus); rsa = RSA_new(); if(!rsa) { BN_free(exponent); BN_free(modulus); return NULL; } #ifndef S_SPLINT_S rsa->n = modulus; rsa->e = exponent; #endif /* splint */ return rsa; } int ldns_digest_evp(unsigned char* data, unsigned int len, unsigned char* dest, const EVP_MD* md) { EVP_MD_CTX* ctx; ctx = EVP_MD_CTX_create(); if(!ctx) return false; if(!EVP_DigestInit_ex(ctx, md, NULL) || !EVP_DigestUpdate(ctx, data, len) || !EVP_DigestFinal_ex(ctx, dest, NULL)) { EVP_MD_CTX_destroy(ctx); return false; } EVP_MD_CTX_destroy(ctx); return true; } #endif /* HAVE_SSL */ ldns_rr * ldns_key_rr2ds(const ldns_rr *key, ldns_hash h) { ldns_rdf *tmp; ldns_rr *ds; uint16_t keytag; uint8_t sha1hash; uint8_t *digest; ldns_buffer *data_buf; #ifdef USE_GOST const EVP_MD* md = NULL; #endif if (ldns_rr_get_type(key) != LDNS_RR_TYPE_DNSKEY) { return NULL; } ds = ldns_rr_new(); if (!ds) { return NULL; } ldns_rr_set_type(ds, LDNS_RR_TYPE_DS); ldns_rr_set_owner(ds, ldns_rdf_clone( ldns_rr_owner(key))); ldns_rr_set_ttl(ds, ldns_rr_ttl(key)); ldns_rr_set_class(ds, ldns_rr_get_class(key)); switch(h) { default: case LDNS_SHA1: digest = LDNS_XMALLOC(uint8_t, LDNS_SHA1_DIGEST_LENGTH); if (!digest) { ldns_rr_free(ds); return NULL; } break; case LDNS_SHA256: digest = LDNS_XMALLOC(uint8_t, LDNS_SHA256_DIGEST_LENGTH); if (!digest) { ldns_rr_free(ds); return NULL; } break; case LDNS_HASH_GOST: #ifdef USE_GOST (void)ldns_key_EVP_load_gost_id(); md = EVP_get_digestbyname("md_gost94"); if(!md) { ldns_rr_free(ds); return NULL; } digest = LDNS_XMALLOC(uint8_t, EVP_MD_size(md)); if (!digest) { ldns_rr_free(ds); return NULL; } break; #else /* not implemented */ ldns_rr_free(ds); return NULL; #endif case LDNS_SHA384: #ifdef USE_ECDSA digest = LDNS_XMALLOC(uint8_t, SHA384_DIGEST_LENGTH); if (!digest) { ldns_rr_free(ds); return NULL; } break; #else /* not implemented */ ldns_rr_free(ds); return NULL; #endif } data_buf = ldns_buffer_new(LDNS_MAX_PACKETLEN); if (!data_buf) { LDNS_FREE(digest); ldns_rr_free(ds); return NULL; } /* keytag */ keytag = htons(ldns_calc_keytag((ldns_rr*)key)); tmp = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_INT16, sizeof(uint16_t), &keytag); ldns_rr_push_rdf(ds, tmp); /* copy the algorithm field */ if ((tmp = ldns_rr_rdf(key, 2)) == NULL) { LDNS_FREE(digest); ldns_buffer_free(data_buf); ldns_rr_free(ds); return NULL; } else { ldns_rr_push_rdf(ds, ldns_rdf_clone( tmp )); } /* digest hash type */ sha1hash = (uint8_t)h; tmp = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_INT8, sizeof(uint8_t), &sha1hash); ldns_rr_push_rdf(ds, tmp); /* digest */ /* owner name */ tmp = ldns_rdf_clone(ldns_rr_owner(key)); ldns_dname2canonical(tmp); if (ldns_rdf2buffer_wire(data_buf, tmp) != LDNS_STATUS_OK) { LDNS_FREE(digest); ldns_buffer_free(data_buf); ldns_rr_free(ds); ldns_rdf_deep_free(tmp); return NULL; } ldns_rdf_deep_free(tmp); /* all the rdata's */ if (ldns_rr_rdata2buffer_wire(data_buf, (ldns_rr*)key) != LDNS_STATUS_OK) { LDNS_FREE(digest); ldns_buffer_free(data_buf); ldns_rr_free(ds); return NULL; } switch(h) { case LDNS_SHA1: (void) ldns_sha1((unsigned char *) ldns_buffer_begin(data_buf), (unsigned int) ldns_buffer_position(data_buf), (unsigned char *) digest); tmp = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_HEX, LDNS_SHA1_DIGEST_LENGTH, digest); ldns_rr_push_rdf(ds, tmp); break; case LDNS_SHA256: (void) ldns_sha256((unsigned char *) ldns_buffer_begin(data_buf), (unsigned int) ldns_buffer_position(data_buf), (unsigned char *) digest); tmp = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_HEX, LDNS_SHA256_DIGEST_LENGTH, digest); ldns_rr_push_rdf(ds, tmp); break; case LDNS_HASH_GOST: #ifdef USE_GOST if(!ldns_digest_evp((unsigned char *) ldns_buffer_begin(data_buf), (unsigned int) ldns_buffer_position(data_buf), (unsigned char *) digest, md)) { LDNS_FREE(digest); ldns_buffer_free(data_buf); ldns_rr_free(ds); return NULL; } tmp = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_HEX, (size_t)EVP_MD_size(md), digest); ldns_rr_push_rdf(ds, tmp); #endif break; case LDNS_SHA384: #ifdef USE_ECDSA (void) SHA384((unsigned char *) ldns_buffer_begin(data_buf), (unsigned int) ldns_buffer_position(data_buf), (unsigned char *) digest); tmp = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_HEX, SHA384_DIGEST_LENGTH, digest); ldns_rr_push_rdf(ds, tmp); #endif break; } LDNS_FREE(digest); ldns_buffer_free(data_buf); return ds; } /* From RFC3845: * * 2.1.2. The List of Type Bit Map(s) Field * * The RR type space is split into 256 window blocks, each representing * the low-order 8 bits of the 16-bit RR type space. Each block that * has at least one active RR type is encoded using a single octet * window number (from 0 to 255), a single octet bitmap length (from 1 * to 32) indicating the number of octets used for the window block's * bitmap, and up to 32 octets (256 bits) of bitmap. * * Window blocks are present in the NSEC RR RDATA in increasing * numerical order. * * "|" denotes concatenation * * Type Bit Map(s) Field = ( Window Block # | Bitmap Length | Bitmap ) + * * * * Blocks with no types present MUST NOT be included. Trailing zero * octets in the bitmap MUST be omitted. The length of each block's * bitmap is determined by the type code with the largest numerical * value within that block, among the set of RR types present at the * NSEC RR's owner name. Trailing zero octets not specified MUST be * interpreted as zero octets. */ ldns_rdf * ldns_dnssec_create_nsec_bitmap(ldns_rr_type rr_type_list[], size_t size, ldns_rr_type nsec_type) { uint8_t window; /* most significant octet of type */ uint8_t subtype; /* least significant octet of type */ uint16_t windows[256] /* Max subtype per window */ #ifndef S_SPLINT_S = { 0 } /* Initialize ALL elements with 0 */ #endif ; ldns_rr_type* d; /* used to traverse rr_type_list*/ size_t i; /* used to traverse windows array */ size_t sz; /* size needed for type bitmap rdf */ uint8_t* data = NULL; /* rdf data */ uint8_t* dptr; /* used to itraverse rdf data */ ldns_rdf* rdf; /* bitmap rdf to return */ if (nsec_type != LDNS_RR_TYPE_NSEC && nsec_type != LDNS_RR_TYPE_NSEC3) { return NULL; } /* Which other windows need to be in the bitmap rdf? */ for (d = rr_type_list; d < rr_type_list + size; d++) { window = *d >> 8; subtype = *d & 0xff; if (windows[window] < subtype) { windows[window] = subtype; } } /* How much space do we need in the rdf for those windows? */ sz = 0; for (i = 0; i < 256; i++) { if (windows[i]) { sz += windows[i] / 8 + 3; } } if (sz > 0) { /* Format rdf data according RFC3845 Section 2.1.2 (see above) */ dptr = data = LDNS_CALLOC(uint8_t, sz); if (!data) { return NULL; } for (i = 0; i < 256; i++) { if (windows[i]) { *dptr++ = (uint8_t)i; *dptr++ = (uint8_t)(windows[i] / 8 + 1); /* Now let windows[i] index the bitmap * within data */ windows[i] = (uint16_t)(dptr - data); dptr += dptr[-1]; } } } /* Set the bits? */ for (d = rr_type_list; d < rr_type_list + size; d++) { subtype = *d & 0xff; data[windows[*d >> 8] + subtype/8] |= (0x80 >> (subtype % 8)); } /* Allocate and return rdf structure for the data */ rdf = ldns_rdf_new(LDNS_RDF_TYPE_BITMAP, sz, data); if (!rdf) { LDNS_FREE(data); return NULL; } return rdf; } int ldns_dnssec_rrsets_contains_type(ldns_dnssec_rrsets *rrsets, ldns_rr_type type) { ldns_dnssec_rrsets *cur_rrset = rrsets; while (cur_rrset) { if (cur_rrset->type == type) { return 1; } cur_rrset = cur_rrset->next; } return 0; } ldns_rr * ldns_dnssec_create_nsec(ldns_dnssec_name *from, ldns_dnssec_name *to, ldns_rr_type nsec_type) { ldns_rr *nsec_rr; ldns_rr_type types[65536]; size_t type_count = 0; ldns_dnssec_rrsets *cur_rrsets; int on_delegation_point; if (!from || !to || (nsec_type != LDNS_RR_TYPE_NSEC)) { return NULL; } nsec_rr = ldns_rr_new(); ldns_rr_set_type(nsec_rr, nsec_type); ldns_rr_set_owner(nsec_rr, ldns_rdf_clone(ldns_dnssec_name_name(from))); ldns_rr_push_rdf(nsec_rr, ldns_rdf_clone(ldns_dnssec_name_name(to))); on_delegation_point = ldns_dnssec_rrsets_contains_type( from->rrsets, LDNS_RR_TYPE_NS) && !ldns_dnssec_rrsets_contains_type( from->rrsets, LDNS_RR_TYPE_SOA); cur_rrsets = from->rrsets; while (cur_rrsets) { /* Do not include non-authoritative rrsets on the delegation point * in the type bitmap */ if ((on_delegation_point && ( cur_rrsets->type == LDNS_RR_TYPE_NS || cur_rrsets->type == LDNS_RR_TYPE_DS)) || (!on_delegation_point && cur_rrsets->type != LDNS_RR_TYPE_RRSIG && cur_rrsets->type != LDNS_RR_TYPE_NSEC)) { types[type_count] = cur_rrsets->type; type_count++; } cur_rrsets = cur_rrsets->next; } types[type_count] = LDNS_RR_TYPE_RRSIG; type_count++; types[type_count] = LDNS_RR_TYPE_NSEC; type_count++; ldns_rr_push_rdf(nsec_rr, ldns_dnssec_create_nsec_bitmap(types, type_count, nsec_type)); return nsec_rr; } ldns_rr * ldns_dnssec_create_nsec3(ldns_dnssec_name *from, ldns_dnssec_name *to, ldns_rdf *zone_name, uint8_t algorithm, uint8_t flags, uint16_t iterations, uint8_t salt_length, uint8_t *salt) { ldns_rr *nsec_rr; ldns_rr_type types[65536]; size_t type_count = 0; ldns_dnssec_rrsets *cur_rrsets; ldns_status status; int on_delegation_point; if (!from) { return NULL; } nsec_rr = ldns_rr_new_frm_type(LDNS_RR_TYPE_NSEC3); ldns_rr_set_owner(nsec_rr, ldns_nsec3_hash_name(ldns_dnssec_name_name(from), algorithm, iterations, salt_length, salt)); status = ldns_dname_cat(ldns_rr_owner(nsec_rr), zone_name); if(status != LDNS_STATUS_OK) { ldns_rr_free(nsec_rr); return NULL; } ldns_nsec3_add_param_rdfs(nsec_rr, algorithm, flags, iterations, salt_length, salt); on_delegation_point = ldns_dnssec_rrsets_contains_type( from->rrsets, LDNS_RR_TYPE_NS) && !ldns_dnssec_rrsets_contains_type( from->rrsets, LDNS_RR_TYPE_SOA); cur_rrsets = from->rrsets; while (cur_rrsets) { /* Do not include non-authoritative rrsets on the delegation point * in the type bitmap. Potentionally not skipping insecure * delegation should have been done earlier, in function * ldns_dnssec_zone_create_nsec3s, or even earlier in: * ldns_dnssec_zone_sign_nsec3_flg . */ if ((on_delegation_point && ( cur_rrsets->type == LDNS_RR_TYPE_NS || cur_rrsets->type == LDNS_RR_TYPE_DS)) || (!on_delegation_point && cur_rrsets->type != LDNS_RR_TYPE_RRSIG)) { types[type_count] = cur_rrsets->type; type_count++; } cur_rrsets = cur_rrsets->next; } /* always add rrsig type if this is not an unsigned * delegation */ if (type_count > 0 && !(type_count == 1 && types[0] == LDNS_RR_TYPE_NS)) { types[type_count] = LDNS_RR_TYPE_RRSIG; type_count++; } /* leave next rdata empty if they weren't precomputed yet */ if (to && to->hashed_name) { (void) ldns_rr_set_rdf(nsec_rr, ldns_rdf_clone(to->hashed_name), 4); } else { (void) ldns_rr_set_rdf(nsec_rr, NULL, 4); } ldns_rr_push_rdf(nsec_rr, ldns_dnssec_create_nsec_bitmap(types, type_count, LDNS_RR_TYPE_NSEC3)); return nsec_rr; } ldns_rr * ldns_create_nsec(ldns_rdf *cur_owner, ldns_rdf *next_owner, ldns_rr_list *rrs) { /* we do not do any check here - garbage in, garbage out */ /* the the start and end names - get the type from the * before rrlist */ /* inefficient, just give it a name, a next name, and a list of rrs */ /* we make 1 big uberbitmap first, then windows */ /* todo: make something more efficient :) */ uint16_t i; ldns_rr *i_rr; uint16_t i_type; ldns_rr *nsec = NULL; ldns_rr_type i_type_list[65536]; size_t type_count = 0; nsec = ldns_rr_new(); ldns_rr_set_type(nsec, LDNS_RR_TYPE_NSEC); ldns_rr_set_owner(nsec, ldns_rdf_clone(cur_owner)); ldns_rr_push_rdf(nsec, ldns_rdf_clone(next_owner)); for (i = 0; i < ldns_rr_list_rr_count(rrs); i++) { i_rr = ldns_rr_list_rr(rrs, i); if (ldns_rdf_compare(cur_owner, ldns_rr_owner(i_rr)) == 0) { i_type = ldns_rr_get_type(i_rr); if (i_type != LDNS_RR_TYPE_RRSIG && i_type != LDNS_RR_TYPE_NSEC) { if (type_count == 0 || i_type_list[type_count-1] != i_type) { i_type_list[type_count] = i_type; type_count++; } } } } i_type_list[type_count] = LDNS_RR_TYPE_RRSIG; type_count++; i_type_list[type_count] = LDNS_RR_TYPE_NSEC; type_count++; ldns_rr_push_rdf(nsec, ldns_dnssec_create_nsec_bitmap(i_type_list, type_count, LDNS_RR_TYPE_NSEC)); return nsec; } ldns_rdf * ldns_nsec3_hash_name(ldns_rdf *name, uint8_t algorithm, uint16_t iterations, uint8_t salt_length, uint8_t *salt) { size_t hashed_owner_str_len; ldns_rdf *cann; ldns_rdf *hashed_owner; unsigned char *hashed_owner_str; char *hashed_owner_b32; size_t hashed_owner_b32_len; uint32_t cur_it; /* define to contain the largest possible hash, which is * sha1 at the moment */ unsigned char hash[LDNS_SHA1_DIGEST_LENGTH]; ldns_status status; /* TODO: mnemonic list for hash algs SHA-1, default to 1 now (sha1) */ if (algorithm != LDNS_SHA1) { return NULL; } /* prepare the owner name according to the draft section bla */ cann = ldns_rdf_clone(name); if(!cann) { #ifdef STDERR_MSGS fprintf(stderr, "Memory error\n"); #endif return NULL; } ldns_dname2canonical(cann); hashed_owner_str_len = salt_length + ldns_rdf_size(cann); hashed_owner_str = LDNS_XMALLOC(unsigned char, hashed_owner_str_len); if(!hashed_owner_str) { ldns_rdf_deep_free(cann); return NULL; } memcpy(hashed_owner_str, ldns_rdf_data(cann), ldns_rdf_size(cann)); memcpy(hashed_owner_str + ldns_rdf_size(cann), salt, salt_length); ldns_rdf_deep_free(cann); for (cur_it = iterations + 1; cur_it > 0; cur_it--) { (void) ldns_sha1((unsigned char *) hashed_owner_str, (unsigned int) hashed_owner_str_len, hash); LDNS_FREE(hashed_owner_str); hashed_owner_str_len = salt_length + LDNS_SHA1_DIGEST_LENGTH; hashed_owner_str = LDNS_XMALLOC(unsigned char, hashed_owner_str_len); if (!hashed_owner_str) { return NULL; } memcpy(hashed_owner_str, hash, LDNS_SHA1_DIGEST_LENGTH); memcpy(hashed_owner_str + LDNS_SHA1_DIGEST_LENGTH, salt, salt_length); hashed_owner_str_len = LDNS_SHA1_DIGEST_LENGTH + salt_length; } LDNS_FREE(hashed_owner_str); hashed_owner_str = hash; hashed_owner_str_len = LDNS_SHA1_DIGEST_LENGTH; hashed_owner_b32 = LDNS_XMALLOC(char, ldns_b32_ntop_calculate_size(hashed_owner_str_len) + 1); if(!hashed_owner_b32) { return NULL; } hashed_owner_b32_len = (size_t) ldns_b32_ntop_extended_hex( (uint8_t *) hashed_owner_str, hashed_owner_str_len, hashed_owner_b32, ldns_b32_ntop_calculate_size(hashed_owner_str_len)+1); if (hashed_owner_b32_len < 1) { #ifdef STDERR_MSGS fprintf(stderr, "Error in base32 extended hex encoding "); fprintf(stderr, "of hashed owner name (name: "); ldns_rdf_print(stderr, name); fprintf(stderr, ", return code: %u)\n", (unsigned int) hashed_owner_b32_len); #endif LDNS_FREE(hashed_owner_b32); return NULL; } hashed_owner_b32[hashed_owner_b32_len] = '\0'; status = ldns_str2rdf_dname(&hashed_owner, hashed_owner_b32); if (status != LDNS_STATUS_OK) { #ifdef STDERR_MSGS fprintf(stderr, "Error creating rdf from %s\n", hashed_owner_b32); #endif LDNS_FREE(hashed_owner_b32); return NULL; } LDNS_FREE(hashed_owner_b32); return hashed_owner; } void ldns_nsec3_add_param_rdfs(ldns_rr *rr, uint8_t algorithm, uint8_t flags, uint16_t iterations, uint8_t salt_length, uint8_t *salt) { ldns_rdf *salt_rdf = NULL; uint8_t *salt_data = NULL; ldns_rdf *old; old = ldns_rr_set_rdf(rr, ldns_rdf_new_frm_data(LDNS_RDF_TYPE_INT8, 1, (void*)&algorithm), 0); if (old) ldns_rdf_deep_free(old); old = ldns_rr_set_rdf(rr, ldns_rdf_new_frm_data(LDNS_RDF_TYPE_INT8, 1, (void*)&flags), 1); if (old) ldns_rdf_deep_free(old); old = ldns_rr_set_rdf(rr, ldns_native2rdf_int16(LDNS_RDF_TYPE_INT16, iterations), 2); if (old) ldns_rdf_deep_free(old); salt_data = LDNS_XMALLOC(uint8_t, salt_length + 1); if(!salt_data) { /* no way to return error */ return; } salt_data[0] = salt_length; memcpy(salt_data + 1, salt, salt_length); salt_rdf = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_NSEC3_SALT, salt_length + 1, salt_data); if(!salt_rdf) { LDNS_FREE(salt_data); /* no way to return error */ return; } old = ldns_rr_set_rdf(rr, salt_rdf, 3); if (old) ldns_rdf_deep_free(old); LDNS_FREE(salt_data); } static int rr_list_delegation_only(ldns_rdf *origin, ldns_rr_list *rr_list) { size_t i; ldns_rr *cur_rr; if (!origin || !rr_list) return 0; for (i = 0; i < ldns_rr_list_rr_count(rr_list); i++) { cur_rr = ldns_rr_list_rr(rr_list, i); if (ldns_dname_compare(ldns_rr_owner(cur_rr), origin) == 0) { return 0; } if (ldns_rr_get_type(cur_rr) != LDNS_RR_TYPE_NS) { return 0; } } return 1; } /* this will NOT return the NSEC3 completed, you will have to run the finalize function on the rrlist later! */ ldns_rr * ldns_create_nsec3(ldns_rdf *cur_owner, ldns_rdf *cur_zone, ldns_rr_list *rrs, uint8_t algorithm, uint8_t flags, uint16_t iterations, uint8_t salt_length, uint8_t *salt, bool emptynonterminal) { size_t i; ldns_rr *i_rr; uint16_t i_type; ldns_rr *nsec = NULL; ldns_rdf *hashed_owner = NULL; ldns_status status; ldns_rr_type i_type_list[1024]; size_t type_count = 0; hashed_owner = ldns_nsec3_hash_name(cur_owner, algorithm, iterations, salt_length, salt); status = ldns_dname_cat(hashed_owner, cur_zone); if(status != LDNS_STATUS_OK) { ldns_rdf_deep_free(hashed_owner); return NULL; } nsec = ldns_rr_new_frm_type(LDNS_RR_TYPE_NSEC3); if(!nsec) { ldns_rdf_deep_free(hashed_owner); return NULL; } ldns_rr_set_type(nsec, LDNS_RR_TYPE_NSEC3); ldns_rr_set_owner(nsec, hashed_owner); ldns_nsec3_add_param_rdfs(nsec, algorithm, flags, iterations, salt_length, salt); (void) ldns_rr_set_rdf(nsec, NULL, 4); for (i = 0; i < ldns_rr_list_rr_count(rrs); i++) { i_rr = ldns_rr_list_rr(rrs, i); if (ldns_rdf_compare(cur_owner, ldns_rr_owner(i_rr)) == 0) { i_type = ldns_rr_get_type(i_rr); if (type_count == 0 || i_type_list[type_count-1] != i_type) { i_type_list[type_count] = i_type; type_count++; } } } /* add RRSIG anyway, but only if this is not an ENT or * an unsigned delegation */ if (!emptynonterminal && !rr_list_delegation_only(cur_zone, rrs)) { i_type_list[type_count] = LDNS_RR_TYPE_RRSIG; type_count++; } /* and SOA if owner == zone */ if (ldns_dname_compare(cur_zone, cur_owner) == 0) { i_type_list[type_count] = LDNS_RR_TYPE_SOA; type_count++; } ldns_rr_push_rdf(nsec, ldns_dnssec_create_nsec_bitmap(i_type_list, type_count, LDNS_RR_TYPE_NSEC3)); return nsec; } uint8_t ldns_nsec3_algorithm(const ldns_rr *nsec3_rr) { if (nsec3_rr && (ldns_rr_get_type(nsec3_rr) == LDNS_RR_TYPE_NSEC3 || ldns_rr_get_type(nsec3_rr) == LDNS_RR_TYPE_NSEC3PARAM) && (ldns_rr_rdf(nsec3_rr, 0) != NULL) && ldns_rdf_size(ldns_rr_rdf(nsec3_rr, 0)) > 0) { return ldns_rdf2native_int8(ldns_rr_rdf(nsec3_rr, 0)); } return 0; } uint8_t ldns_nsec3_flags(const ldns_rr *nsec3_rr) { if (nsec3_rr && (ldns_rr_get_type(nsec3_rr) == LDNS_RR_TYPE_NSEC3 || ldns_rr_get_type(nsec3_rr) == LDNS_RR_TYPE_NSEC3PARAM) && (ldns_rr_rdf(nsec3_rr, 1) != NULL) && ldns_rdf_size(ldns_rr_rdf(nsec3_rr, 1)) > 0) { return ldns_rdf2native_int8(ldns_rr_rdf(nsec3_rr, 1)); } return 0; } bool ldns_nsec3_optout(const ldns_rr *nsec3_rr) { return (ldns_nsec3_flags(nsec3_rr) & LDNS_NSEC3_VARS_OPTOUT_MASK); } uint16_t ldns_nsec3_iterations(const ldns_rr *nsec3_rr) { if (nsec3_rr && (ldns_rr_get_type(nsec3_rr) == LDNS_RR_TYPE_NSEC3 || ldns_rr_get_type(nsec3_rr) == LDNS_RR_TYPE_NSEC3PARAM) && (ldns_rr_rdf(nsec3_rr, 2) != NULL) && ldns_rdf_size(ldns_rr_rdf(nsec3_rr, 2)) > 0) { return ldns_rdf2native_int16(ldns_rr_rdf(nsec3_rr, 2)); } return 0; } ldns_rdf * ldns_nsec3_salt(const ldns_rr *nsec3_rr) { if (nsec3_rr && (ldns_rr_get_type(nsec3_rr) == LDNS_RR_TYPE_NSEC3 || ldns_rr_get_type(nsec3_rr) == LDNS_RR_TYPE_NSEC3PARAM) ) { return ldns_rr_rdf(nsec3_rr, 3); } return NULL; } uint8_t ldns_nsec3_salt_length(const ldns_rr *nsec3_rr) { ldns_rdf *salt_rdf = ldns_nsec3_salt(nsec3_rr); if (salt_rdf && ldns_rdf_size(salt_rdf) > 0) { return (uint8_t) ldns_rdf_data(salt_rdf)[0]; } return 0; } /* allocs data, free with LDNS_FREE() */ uint8_t * ldns_nsec3_salt_data(const ldns_rr *nsec3_rr) { uint8_t salt_length; uint8_t *salt; ldns_rdf *salt_rdf = ldns_nsec3_salt(nsec3_rr); if (salt_rdf && ldns_rdf_size(salt_rdf) > 0) { salt_length = ldns_rdf_data(salt_rdf)[0]; salt = LDNS_XMALLOC(uint8_t, salt_length); if(!salt) return NULL; memcpy(salt, &ldns_rdf_data(salt_rdf)[1], salt_length); return salt; } return NULL; } ldns_rdf * ldns_nsec3_next_owner(const ldns_rr *nsec3_rr) { if (!nsec3_rr || ldns_rr_get_type(nsec3_rr) != LDNS_RR_TYPE_NSEC3) { return NULL; } else { return ldns_rr_rdf(nsec3_rr, 4); } } ldns_rdf * ldns_nsec3_bitmap(const ldns_rr *nsec3_rr) { if (!nsec3_rr || ldns_rr_get_type(nsec3_rr) != LDNS_RR_TYPE_NSEC3) { return NULL; } else { return ldns_rr_rdf(nsec3_rr, 5); } } ldns_rdf * ldns_nsec3_hash_name_frm_nsec3(const ldns_rr *nsec, ldns_rdf *name) { uint8_t algorithm; uint16_t iterations; uint8_t salt_length; uint8_t *salt = 0; ldns_rdf *hashed_owner; algorithm = ldns_nsec3_algorithm(nsec); salt_length = ldns_nsec3_salt_length(nsec); salt = ldns_nsec3_salt_data(nsec); iterations = ldns_nsec3_iterations(nsec); hashed_owner = ldns_nsec3_hash_name(name, algorithm, iterations, salt_length, salt); LDNS_FREE(salt); return hashed_owner; } bool ldns_nsec_bitmap_covers_type(const ldns_rdf* bitmap, ldns_rr_type type) { uint8_t* dptr; uint8_t* dend; /* From RFC3845 Section 2.1.2: * * "The RR type space is split into 256 window blocks, each re- * presenting the low-order 8 bits of the 16-bit RR type space." */ uint8_t window = type >> 8; uint8_t subtype = type & 0xff; if (! bitmap) { return false; } assert(ldns_rdf_get_type(bitmap) == LDNS_RDF_TYPE_BITMAP); dptr = ldns_rdf_data(bitmap); dend = ldns_rdf_data(bitmap) + ldns_rdf_size(bitmap); /* Type Bitmap = ( Window Block # | Bitmap Length | Bitmap ) + * dptr[0] dptr[1] dptr[2:] */ while (dptr < dend && dptr[0] <= window) { if (dptr[0] == window && subtype / 8 < dptr[1] && dptr + dptr[1] + 2 <= dend) { return dptr[2 + subtype / 8] & (0x80 >> (subtype % 8)); } dptr += dptr[1] + 2; /* next window */ } return false; } ldns_status ldns_nsec_bitmap_set_type(ldns_rdf* bitmap, ldns_rr_type type) { uint8_t* dptr; uint8_t* dend; /* From RFC3845 Section 2.1.2: * * "The RR type space is split into 256 window blocks, each re- * presenting the low-order 8 bits of the 16-bit RR type space." */ uint8_t window = type >> 8; uint8_t subtype = type & 0xff; if (! bitmap) { return false; } assert(ldns_rdf_get_type(bitmap) == LDNS_RDF_TYPE_BITMAP); dptr = ldns_rdf_data(bitmap); dend = ldns_rdf_data(bitmap) + ldns_rdf_size(bitmap); /* Type Bitmap = ( Window Block # | Bitmap Length | Bitmap ) + * dptr[0] dptr[1] dptr[2:] */ while (dptr < dend && dptr[0] <= window) { if (dptr[0] == window && subtype / 8 < dptr[1] && dptr + dptr[1] + 2 <= dend) { dptr[2 + subtype / 8] |= (0x80 >> (subtype % 8)); return LDNS_STATUS_OK; } dptr += dptr[1] + 2; /* next window */ } return LDNS_STATUS_TYPE_NOT_IN_BITMAP; } ldns_status ldns_nsec_bitmap_clear_type(ldns_rdf* bitmap, ldns_rr_type type) { uint8_t* dptr; uint8_t* dend; /* From RFC3845 Section 2.1.2: * * "The RR type space is split into 256 window blocks, each re- * presenting the low-order 8 bits of the 16-bit RR type space." */ uint8_t window = type >> 8; uint8_t subtype = type & 0xff; if (! bitmap) { return false; } assert(ldns_rdf_get_type(bitmap) == LDNS_RDF_TYPE_BITMAP); dptr = ldns_rdf_data(bitmap); dend = ldns_rdf_data(bitmap) + ldns_rdf_size(bitmap); /* Type Bitmap = ( Window Block # | Bitmap Length | Bitmap ) + * dptr[0] dptr[1] dptr[2:] */ while (dptr < dend && dptr[0] <= window) { if (dptr[0] == window && subtype / 8 < dptr[1] && dptr + dptr[1] + 2 <= dend) { dptr[2 + subtype / 8] &= ~(0x80 >> (subtype % 8)); return LDNS_STATUS_OK; } dptr += dptr[1] + 2; /* next window */ } return LDNS_STATUS_TYPE_NOT_IN_BITMAP; } bool ldns_nsec_covers_name(const ldns_rr *nsec, const ldns_rdf *name) { ldns_rdf *nsec_owner = ldns_rr_owner(nsec); ldns_rdf *hash_next; char *next_hash_str; ldns_rdf *nsec_next = NULL; ldns_status status; ldns_rdf *chopped_dname; bool result; if (ldns_rr_get_type(nsec) == LDNS_RR_TYPE_NSEC) { if (ldns_rr_rdf(nsec, 0) != NULL) { nsec_next = ldns_rdf_clone(ldns_rr_rdf(nsec, 0)); } else { return false; } } else if (ldns_rr_get_type(nsec) == LDNS_RR_TYPE_NSEC3) { hash_next = ldns_nsec3_next_owner(nsec); next_hash_str = ldns_rdf2str(hash_next); nsec_next = ldns_dname_new_frm_str(next_hash_str); LDNS_FREE(next_hash_str); chopped_dname = ldns_dname_left_chop(nsec_owner); status = ldns_dname_cat(nsec_next, chopped_dname); ldns_rdf_deep_free(chopped_dname); if (status != LDNS_STATUS_OK) { printf("error catting: %s\n", ldns_get_errorstr_by_id(status)); } } else { ldns_rdf_deep_free(nsec_next); return false; } /* in the case of the last nsec */ if(ldns_dname_compare(nsec_owner, nsec_next) > 0) { result = (ldns_dname_compare(nsec_owner, name) <= 0 || ldns_dname_compare(name, nsec_next) < 0); } else if(ldns_dname_compare(nsec_owner, nsec_next) < 0) { result = (ldns_dname_compare(nsec_owner, name) <= 0 && ldns_dname_compare(name, nsec_next) < 0); } else { result = true; } ldns_rdf_deep_free(nsec_next); return result; } #ifdef HAVE_SSL /* sig may be null - if so look in the packet */ ldns_status ldns_pkt_verify_time(ldns_pkt *p, ldns_rr_type t, ldns_rdf *o, ldns_rr_list *k, ldns_rr_list *s, time_t check_time, ldns_rr_list *good_keys) { ldns_rr_list *rrset; ldns_rr_list *sigs; ldns_rr_list *sigs_covered; ldns_rdf *rdf_t; ldns_rr_type t_netorder; if (!k) { return LDNS_STATUS_ERR; /* return LDNS_STATUS_CRYPTO_NO_DNSKEY; */ } if (t == LDNS_RR_TYPE_RRSIG) { /* we don't have RRSIG(RRSIG) (yet? ;-) ) */ return LDNS_STATUS_ERR; } if (s) { /* if s is not NULL, the sigs are given to use */ sigs = s; } else { /* otherwise get them from the packet */ sigs = ldns_pkt_rr_list_by_name_and_type(p, o, LDNS_RR_TYPE_RRSIG, LDNS_SECTION_ANY_NOQUESTION); if (!sigs) { /* no sigs */ return LDNS_STATUS_ERR; /* return LDNS_STATUS_CRYPTO_NO_RRSIG; */ } } /* rrsig are subtyped, so now we need to find the correct * sigs for the type t */ t_netorder = htons(t); /* rdf are in network order! */ /* a type identifier is a 16-bit number, so the size is 2 bytes */ rdf_t = ldns_rdf_new(LDNS_RDF_TYPE_TYPE, 2, &t_netorder); sigs_covered = ldns_rr_list_subtype_by_rdf(sigs, rdf_t, 0); ldns_rdf_free(rdf_t); if (! sigs_covered) { if (! s) { ldns_rr_list_deep_free(sigs); } return LDNS_STATUS_ERR; } ldns_rr_list_deep_free(sigs_covered); rrset = ldns_pkt_rr_list_by_name_and_type(p, o, t, LDNS_SECTION_ANY_NOQUESTION); if (!rrset) { if (! s) { ldns_rr_list_deep_free(sigs); } return LDNS_STATUS_ERR; } return ldns_verify_time(rrset, sigs, k, check_time, good_keys); } ldns_status ldns_pkt_verify(ldns_pkt *p, ldns_rr_type t, ldns_rdf *o, ldns_rr_list *k, ldns_rr_list *s, ldns_rr_list *good_keys) { return ldns_pkt_verify_time(p, t, o, k, s, ldns_time(NULL), good_keys); } #endif /* HAVE_SSL */ ldns_status ldns_dnssec_chain_nsec3_list(ldns_rr_list *nsec3_rrs) { size_t i; char *next_nsec_owner_str; ldns_rdf *next_nsec_owner_label; ldns_rdf *next_nsec_rdf; ldns_status status = LDNS_STATUS_OK; for (i = 0; i < ldns_rr_list_rr_count(nsec3_rrs); i++) { if (i == ldns_rr_list_rr_count(nsec3_rrs) - 1) { next_nsec_owner_label = ldns_dname_label(ldns_rr_owner(ldns_rr_list_rr(nsec3_rrs, 0)), 0); next_nsec_owner_str = ldns_rdf2str(next_nsec_owner_label); if (next_nsec_owner_str[strlen(next_nsec_owner_str) - 1] == '.') { next_nsec_owner_str[strlen(next_nsec_owner_str) - 1] = '\0'; } status = ldns_str2rdf_b32_ext(&next_nsec_rdf, next_nsec_owner_str); if (!ldns_rr_set_rdf(ldns_rr_list_rr(nsec3_rrs, i), next_nsec_rdf, 4)) { /* todo: error */ } ldns_rdf_deep_free(next_nsec_owner_label); LDNS_FREE(next_nsec_owner_str); } else { next_nsec_owner_label = ldns_dname_label(ldns_rr_owner(ldns_rr_list_rr(nsec3_rrs, i + 1)), 0); next_nsec_owner_str = ldns_rdf2str(next_nsec_owner_label); if (next_nsec_owner_str[strlen(next_nsec_owner_str) - 1] == '.') { next_nsec_owner_str[strlen(next_nsec_owner_str) - 1] = '\0'; } status = ldns_str2rdf_b32_ext(&next_nsec_rdf, next_nsec_owner_str); ldns_rdf_deep_free(next_nsec_owner_label); LDNS_FREE(next_nsec_owner_str); if (!ldns_rr_set_rdf(ldns_rr_list_rr(nsec3_rrs, i), next_nsec_rdf, 4)) { /* todo: error */ } } } return status; } int qsort_rr_compare_nsec3(const void *a, const void *b) { const ldns_rr *rr1 = * (const ldns_rr **) a; const ldns_rr *rr2 = * (const ldns_rr **) b; if (rr1 == NULL && rr2 == NULL) { return 0; } if (rr1 == NULL) { return -1; } if (rr2 == NULL) { return 1; } return ldns_rdf_compare(ldns_rr_owner(rr1), ldns_rr_owner(rr2)); } void ldns_rr_list_sort_nsec3(ldns_rr_list *unsorted) { qsort(unsorted->_rrs, ldns_rr_list_rr_count(unsorted), sizeof(ldns_rr *), qsort_rr_compare_nsec3); } int ldns_dnssec_default_add_to_signatures( ATTR_UNUSED(ldns_rr *sig) , ATTR_UNUSED(void *n) ) { return LDNS_SIGNATURE_LEAVE_ADD_NEW; } int ldns_dnssec_default_leave_signatures( ATTR_UNUSED(ldns_rr *sig) , ATTR_UNUSED(void *n) ) { return LDNS_SIGNATURE_LEAVE_NO_ADD; } int ldns_dnssec_default_delete_signatures( ATTR_UNUSED(ldns_rr *sig) , ATTR_UNUSED(void *n) ) { return LDNS_SIGNATURE_REMOVE_NO_ADD; } int ldns_dnssec_default_replace_signatures( ATTR_UNUSED(ldns_rr *sig) , ATTR_UNUSED(void *n) ) { return LDNS_SIGNATURE_REMOVE_ADD_NEW; } #ifdef HAVE_SSL ldns_rdf * ldns_convert_dsa_rrsig_asn12rdf(const ldns_buffer *sig, const long sig_len) { ldns_rdf *sigdata_rdf; DSA_SIG *dsasig; unsigned char *dsasig_data = (unsigned char*)ldns_buffer_begin(sig); size_t byte_offset; dsasig = d2i_DSA_SIG(NULL, (const unsigned char **)&dsasig_data, sig_len); if (!dsasig) { DSA_SIG_free(dsasig); return NULL; } dsasig_data = LDNS_XMALLOC(unsigned char, 41); if(!dsasig_data) { DSA_SIG_free(dsasig); return NULL; } dsasig_data[0] = 0; byte_offset = (size_t) (20 - BN_num_bytes(dsasig->r)); if (byte_offset > 20) { DSA_SIG_free(dsasig); LDNS_FREE(dsasig_data); return NULL; } memset(&dsasig_data[1], 0, byte_offset); BN_bn2bin(dsasig->r, &dsasig_data[1 + byte_offset]); byte_offset = (size_t) (20 - BN_num_bytes(dsasig->s)); if (byte_offset > 20) { DSA_SIG_free(dsasig); LDNS_FREE(dsasig_data); return NULL; } memset(&dsasig_data[21], 0, byte_offset); BN_bn2bin(dsasig->s, &dsasig_data[21 + byte_offset]); sigdata_rdf = ldns_rdf_new(LDNS_RDF_TYPE_B64, 41, dsasig_data); if(!sigdata_rdf) { LDNS_FREE(dsasig_data); } DSA_SIG_free(dsasig); return sigdata_rdf; } ldns_status ldns_convert_dsa_rrsig_rdf2asn1(ldns_buffer *target_buffer, const ldns_rdf *sig_rdf) { /* the EVP api wants the DER encoding of the signature... */ BIGNUM *R, *S; DSA_SIG *dsasig; unsigned char *raw_sig = NULL; int raw_sig_len; if(ldns_rdf_size(sig_rdf) < 1 + 2*SHA_DIGEST_LENGTH) return LDNS_STATUS_SYNTAX_RDATA_ERR; /* extract the R and S field from the sig buffer */ R = BN_new(); if(!R) return LDNS_STATUS_MEM_ERR; (void) BN_bin2bn((unsigned char *) ldns_rdf_data(sig_rdf) + 1, SHA_DIGEST_LENGTH, R); S = BN_new(); if(!S) { BN_free(R); return LDNS_STATUS_MEM_ERR; } (void) BN_bin2bn((unsigned char *) ldns_rdf_data(sig_rdf) + 21, SHA_DIGEST_LENGTH, S); dsasig = DSA_SIG_new(); if (!dsasig) { BN_free(R); BN_free(S); return LDNS_STATUS_MEM_ERR; } dsasig->r = R; dsasig->s = S; raw_sig_len = i2d_DSA_SIG(dsasig, &raw_sig); if (raw_sig_len < 0) { DSA_SIG_free(dsasig); free(raw_sig); return LDNS_STATUS_SSL_ERR; } if (ldns_buffer_reserve(target_buffer, (size_t) raw_sig_len)) { ldns_buffer_write(target_buffer, raw_sig, (size_t)raw_sig_len); } DSA_SIG_free(dsasig); free(raw_sig); return ldns_buffer_status(target_buffer); } #ifdef USE_ECDSA #ifndef S_SPLINT_S ldns_rdf * ldns_convert_ecdsa_rrsig_asn12rdf(const ldns_buffer *sig, const long sig_len) { ECDSA_SIG* ecdsa_sig; unsigned char *data = (unsigned char*)ldns_buffer_begin(sig); ldns_rdf* rdf; ecdsa_sig = d2i_ECDSA_SIG(NULL, (const unsigned char **)&data, sig_len); if(!ecdsa_sig) return NULL; /* "r | s". */ data = LDNS_XMALLOC(unsigned char, BN_num_bytes(ecdsa_sig->r) + BN_num_bytes(ecdsa_sig->s)); if(!data) { ECDSA_SIG_free(ecdsa_sig); return NULL; } BN_bn2bin(ecdsa_sig->r, data); BN_bn2bin(ecdsa_sig->s, data+BN_num_bytes(ecdsa_sig->r)); rdf = ldns_rdf_new(LDNS_RDF_TYPE_B64, (size_t)( BN_num_bytes(ecdsa_sig->r) + BN_num_bytes(ecdsa_sig->s)), data); ECDSA_SIG_free(ecdsa_sig); return rdf; } ldns_status ldns_convert_ecdsa_rrsig_rdf2asn1(ldns_buffer *target_buffer, const ldns_rdf *sig_rdf) { ECDSA_SIG* sig; int raw_sig_len; long bnsize = (long)ldns_rdf_size(sig_rdf) / 2; /* if too short, or not even length, do not bother */ if(bnsize < 16 || (size_t)bnsize*2 != ldns_rdf_size(sig_rdf)) return LDNS_STATUS_ERR; /* use the raw data to parse two evenly long BIGNUMs, "r | s". */ sig = ECDSA_SIG_new(); if(!sig) return LDNS_STATUS_MEM_ERR; sig->r = BN_bin2bn((const unsigned char*)ldns_rdf_data(sig_rdf), bnsize, sig->r); sig->s = BN_bin2bn((const unsigned char*)ldns_rdf_data(sig_rdf)+bnsize, bnsize, sig->s); if(!sig->r || !sig->s) { ECDSA_SIG_free(sig); return LDNS_STATUS_MEM_ERR; } raw_sig_len = i2d_ECDSA_SIG(sig, NULL); if (ldns_buffer_reserve(target_buffer, (size_t) raw_sig_len)) { unsigned char* pp = (unsigned char*) ldns_buffer_current(target_buffer); raw_sig_len = i2d_ECDSA_SIG(sig, &pp); ldns_buffer_skip(target_buffer, (ssize_t) raw_sig_len); } ECDSA_SIG_free(sig); return ldns_buffer_status(target_buffer); } #endif /* S_SPLINT_S */ #endif /* USE_ECDSA */ #endif /* HAVE_SSL */ ldns-1.6.17/higher.c0000664000175100017510000001672112264060151013534 0ustar willemwillem/* * higher.c * * Specify some higher level functions that would * be usefull to would be developers * * a Net::DNS like library for C * * (c) NLnet Labs, 2004-2006 * * See the file LICENSE for the license */ #include #include #ifdef HAVE_SSL #include #include #endif /* HAVE_SSL */ ldns_rr_list * ldns_get_rr_list_addr_by_name(ldns_resolver *res, ldns_rdf *name, ldns_rr_class c, uint16_t flags) { ldns_pkt *pkt; ldns_rr_list *aaaa; ldns_rr_list *a; ldns_rr_list *result = NULL; ldns_rr_list *hostsfilenames; size_t i; uint8_t ip6; a = NULL; aaaa = NULL; result = NULL; if (!res) { return NULL; } if (ldns_rdf_get_type(name) != LDNS_RDF_TYPE_DNAME) { return NULL; } ip6 = ldns_resolver_ip6(res); /* we use INET_ANY here, save what was there */ ldns_resolver_set_ip6(res, LDNS_RESOLV_INETANY); hostsfilenames = ldns_get_rr_list_hosts_frm_file(NULL); for (i = 0; i < ldns_rr_list_rr_count(hostsfilenames); i++) { if (ldns_rdf_compare(name, ldns_rr_owner(ldns_rr_list_rr(hostsfilenames, i))) == 0) { if (!result) { result = ldns_rr_list_new(); } ldns_rr_list_push_rr(result, ldns_rr_clone(ldns_rr_list_rr(hostsfilenames, i))); } } ldns_rr_list_deep_free(hostsfilenames); if (result) { return result; } /* add the RD flags, because we want an answer */ pkt = ldns_resolver_query(res, name, LDNS_RR_TYPE_AAAA, c, flags | LDNS_RD); if (pkt) { /* extract the data we need */ aaaa = ldns_pkt_rr_list_by_type(pkt, LDNS_RR_TYPE_AAAA, LDNS_SECTION_ANSWER); ldns_pkt_free(pkt); } pkt = ldns_resolver_query(res, name, LDNS_RR_TYPE_A, c, flags | LDNS_RD); if (pkt) { /* extract the data we need */ a = ldns_pkt_rr_list_by_type(pkt, LDNS_RR_TYPE_A, LDNS_SECTION_ANSWER); ldns_pkt_free(pkt); } ldns_resolver_set_ip6(res, ip6); if (aaaa && a) { result = ldns_rr_list_cat_clone(aaaa, a); ldns_rr_list_deep_free(aaaa); ldns_rr_list_deep_free(a); return result; } if (aaaa) { result = ldns_rr_list_clone(aaaa); } if (a) { result = ldns_rr_list_clone(a); } ldns_rr_list_deep_free(aaaa); ldns_rr_list_deep_free(a); return result; } ldns_rr_list * ldns_get_rr_list_name_by_addr(ldns_resolver *res, ldns_rdf *addr, ldns_rr_class c, uint16_t flags) { ldns_pkt *pkt; ldns_rr_list *names; ldns_rdf *name; names = NULL; if (!res || !addr) { return NULL; } if (ldns_rdf_get_type(addr) != LDNS_RDF_TYPE_A && ldns_rdf_get_type(addr) != LDNS_RDF_TYPE_AAAA) { return NULL; } name = ldns_rdf_address_reverse(addr); /* add the RD flags, because we want an answer */ pkt = ldns_resolver_query(res, name, LDNS_RR_TYPE_PTR, c, flags | LDNS_RD); ldns_rdf_deep_free(name); if (pkt) { /* extract the data we need */ names = ldns_pkt_rr_list_by_type(pkt, LDNS_RR_TYPE_PTR, LDNS_SECTION_ANSWER); ldns_pkt_free(pkt); } return names; } /* read a line, put it in a buffer, parse the buffer */ ldns_rr_list * ldns_get_rr_list_hosts_frm_fp(FILE *fp) { return ldns_get_rr_list_hosts_frm_fp_l(fp, NULL); } ldns_rr_list * ldns_get_rr_list_hosts_frm_fp_l(FILE *fp, int *line_nr) { ssize_t i, j; size_t cnt; char *line; char *word; char *addr; char *rr_str; ldns_buffer *linebuf; ldns_rr *rr; ldns_rr_list *list; ldns_rdf *tmp; bool ip6; ldns_status parse_result; line = LDNS_XMALLOC(char, LDNS_MAX_LINELEN + 1); word = LDNS_XMALLOC(char, LDNS_MAX_LINELEN + 1); addr = LDNS_XMALLOC(char, LDNS_MAX_LINELEN + 1); rr_str = LDNS_XMALLOC(char, LDNS_MAX_LINELEN + 1); ip6 = false; list = ldns_rr_list_new(); rr = NULL; if(!line || !word || !addr || !rr_str || !list) { LDNS_FREE(line); LDNS_FREE(word); LDNS_FREE(addr); LDNS_FREE(rr_str); ldns_rr_list_free(list); return NULL; } for(i = ldns_fget_token_l(fp, line, "\n", LDNS_MAX_LINELEN, line_nr); i > 0; i = ldns_fget_token_l(fp, line, "\n", LDNS_MAX_LINELEN, line_nr)) { /* # is comment */ if (line[0] == '#') { continue; } /* put it in a buffer for further processing */ linebuf = LDNS_MALLOC(ldns_buffer); if(!linebuf) { LDNS_FREE(line); LDNS_FREE(word); LDNS_FREE(addr); LDNS_FREE(rr_str); ldns_rr_list_deep_free(list); return NULL; } ldns_buffer_new_frm_data(linebuf, line, (size_t) i); for(cnt = 0, j = ldns_bget_token(linebuf, word, LDNS_PARSE_NO_NL, LDNS_MAX_LINELEN); j > 0; j = ldns_bget_token(linebuf, word, LDNS_PARSE_NO_NL, LDNS_MAX_LINELEN), cnt++) { if (cnt == 0) { /* the address */ if ((tmp = ldns_rdf_new_frm_str(LDNS_RDF_TYPE_AAAA, word))) { /* ip6 */ ldns_rdf_deep_free(tmp); ip6 = true; } else { if ((tmp = ldns_rdf_new_frm_str(LDNS_RDF_TYPE_A, word))) { /* ip4 */ ldns_rdf_deep_free(tmp); ip6 = false; } else { /* kaput */ break; } } (void)strlcpy(addr, word, LDNS_MAX_LINELEN+1); } else { /* la al la la */ if (ip6) { snprintf(rr_str, LDNS_MAX_LINELEN, "%s IN AAAA %s", word, addr); } else { snprintf(rr_str, LDNS_MAX_LINELEN, "%s IN A %s", word, addr); } parse_result = ldns_rr_new_frm_str(&rr, rr_str, 0, NULL, NULL); if (parse_result == LDNS_STATUS_OK && ldns_rr_owner(rr) && ldns_rr_rd_count(rr) > 0) { ldns_rr_list_push_rr(list, ldns_rr_clone(rr)); } ldns_rr_free(rr); } } ldns_buffer_free(linebuf); } LDNS_FREE(line); LDNS_FREE(word); LDNS_FREE(addr); LDNS_FREE(rr_str); return list; } ldns_rr_list * ldns_get_rr_list_hosts_frm_file(char *filename) { ldns_rr_list *names; FILE *fp; if (!filename) { fp = fopen(LDNS_RESOLV_HOSTS, "r"); } else { fp = fopen(filename, "r"); } if (!fp) { return NULL; } names = ldns_get_rr_list_hosts_frm_fp(fp); fclose(fp); return names; } uint16_t ldns_getaddrinfo(ldns_resolver *res, ldns_rdf *node, ldns_rr_class c, ldns_rr_list **ret) { ldns_rdf_type t; uint16_t names_found; ldns_resolver *r; ldns_status s; t = ldns_rdf_get_type(node); names_found = 0; r = res; if (res == NULL) { /* prepare a new resolver, using /etc/resolv.conf as a guide */ s = ldns_resolver_new_frm_file(&r, NULL); if (s != LDNS_STATUS_OK) { return 0; } } if (t == LDNS_RDF_TYPE_DNAME) { /* we're asked to query for a name */ *ret = ldns_get_rr_list_addr_by_name(r, node, c, 0); names_found = ldns_rr_list_rr_count(*ret); } if (t == LDNS_RDF_TYPE_A || t == LDNS_RDF_TYPE_AAAA) { /* an address */ *ret = ldns_get_rr_list_name_by_addr(r, node, c, 0); names_found = ldns_rr_list_rr_count(*ret); } if (res == NULL) { ldns_resolver_deep_free(r); } return names_found; } bool ldns_nsec_type_check(ldns_rr *nsec, ldns_rr_type t) { switch (ldns_rr_get_type(nsec)) { case LDNS_RR_TYPE_NSEC : if (ldns_rr_rd_count(nsec) < 2) { return false; } return ldns_nsec_bitmap_covers_type( ldns_rr_rdf(nsec, 1), t); case LDNS_RR_TYPE_NSEC3 : if (ldns_rr_rd_count(nsec) < 6) { return false; } return ldns_nsec_bitmap_covers_type( ldns_rr_rdf(nsec, 5), t); default : return false; } } void ldns_print_rr_rdf(FILE *fp, ldns_rr *r, int rdfnum, ...) { int16_t rdf; ldns_rdf *rd; va_list va_rdf; va_start(va_rdf, rdfnum); for (rdf = (int16_t)rdfnum; rdf != -1; rdf = (int16_t)va_arg(va_rdf, int)) { rd = ldns_rr_rdf(r, rdf); if (!rd) { continue; } else { ldns_rdf_print(fp, rd); fprintf(fp, " "); /* not sure if we want to do this */ } } va_end(va_rdf); } ldns-1.6.17/LICENSE0000664000175100017510000000274612264060151013131 0ustar willemwillemCopyright (c) 2005,2006, NLnetLabs All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the name of NLnetLabs nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ldns-1.6.17/radix.c0000664000175100017510000011076512264060151013400 0ustar willemwillem/* * radix.c -- generic radix tree * * Taken from NSD4, modified for ldns * * Copyright (c) 2012, NLnet Labs. All rights reserved. * * This software is open source. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * Redistributions of source code must retain the above copyright notice, * this list of conditions and the following disclaimer. * * Redistributions in binary form must reproduce the above copyright notice, * this list of conditions and the following disclaimer in the documentation * and/or other materials provided with the distribution. * * Neither the name of the NLNET LABS nor the names of its contributors may * be used to endorse or promote products derived from this software without * specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. * */ /** * \file * Implementation of a radix tree. */ #include #include #include #include /** Helper functions */ static ldns_radix_node_t* ldns_radix_new_node(void* data, uint8_t* key, radix_strlen_t len); static int ldns_radix_find_prefix(ldns_radix_t* tree, uint8_t* key, radix_strlen_t len, ldns_radix_node_t** result, radix_strlen_t* pos); static int ldns_radix_array_space(ldns_radix_node_t* node, uint8_t byte); static int ldns_radix_array_grow(ldns_radix_node_t* node, unsigned need); static int ldns_radix_str_create(ldns_radix_array_t* array, uint8_t* key, radix_strlen_t pos, radix_strlen_t len); static int ldns_radix_prefix_remainder(radix_strlen_t prefix_len, uint8_t* longer_str, radix_strlen_t longer_len, uint8_t** split_str, radix_strlen_t* split_len); static int ldns_radix_array_split(ldns_radix_array_t* array, uint8_t* key, radix_strlen_t pos, radix_strlen_t len, ldns_radix_node_t* add); static int ldns_radix_str_is_prefix(uint8_t* str1, radix_strlen_t len1, uint8_t* str2, radix_strlen_t len2); static radix_strlen_t ldns_radix_str_common(uint8_t* str1, radix_strlen_t len1, uint8_t* str2, radix_strlen_t len2); static ldns_radix_node_t* ldns_radix_next_in_subtree(ldns_radix_node_t* node); static ldns_radix_node_t* ldns_radix_prev_from_index(ldns_radix_node_t* node, uint8_t index); static ldns_radix_node_t* ldns_radix_last_in_subtree_incl_self( ldns_radix_node_t* node); static ldns_radix_node_t* ldns_radix_last_in_subtree(ldns_radix_node_t* node); static void ldns_radix_del_fix(ldns_radix_t* tree, ldns_radix_node_t* node); static void ldns_radix_cleanup_onechild(ldns_radix_node_t* node); static void ldns_radix_cleanup_leaf(ldns_radix_node_t* node); static void ldns_radix_node_free(ldns_radix_node_t* node, void* arg); static void ldns_radix_node_array_free(ldns_radix_node_t* node); static void ldns_radix_node_array_free_front(ldns_radix_node_t* node); static void ldns_radix_node_array_free_end(ldns_radix_node_t* node); static void ldns_radix_array_reduce(ldns_radix_node_t* node); static void ldns_radix_self_or_prev(ldns_radix_node_t* node, ldns_radix_node_t** result); /** * Create a new radix node. * */ static ldns_radix_node_t* ldns_radix_new_node(void* data, uint8_t* key, radix_strlen_t len) { ldns_radix_node_t* node = LDNS_MALLOC(ldns_radix_node_t); if (!node) { return NULL; } node->data = data; node->key = key; node->klen = len; node->parent = NULL; node->parent_index = 0; node->len = 0; node->offset = 0; node->capacity = 0; node->array = NULL; return node; } /** * Create a new radix tree. * */ ldns_radix_t * ldns_radix_create(void) { ldns_radix_t* tree; /** Allocate memory for it */ tree = (ldns_radix_t *) LDNS_MALLOC(ldns_radix_t); if (!tree) { return NULL; } /** Initialize it */ ldns_radix_init(tree); return tree; } /** * Initialize radix tree. * */ void ldns_radix_init(ldns_radix_t* tree) { /** Initialize it */ if (tree) { tree->root = NULL; tree->count = 0; } return; } /** * Free radix tree. * */ void ldns_radix_free(ldns_radix_t* tree) { if (tree) { if (tree->root) { ldns_radix_traverse_postorder(tree->root, ldns_radix_node_free, NULL); } LDNS_FREE(tree); } return; } /** * Insert data into the tree. * */ ldns_status ldns_radix_insert(ldns_radix_t* tree, uint8_t* key, radix_strlen_t len, void* data) { radix_strlen_t pos = 0; ldns_radix_node_t* add = NULL; ldns_radix_node_t* prefix = NULL; if (!tree || !key || !data) { return LDNS_STATUS_NULL; } add = ldns_radix_new_node(data, key, len); if (!add) { return LDNS_STATUS_MEM_ERR; } /** Search the trie until we can make no further process. */ if (!ldns_radix_find_prefix(tree, key, len, &prefix, &pos)) { /** No prefix found */ assert(tree->root == NULL); if (len == 0) { /** * Example 1: The root: * | [0] **/ tree->root = add; } else { /** Example 2: 'dns': * | [0] * --| [d+ns] dns **/ prefix = ldns_radix_new_node(NULL, (uint8_t*)"", 0); if (!prefix) { LDNS_FREE(add); return LDNS_STATUS_MEM_ERR; } /** Find some space in the array for the first byte */ if (!ldns_radix_array_space(prefix, key[0])) { LDNS_FREE(add); LDNS_FREE(prefix->array); LDNS_FREE(prefix); return LDNS_STATUS_MEM_ERR; } /** Set relational pointers */ add->parent = prefix; add->parent_index = 0; prefix->array[0].edge = add; if (len > 1) { /** Store the remainder of the prefix */ if (!ldns_radix_prefix_remainder(1, key, len, &prefix->array[0].str, &prefix->array[0].len)) { LDNS_FREE(add); LDNS_FREE(prefix->array); LDNS_FREE(prefix); return LDNS_STATUS_MEM_ERR; } } tree->root = prefix; } } else if (pos == len) { /** Exact match found */ if (prefix->data) { /* Element already exists */ LDNS_FREE(add); return LDNS_STATUS_EXISTS_ERR; } prefix->data = data; prefix->key = key; prefix->klen = len; /* redundant */ } else { /** Prefix found */ uint8_t byte = key[pos]; assert(pos < len); if (byte < prefix->offset || (byte - prefix->offset) >= prefix->len) { /** Find some space in the array for the byte. */ /** * Example 3: 'ldns' * | [0] * --| [d+ns] dns * --| [l+dns] ldns **/ if (!ldns_radix_array_space(prefix, byte)) { LDNS_FREE(add); return LDNS_STATUS_MEM_ERR; } assert(byte >= prefix->offset); assert((byte - prefix->offset) <= prefix->len); byte -= prefix->offset; if (pos+1 < len) { /** Create remainder of the string. */ if (!ldns_radix_str_create( &prefix->array[byte], key, pos+1, len)) { LDNS_FREE(add); return LDNS_STATUS_MEM_ERR; } } /** Add new node. */ add->parent = prefix; add->parent_index = byte; prefix->array[byte].edge = add; } else if (prefix->array[byte-prefix->offset].edge == NULL) { /** Use existing element. */ /** * Example 4: 'edns' * | [0] * --| [d+ns] dns * --| [e+dns] edns * --| [l+dns] ldns **/ byte -= prefix->offset; if (pos+1 < len) { /** Create remainder of the string. */ if (!ldns_radix_str_create( &prefix->array[byte], key, pos+1, len)) { LDNS_FREE(add); return LDNS_STATUS_MEM_ERR; } } /** Add new node. */ add->parent = prefix; add->parent_index = byte; prefix->array[byte].edge = add; } else { /** * Use existing element, but it has a shared prefix, * we need a split. */ if (!ldns_radix_array_split(&prefix->array[byte-(prefix->offset)], key, pos+1, len, add)) { LDNS_FREE(add); return LDNS_STATUS_MEM_ERR; } } } tree->count ++; return LDNS_STATUS_OK; } /** * Delete data from the tree. * */ void* ldns_radix_delete(ldns_radix_t* tree, uint8_t* key, radix_strlen_t len) { ldns_radix_node_t* del = ldns_radix_search(tree, key, len); void* data = NULL; if (del) { tree->count--; data = del->data; del->data = NULL; ldns_radix_del_fix(tree, del); return data; } return NULL; } /** * Search data in the tree. * */ ldns_radix_node_t* ldns_radix_search(ldns_radix_t* tree, uint8_t* key, radix_strlen_t len) { ldns_radix_node_t* node = NULL; radix_strlen_t pos = 0; uint8_t byte = 0; if (!tree || !key) { return NULL; } node = tree->root; while (node) { if (pos == len) { return node->data?node:NULL; } byte = key[pos]; if (byte < node->offset) { return NULL; } byte -= node->offset; if (byte >= node->len) { return NULL; } pos++; if (node->array[byte].len > 0) { /** Must match additional string. */ if (pos + node->array[byte].len > len) { return NULL; } if (memcmp(&key[pos], node->array[byte].str, node->array[byte].len) != 0) { return NULL; } pos += node->array[byte].len; } node = node->array[byte].edge; } return NULL; } /** * Search data in the tree, and if not found, find the closest smaller * element in the tree. * */ int ldns_radix_find_less_equal(ldns_radix_t* tree, uint8_t* key, radix_strlen_t len, ldns_radix_node_t** result) { ldns_radix_node_t* node = NULL; radix_strlen_t pos = 0; uint8_t byte; int memcmp_res = 0; if (!tree || !tree->root || !key) { *result = NULL; return 0; } node = tree->root; while (pos < len) { byte = key[pos]; if (byte < node->offset) { /** * No exact match. The lesser is in this or the * previous node. */ ldns_radix_self_or_prev(node, result); return 0; } byte -= node->offset; if (byte >= node->len) { /** * No exact match. The lesser is in this node or the * last of this array, or something before this node. */ *result = ldns_radix_last_in_subtree_incl_self(node); if (*result == NULL) { *result = ldns_radix_prev(node); } return 0; } pos++; if (!node->array[byte].edge) { /** * No exact match. Find the previous in the array * from this index. */ *result = ldns_radix_prev_from_index(node, byte); if (*result == NULL) { ldns_radix_self_or_prev(node, result); } return 0; } if (node->array[byte].len != 0) { /** Must match additional string. */ if (pos + node->array[byte].len > len) { /** Additional string is longer than key. */ if (memcmp(&key[pos], node->array[byte].str, len-pos) <= 0) { /** Key is before this node. */ *result = ldns_radix_prev( node->array[byte].edge); } else { /** Key is after additional string. */ *result = ldns_radix_last_in_subtree_incl_self(node->array[byte].edge); if (*result == NULL) { *result = ldns_radix_prev(node->array[byte].edge); } } return 0; } memcmp_res = memcmp(&key[pos], node->array[byte].str, node->array[byte].len); if (memcmp_res < 0) { *result = ldns_radix_prev( node->array[byte].edge); return 0; } else if (memcmp_res > 0) { *result = ldns_radix_last_in_subtree_incl_self(node->array[byte].edge); if (*result == NULL) { *result = ldns_radix_prev(node->array[byte].edge); } return 0; } pos += node->array[byte].len; } node = node->array[byte].edge; } if (node->data) { /** Exact match. */ *result = node; return 1; } /** There is a node which is an exact match, but has no element. */ *result = ldns_radix_prev(node); return 0; } /** * Get the first element in the tree. * */ ldns_radix_node_t* ldns_radix_first(ldns_radix_t* tree) { ldns_radix_node_t* first = NULL; if (!tree || !tree->root) { return NULL; } first = tree->root; if (first->data) { return first; } return ldns_radix_next(first); } /** * Get the last element in the tree. * */ ldns_radix_node_t* ldns_radix_last(ldns_radix_t* tree) { if (!tree || !tree->root) { return NULL; } return ldns_radix_last_in_subtree_incl_self(tree->root); } /** * Next element. * */ ldns_radix_node_t* ldns_radix_next(ldns_radix_node_t* node) { if (!node) { return NULL; } if (node->len) { /** Go down: most-left child is the next. */ ldns_radix_node_t* next = ldns_radix_next_in_subtree(node); if (next) { return next; } } /** No elements in subtree, get to parent and go down next branch. */ while (node->parent) { uint8_t index = node->parent_index; node = node->parent; index++; for (; index < node->len; index++) { if (node->array[index].edge) { ldns_radix_node_t* next; /** Node itself. */ if (node->array[index].edge->data) { return node->array[index].edge; } /** Dive into subtree. */ next = ldns_radix_next_in_subtree(node); if (next) { return next; } } } } return NULL; } /** * Previous element. * */ ldns_radix_node_t* ldns_radix_prev(ldns_radix_node_t* node) { if (!node) { return NULL; } /** Get to parent and go down previous branch. */ while (node->parent) { uint8_t index = node->parent_index; ldns_radix_node_t* prev; node = node->parent; assert(node->len > 0); prev = ldns_radix_prev_from_index(node, index); if (prev) { return prev; } if (node->data) { return node; } } return NULL; } /** * Print node. * */ static void ldns_radix_node_print(FILE* fd, ldns_radix_node_t* node, uint8_t i, uint8_t* str, radix_strlen_t len, unsigned d) { uint8_t j; if (!node) { return; } for (j = 0; j < d; j++) { fprintf(fd, "--"); } if (str) { radix_strlen_t l; fprintf(fd, "| [%u+", (unsigned) i); for (l=0; l < len; l++) { fprintf(fd, "%c", (char) str[l]); } fprintf(fd, "]%u", (unsigned) len); } else { fprintf(fd, "| [%u]", (unsigned) i); } if (node->data) { fprintf(fd, " %s", (char*) node->data); } fprintf(fd, "\n"); for (j = 0; j < node->len; j++) { if (node->array[j].edge) { ldns_radix_node_print(fd, node->array[j].edge, j, node->array[j].str, node->array[j].len, d+1); } } return; } /** * Print radix tree. * */ void ldns_radix_printf(FILE* fd, ldns_radix_t* tree) { if (!fd || !tree) { return; } if (!tree->root) { fprintf(fd, "; empty radix tree\n"); return; } ldns_radix_node_print(fd, tree->root, 0, NULL, 0, 0); return; } /** * Join two radix trees. * */ ldns_status ldns_radix_join(ldns_radix_t* tree1, ldns_radix_t* tree2) { ldns_radix_node_t* cur_node, *next_node; ldns_status status; if (!tree2 || !tree2->root) { return LDNS_STATUS_OK; } /** Add all elements from tree2 into tree1. */ cur_node = ldns_radix_first(tree2); while (cur_node) { status = LDNS_STATUS_NO_DATA; /** Insert current node into tree1 */ if (cur_node->data) { status = ldns_radix_insert(tree1, cur_node->key, cur_node->klen, cur_node->data); /** Exist errors may occur */ if (status != LDNS_STATUS_OK && status != LDNS_STATUS_EXISTS_ERR) { return status; } } next_node = ldns_radix_next(cur_node); if (status == LDNS_STATUS_OK) { (void) ldns_radix_delete(tree2, cur_node->key, cur_node->klen); } cur_node = next_node; } return LDNS_STATUS_OK; } /** * Split a radix tree intwo. * */ ldns_status ldns_radix_split(ldns_radix_t* tree1, size_t num, ldns_radix_t** tree2) { size_t count = 0; ldns_radix_node_t* cur_node; ldns_status status = LDNS_STATUS_OK; if (!tree1 || !tree1->root || num == 0) { return LDNS_STATUS_OK; } if (!tree2) { return LDNS_STATUS_NULL; } if (!*tree2) { *tree2 = ldns_radix_create(); if (!*tree2) { return LDNS_STATUS_MEM_ERR; } } cur_node = ldns_radix_first(tree1); while (count < num && cur_node) { if (cur_node->data) { /** Delete current node from tree1. */ uint8_t* cur_key = cur_node->key; radix_strlen_t cur_len = cur_node->klen; void* cur_data = ldns_radix_delete(tree1, cur_key, cur_len); /** Insert current node into tree2/ */ if (!cur_data) { return LDNS_STATUS_NO_DATA; } status = ldns_radix_insert(*tree2, cur_key, cur_len, cur_data); if (status != LDNS_STATUS_OK && status != LDNS_STATUS_EXISTS_ERR) { return status; } /* if (status == LDNS_STATUS_OK) { cur_node->key = NULL; cur_node->klen = 0; } */ /** Update count; get first element from tree1 again. */ count++; cur_node = ldns_radix_first(tree1); } else { cur_node = ldns_radix_next(cur_node); } } return LDNS_STATUS_OK; } /** * Call function for all nodes in the tree, such that leaf nodes are * called before parent nodes. * */ void ldns_radix_traverse_postorder(ldns_radix_node_t* node, void (*func)(ldns_radix_node_t*, void*), void* arg) { uint8_t i; if (!node) { return; } for (i=0; i < node->len; i++) { ldns_radix_traverse_postorder(node->array[i].edge, func, arg); } /** Call user function */ (*func)(node, arg); return; } /** Static helper functions */ /** * Find a prefix of the key. * @param tree: tree. * @param key: key. * @param len: length of key. * @param result: the longest prefix, the entry itself if *pos==len, * otherwise an array entry. * @param pos: position in string where next unmatched byte is. * If *pos==len, an exact match is found. * If *pos== 0, a "" match was found. * @return 0 (false) if no prefix found. * */ static int ldns_radix_find_prefix(ldns_radix_t* tree, uint8_t* key, radix_strlen_t len, ldns_radix_node_t** result, radix_strlen_t* respos) { /** Start searching at the root node */ ldns_radix_node_t* n = tree->root; radix_strlen_t pos = 0; uint8_t byte; *respos = 0; *result = n; if (!n) { /** No root, no prefix found */ return 0; } /** For each node, look if we can make further progress */ while (n) { if (pos == len) { /** Exact match */ return 1; } byte = key[pos]; if (byte < n->offset) { /** key < node */ return 1; } byte -= n->offset; if (byte >= n->len) { /** key > node */ return 1; } /** So far, the trie matches */ pos++; if (n->array[byte].len != 0) { /** Must match additional string */ if (pos + n->array[byte].len > len) { return 1; /* no match at child node */ } if (memcmp(&key[pos], n->array[byte].str, n->array[byte].len) != 0) { return 1; /* no match at child node */ } pos += n->array[byte].len; } /** Continue searching prefix at this child node */ n = n->array[byte].edge; if (!n) { return 1; } /** Update the prefix node */ *respos = pos; *result = n; } /** Done */ return 1; } /** * Make space in the node's array for another byte. * @param node: node. * @param byte: byte. * @return 1 if successful, 0 otherwise. * */ static int ldns_radix_array_space(ldns_radix_node_t* node, uint8_t byte) { /** Is there an array? */ if (!node->array) { assert(node->capacity == 0); /** No array, create new array */ node->array = LDNS_MALLOC(ldns_radix_array_t); if (!node->array) { return 0; } memset(&node->array[0], 0, sizeof(ldns_radix_array_t)); node->len = 1; node->capacity = 1; node->offset = byte; return 1; } /** Array exist */ assert(node->array != NULL); assert(node->capacity > 0); if (node->len == 0) { /** Unused array */ node->len = 1; node->offset = byte; } else if (byte < node->offset) { /** Byte is below the offset */ uint8_t index; uint16_t need = node->offset - byte; /** Is there enough capacity? */ if (node->len + need > node->capacity) { /** Not enough capacity, grow array */ if (!ldns_radix_array_grow(node, (unsigned) (node->len + need))) { return 0; /* failed to grow array */ } } /** Move items to the end */ memmove(&node->array[need], &node->array[0], node->len*sizeof(ldns_radix_array_t)); /** Fix parent index */ for (index = 0; index < node->len; index++) { if (node->array[index+need].edge) { node->array[index+need].edge->parent_index = index + need; } } /** Zero the first */ memset(&node->array[0], 0, need*sizeof(ldns_radix_array_t)); node->len += need; node->offset = byte; } else if (byte - node->offset >= node->len) { /** Byte does not fit in array */ uint16_t need = (byte - node->offset) - node->len + 1; /** Is there enough capacity? */ if (node->len + need > node->capacity) { /** Not enough capacity, grow array */ if (!ldns_radix_array_grow(node, (unsigned) (node->len + need))) { return 0; /* failed to grow array */ } } /** Zero the added items */ memset(&node->array[node->len], 0, need*sizeof(ldns_radix_array_t)); node->len += need; } return 1; } /** * Grow the array. * @param node: node. * @param need: number of elements the array at least need to grow. * Can't be bigger than 256. * @return: 0 if failed, 1 if was successful. * */ static int ldns_radix_array_grow(ldns_radix_node_t* node, unsigned need) { unsigned size = ((unsigned)node->capacity)*2; ldns_radix_array_t* a = NULL; if (need > size) { size = need; } if (size > 256) { size = 256; } a = LDNS_XMALLOC(ldns_radix_array_t, size); if (!a) { return 0; } assert(node->len <= node->capacity); assert(node->capacity < size); memcpy(&a[0], &node->array[0], node->len*sizeof(ldns_radix_array_t)); LDNS_FREE(node->array); node->array = a; node->capacity = size; return 1; } /** * Create a prefix in the array string. * @param array: array. * @param key: key. * @param pos: start position in key. * @param len: length of key. * @return 0 if failed, 1 if was successful. * */ static int ldns_radix_str_create(ldns_radix_array_t* array, uint8_t* key, radix_strlen_t pos, radix_strlen_t len) { array->str = LDNS_XMALLOC(uint8_t, (len-pos)); if (!array->str) { return 0; } memmove(array->str, key+pos, len-pos); array->len = (len-pos); return 1; } /** * Allocate remainder from prefixes for a split. * @param prefixlen: length of prefix. * @param longer_str: the longer string. * @param longer_len: the longer string length. * @param split_str: the split string. * @param split_len: the split string length. * @return 0 if failed, 1 if successful. * */ static int ldns_radix_prefix_remainder(radix_strlen_t prefix_len, uint8_t* longer_str, radix_strlen_t longer_len, uint8_t** split_str, radix_strlen_t* split_len) { *split_len = longer_len - prefix_len; *split_str = LDNS_XMALLOC(uint8_t, (*split_len)); if (!*split_str) { return 0; } memmove(*split_str, longer_str+prefix_len, longer_len-prefix_len); return 1; } /** * Create a split when two nodes have a shared prefix. * @param array: array. * @param key: key. * @param pos: start position in key. * @param len: length of the key. * @param add: node to be added. * @return 0 if failed, 1 if was successful. * */ static int ldns_radix_array_split(ldns_radix_array_t* array, uint8_t* key, radix_strlen_t pos, radix_strlen_t len, ldns_radix_node_t* add) { uint8_t* str_to_add = key + pos; radix_strlen_t strlen_to_add = len - pos; if (ldns_radix_str_is_prefix(str_to_add, strlen_to_add, array->str, array->len)) { /** The string to add is a prefix of the existing string */ uint8_t* split_str = NULL, *dup_str = NULL; radix_strlen_t split_len = 0; /** * Example 5: 'ld' * | [0] * --| [d+ns] dns * --| [e+dns] edns * --| [l+d] ld * ----| [n+s] ldns **/ assert(strlen_to_add < array->len); /** Store the remainder in the split string */ if (array->len - strlen_to_add > 1) { if (!ldns_radix_prefix_remainder(strlen_to_add+1, array->str, array->len, &split_str, &split_len)) { return 0; } } /** Duplicate the string to add */ if (strlen_to_add != 0) { dup_str = LDNS_XMALLOC(uint8_t, strlen_to_add); if (!dup_str) { LDNS_FREE(split_str); return 0; } memcpy(dup_str, str_to_add, strlen_to_add); } /** Make space in array for the new node */ if (!ldns_radix_array_space(add, array->str[strlen_to_add])) { LDNS_FREE(split_str); LDNS_FREE(dup_str); return 0; } /** * The added node should go direct under the existing parent. * The existing node should go under the added node. */ add->parent = array->edge->parent; add->parent_index = array->edge->parent_index; add->array[0].edge = array->edge; add->array[0].str = split_str; add->array[0].len = split_len; array->edge->parent = add; array->edge->parent_index = 0; LDNS_FREE(array->str); array->edge = add; array->str = dup_str; array->len = strlen_to_add; } else if (ldns_radix_str_is_prefix(array->str, array->len, str_to_add, strlen_to_add)) { /** The existing string is a prefix of the string to add */ /** * Example 6: 'dns-ng' * | [0] * --| [d+ns] dns * ----| [-+ng] dns-ng * --| [e+dns] edns * --| [l+d] ld * ----| [n+s] ldns **/ uint8_t* split_str = NULL; radix_strlen_t split_len = 0; assert(array->len < strlen_to_add); if (strlen_to_add - array->len > 1) { if (!ldns_radix_prefix_remainder(array->len+1, str_to_add, strlen_to_add, &split_str, &split_len)) { return 0; } } /** Make space in array for the new node */ if (!ldns_radix_array_space(array->edge, str_to_add[array->len])) { LDNS_FREE(split_str); return 0; } /** * The added node should go direct under the existing node. */ add->parent = array->edge; add->parent_index = str_to_add[array->len] - array->edge->offset; array->edge->array[add->parent_index].edge = add; array->edge->array[add->parent_index].str = split_str; array->edge->array[add->parent_index].len = split_len; } else { /** Create a new split node. */ /** * Example 7: 'dndns' * | [0] * --| [d+n] * ----| [d+ns] dndns * ----| [s] dns * ------| [-+ng] dns-ng * --| [e+dns] edns * --| [l+d] ld * ----| [n+s] ldns **/ ldns_radix_node_t* common = NULL; uint8_t* common_str = NULL, *s1 = NULL, *s2 = NULL; radix_strlen_t common_len = 0, l1 = 0, l2 = 0; common_len = ldns_radix_str_common(array->str, array->len, str_to_add, strlen_to_add); assert(common_len < array->len); assert(common_len < strlen_to_add); /** Create the new common node. */ common = ldns_radix_new_node(NULL, (uint8_t*)"", 0); if (!common) { return 0; } if (array->len - common_len > 1) { if (!ldns_radix_prefix_remainder(common_len+1, array->str, array->len, &s1, &l1)) { return 0; } } if (strlen_to_add - common_len > 1) { if (!ldns_radix_prefix_remainder(common_len+1, str_to_add, strlen_to_add, &s2, &l2)) { return 0; } } /** Create the shared prefix. */ if (common_len > 0) { common_str = LDNS_XMALLOC(uint8_t, common_len); if (!common_str) { LDNS_FREE(common); LDNS_FREE(s1); LDNS_FREE(s2); return 0; } memcpy(common_str, str_to_add, common_len); } /** Make space in the common node array. */ if (!ldns_radix_array_space(common, array->str[common_len]) || !ldns_radix_array_space(common, str_to_add[common_len])) { LDNS_FREE(common->array); LDNS_FREE(common); LDNS_FREE(common_str); LDNS_FREE(s1); LDNS_FREE(s2); return 0; } /** * The common node should go direct under the parent node. * The added and existing nodes go under the common node. */ common->parent = array->edge->parent; common->parent_index = array->edge->parent_index; array->edge->parent = common; array->edge->parent_index = array->str[common_len] - common->offset; add->parent = common; add->parent_index = str_to_add[common_len] - common->offset; common->array[array->edge->parent_index].edge = array->edge; common->array[array->edge->parent_index].str = s1; common->array[array->edge->parent_index].len = l1; common->array[add->parent_index].edge = add; common->array[add->parent_index].str = s2; common->array[add->parent_index].len = l2; LDNS_FREE(array->str); array->edge = common; array->str = common_str; array->len = common_len; } return 1; } /** * Check if one string prefix of other string. * @param str1: one string. * @param len1: one string length. * @param str2: other string. * @param len2: other string length. * @return 1 if prefix, 0 otherwise. * */ static int ldns_radix_str_is_prefix(uint8_t* str1, radix_strlen_t len1, uint8_t* str2, radix_strlen_t len2) { if (len1 == 0) { return 1; /* empty prefix is also a prefix */ } if (len1 > len2) { return 0; /* len1 is longer so str1 cannot be a prefix */ } return (memcmp(str1, str2, len1) == 0); } /** * Return the number of bytes in common for the two strings. * @param str1: one string. * @param len1: one string length. * @param str2: other string. * @param len2: other string length. * @return length of substring that the two strings have in common. * */ static radix_strlen_t ldns_radix_str_common(uint8_t* str1, radix_strlen_t len1, uint8_t* str2, radix_strlen_t len2) { radix_strlen_t i, max = (len1len; i++) { if (node->array[i].edge) { /** Node itself. */ if (node->array[i].edge->data) { return node->array[i].edge; } /** Dive into subtree. */ next = ldns_radix_next_in_subtree(node->array[i].edge); if (next) { return next; } } } return NULL; } /** * Find the previous element in the array of this node, from index. * @param node: node. * @param index: index. * @return previous node from index. * */ static ldns_radix_node_t* ldns_radix_prev_from_index(ldns_radix_node_t* node, uint8_t index) { uint8_t i = index; while (i > 0) { i--; if (node->array[i].edge) { ldns_radix_node_t* prev = ldns_radix_last_in_subtree_incl_self(node); if (prev) { return prev; } } } return NULL; } /** * Find last node in subtree, or this node (if have data). * @param node: node. * @return last node in subtree, or this node, or NULL. * */ static ldns_radix_node_t* ldns_radix_last_in_subtree_incl_self(ldns_radix_node_t* node) { ldns_radix_node_t* last = ldns_radix_last_in_subtree(node); if (last) { return last; } else if (node->data) { return node; } return NULL; } /** * Find last node in subtree. * @param node: node. * @return last node in subtree. * */ static ldns_radix_node_t* ldns_radix_last_in_subtree(ldns_radix_node_t* node) { int i; /** Look for the most right leaf node. */ for (i=(int)(node->len)-1; i >= 0; i--) { if (node->array[i].edge) { /** Keep looking for the most right leaf node. */ if (node->array[i].edge->len > 0) { ldns_radix_node_t* last = ldns_radix_last_in_subtree( node->array[i].edge); if (last) { return last; } } /** Could this be the most right leaf node? */ if (node->array[i].edge->data) { return node->array[i].edge; } } } return NULL; } /** * Fix tree after deleting element. * @param tree: tree. * @param node: node with deleted element. * */ static void ldns_radix_del_fix(ldns_radix_t* tree, ldns_radix_node_t* node) { while (node) { if (node->data) { /** Thou should not delete nodes with data attached. */ return; } else if (node->len == 1 && node->parent) { /** Node with one child is fold back into. */ ldns_radix_cleanup_onechild(node); return; } else if (node->len == 0) { /** Leaf node. */ ldns_radix_node_t* parent = node->parent; if (!parent) { /** The root is a leaf node. */ ldns_radix_node_free(node, NULL); tree->root = NULL; return; } /** Cleanup leaf node and continue with parent. */ ldns_radix_cleanup_leaf(node); node = parent; } else { /** * Node cannot be deleted, because it has edge nodes * and no parent to fix up to. */ return; } } /** Not reached. */ return; } /** * Clean up a node with one child. * @param node: node with one child. * */ static void ldns_radix_cleanup_onechild(ldns_radix_node_t* node) { uint8_t* join_str; radix_strlen_t join_len; uint8_t parent_index = node->parent_index; ldns_radix_node_t* child = node->array[0].edge; ldns_radix_node_t* parent = node->parent; /** Node has one child, merge the child node into the parent node. */ assert(parent_index < parent->len); join_len = parent->array[parent_index].len + node->array[0].len + 1; join_str = LDNS_XMALLOC(uint8_t, join_len); if (!join_str) { /** * Cleanup failed due to out of memory. * This tree is now inefficient, with the empty node still * existing, but it is still valid. */ return; } memcpy(join_str, parent->array[parent_index].str, parent->array[parent_index].len); join_str[parent->array[parent_index].len] = child->parent_index + node->offset; memmove(join_str + parent->array[parent_index].len+1, node->array[0].str, node->array[0].len); LDNS_FREE(parent->array[parent_index].str); parent->array[parent_index].str = join_str; parent->array[parent_index].len = join_len; parent->array[parent_index].edge = child; child->parent = parent; child->parent_index = parent_index; ldns_radix_node_free(node, NULL); return; } /** * Clean up a leaf node. * @param node: leaf node. * */ static void ldns_radix_cleanup_leaf(ldns_radix_node_t* node) { uint8_t parent_index = node->parent_index; ldns_radix_node_t* parent = node->parent; /** Delete lead node and fix parent array. */ assert(parent_index < parent->len); ldns_radix_node_free(node, NULL); LDNS_FREE(parent->array[parent_index].str); parent->array[parent_index].str = NULL; parent->array[parent_index].len = 0; parent->array[parent_index].edge = NULL; /** Fix array in parent. */ if (parent->len == 1) { ldns_radix_node_array_free(parent); } else if (parent_index == 0) { ldns_radix_node_array_free_front(parent); } else { ldns_radix_node_array_free_end(parent); } return; } /** * Free a radix node. * @param node: node. * @param arg: user argument. * */ static void ldns_radix_node_free(ldns_radix_node_t* node, void* arg) { uint16_t i; (void) arg; if (!node) { return; } for (i=0; i < node->len; i++) { LDNS_FREE(node->array[i].str); } node->key = NULL; node->klen = 0; LDNS_FREE(node->array); LDNS_FREE(node); return; } /** * Free select edge array. * @param node: node. * */ static void ldns_radix_node_array_free(ldns_radix_node_t* node) { node->offset = 0; node->len = 0; LDNS_FREE(node->array); node->array = NULL; node->capacity = 0; return; } /** * Free front of select edge array. * @param node: node. * */ static void ldns_radix_node_array_free_front(ldns_radix_node_t* node) { uint16_t i, n = 0; /** Remove until a non NULL entry. */ while (n < node->len && node->array[n].edge == NULL) { n++; } if (n == 0) { return; } if (n == node->len) { ldns_radix_node_array_free(node); return; } assert(n < node->len); assert((int) n <= (255 - (int) node->offset)); memmove(&node->array[0], &node->array[n], (node->len - n)*sizeof(ldns_radix_array_t)); node->offset += n; node->len -= n; for (i=0; i < node->len; i++) { if (node->array[i].edge) { node->array[i].edge->parent_index = i; } } ldns_radix_array_reduce(node); return; } /** * Free front of select edge array. * @param node: node. * */ static void ldns_radix_node_array_free_end(ldns_radix_node_t* node) { uint16_t n = 0; /** Shorten array. */ while (n < node->len && node->array[node->len-1-n].edge == NULL) { n++; } if (n == 0) { return; } if (n == node->len) { ldns_radix_node_array_free(node); return; } assert(n < node->len); node->len -= n; ldns_radix_array_reduce(node); return; } /** * Reduce the capacity of the array if needed. * @param node: node. * */ static void ldns_radix_array_reduce(ldns_radix_node_t* node) { if (node->len <= node->capacity/2 && node->len != node->capacity) { ldns_radix_array_t* a = LDNS_XMALLOC(ldns_radix_array_t, node->len); if (!a) { return; } memcpy(a, node->array, sizeof(ldns_radix_array_t)*node->len); LDNS_FREE(node->array); node->array = a; node->capacity = node->len; } return; } /** * Return this element if it exists, the previous otherwise. * @param node: from this node. * @param result: result node. * */ static void ldns_radix_self_or_prev(ldns_radix_node_t* node, ldns_radix_node_t** result) { if (node->data) { *result = node; } else { *result = ldns_radix_prev(node); } return; } ldns-1.6.17/dnssec_sign.c0000664000175100017510000011335012264060151014561 0ustar willemwillem#include #include #include #include #include #include #ifdef HAVE_SSL /* this entire file is rather useless when you don't have * crypto... */ #include #include #include #include #include #endif /* HAVE_SSL */ ldns_rr * ldns_create_empty_rrsig(ldns_rr_list *rrset, ldns_key *current_key) { uint32_t orig_ttl; ldns_rr_class orig_class; time_t now; ldns_rr *current_sig; uint8_t label_count; ldns_rdf *signame; label_count = ldns_dname_label_count(ldns_rr_owner(ldns_rr_list_rr(rrset, 0))); /* RFC4035 2.2: not counting the leftmost label if it is a wildcard */ if(ldns_dname_is_wildcard(ldns_rr_owner(ldns_rr_list_rr(rrset, 0)))) label_count --; current_sig = ldns_rr_new_frm_type(LDNS_RR_TYPE_RRSIG); /* set the type on the new signature */ orig_ttl = ldns_rr_ttl(ldns_rr_list_rr(rrset, 0)); orig_class = ldns_rr_get_class(ldns_rr_list_rr(rrset, 0)); ldns_rr_set_ttl(current_sig, orig_ttl); ldns_rr_set_class(current_sig, orig_class); ldns_rr_set_owner(current_sig, ldns_rdf_clone( ldns_rr_owner( ldns_rr_list_rr(rrset, 0)))); /* fill in what we know of the signature */ /* set the orig_ttl */ (void)ldns_rr_rrsig_set_origttl( current_sig, ldns_native2rdf_int32(LDNS_RDF_TYPE_INT32, orig_ttl)); /* the signers name */ signame = ldns_rdf_clone(ldns_key_pubkey_owner(current_key)); ldns_dname2canonical(signame); (void)ldns_rr_rrsig_set_signame( current_sig, signame); /* label count - get it from the first rr in the rr_list */ (void)ldns_rr_rrsig_set_labels( current_sig, ldns_native2rdf_int8(LDNS_RDF_TYPE_INT8, label_count)); /* inception, expiration */ now = time(NULL); if (ldns_key_inception(current_key) != 0) { (void)ldns_rr_rrsig_set_inception( current_sig, ldns_native2rdf_int32( LDNS_RDF_TYPE_TIME, ldns_key_inception(current_key))); } else { (void)ldns_rr_rrsig_set_inception( current_sig, ldns_native2rdf_int32(LDNS_RDF_TYPE_TIME, now)); } if (ldns_key_expiration(current_key) != 0) { (void)ldns_rr_rrsig_set_expiration( current_sig, ldns_native2rdf_int32( LDNS_RDF_TYPE_TIME, ldns_key_expiration(current_key))); } else { (void)ldns_rr_rrsig_set_expiration( current_sig, ldns_native2rdf_int32( LDNS_RDF_TYPE_TIME, now + LDNS_DEFAULT_EXP_TIME)); } (void)ldns_rr_rrsig_set_keytag( current_sig, ldns_native2rdf_int16(LDNS_RDF_TYPE_INT16, ldns_key_keytag(current_key))); (void)ldns_rr_rrsig_set_algorithm( current_sig, ldns_native2rdf_int8( LDNS_RDF_TYPE_ALG, ldns_key_algorithm(current_key))); (void)ldns_rr_rrsig_set_typecovered( current_sig, ldns_native2rdf_int16( LDNS_RDF_TYPE_TYPE, ldns_rr_get_type(ldns_rr_list_rr(rrset, 0)))); return current_sig; } #ifdef HAVE_SSL ldns_rdf * ldns_sign_public_buffer(ldns_buffer *sign_buf, ldns_key *current_key) { ldns_rdf *b64rdf = NULL; switch(ldns_key_algorithm(current_key)) { case LDNS_SIGN_DSA: case LDNS_SIGN_DSA_NSEC3: b64rdf = ldns_sign_public_evp( sign_buf, ldns_key_evp_key(current_key), EVP_dss1()); break; case LDNS_SIGN_RSASHA1: case LDNS_SIGN_RSASHA1_NSEC3: b64rdf = ldns_sign_public_evp( sign_buf, ldns_key_evp_key(current_key), EVP_sha1()); break; #ifdef USE_SHA2 case LDNS_SIGN_RSASHA256: b64rdf = ldns_sign_public_evp( sign_buf, ldns_key_evp_key(current_key), EVP_sha256()); break; case LDNS_SIGN_RSASHA512: b64rdf = ldns_sign_public_evp( sign_buf, ldns_key_evp_key(current_key), EVP_sha512()); break; #endif /* USE_SHA2 */ #ifdef USE_GOST case LDNS_SIGN_ECC_GOST: b64rdf = ldns_sign_public_evp( sign_buf, ldns_key_evp_key(current_key), EVP_get_digestbyname("md_gost94")); break; #endif /* USE_GOST */ #ifdef USE_ECDSA case LDNS_SIGN_ECDSAP256SHA256: b64rdf = ldns_sign_public_evp( sign_buf, ldns_key_evp_key(current_key), EVP_sha256()); break; case LDNS_SIGN_ECDSAP384SHA384: b64rdf = ldns_sign_public_evp( sign_buf, ldns_key_evp_key(current_key), EVP_sha384()); break; #endif case LDNS_SIGN_RSAMD5: b64rdf = ldns_sign_public_evp( sign_buf, ldns_key_evp_key(current_key), EVP_md5()); break; default: /* do _you_ know this alg? */ printf("unknown algorithm, "); printf("is the one used available on this system?\n"); break; } return b64rdf; } /** * use this function to sign with a public/private key alg * return the created signatures */ ldns_rr_list * ldns_sign_public(ldns_rr_list *rrset, ldns_key_list *keys) { ldns_rr_list *signatures; ldns_rr_list *rrset_clone; ldns_rr *current_sig; ldns_rdf *b64rdf; ldns_key *current_key; size_t key_count; uint16_t i; ldns_buffer *sign_buf; ldns_rdf *new_owner; if (!rrset || ldns_rr_list_rr_count(rrset) < 1 || !keys) { return NULL; } new_owner = NULL; signatures = ldns_rr_list_new(); /* prepare a signature and add all the know data * prepare the rrset. Sign this together. */ rrset_clone = ldns_rr_list_clone(rrset); if (!rrset_clone) { return NULL; } /* make it canonical */ for(i = 0; i < ldns_rr_list_rr_count(rrset_clone); i++) { ldns_rr_set_ttl(ldns_rr_list_rr(rrset_clone, i), ldns_rr_ttl(ldns_rr_list_rr(rrset, 0))); ldns_rr2canonical(ldns_rr_list_rr(rrset_clone, i)); } /* sort */ ldns_rr_list_sort(rrset_clone); for (key_count = 0; key_count < ldns_key_list_key_count(keys); key_count++) { if (!ldns_key_use(ldns_key_list_key(keys, key_count))) { continue; } sign_buf = ldns_buffer_new(LDNS_MAX_PACKETLEN); if (!sign_buf) { ldns_rr_list_free(rrset_clone); ldns_rr_list_free(signatures); ldns_rdf_free(new_owner); return NULL; } b64rdf = NULL; current_key = ldns_key_list_key(keys, key_count); /* sign all RRs with keys that have ZSKbit, !SEPbit. sign DNSKEY RRs with keys that have ZSKbit&SEPbit */ if (ldns_key_flags(current_key) & LDNS_KEY_ZONE_KEY) { current_sig = ldns_create_empty_rrsig(rrset_clone, current_key); /* right now, we have: a key, a semi-sig and an rrset. For * which we can create the sig and base64 encode that and * add that to the signature */ if (ldns_rrsig2buffer_wire(sign_buf, current_sig) != LDNS_STATUS_OK) { ldns_buffer_free(sign_buf); /* ERROR */ ldns_rr_list_deep_free(rrset_clone); ldns_rr_free(current_sig); ldns_rr_list_deep_free(signatures); return NULL; } /* add the rrset in sign_buf */ if (ldns_rr_list2buffer_wire(sign_buf, rrset_clone) != LDNS_STATUS_OK) { ldns_buffer_free(sign_buf); ldns_rr_list_deep_free(rrset_clone); ldns_rr_free(current_sig); ldns_rr_list_deep_free(signatures); return NULL; } b64rdf = ldns_sign_public_buffer(sign_buf, current_key); if (!b64rdf) { /* signing went wrong */ ldns_rr_list_deep_free(rrset_clone); ldns_rr_free(current_sig); ldns_rr_list_deep_free(signatures); return NULL; } ldns_rr_rrsig_set_sig(current_sig, b64rdf); /* push the signature to the signatures list */ ldns_rr_list_push_rr(signatures, current_sig); } ldns_buffer_free(sign_buf); /* restart for the next key */ } ldns_rr_list_deep_free(rrset_clone); return signatures; } /** * Sign data with DSA * * \param[in] to_sign The ldns_buffer containing raw data that is * to be signed * \param[in] key The DSA key structure to sign with * \return ldns_rdf for the RRSIG ldns_rr */ ldns_rdf * ldns_sign_public_dsa(ldns_buffer *to_sign, DSA *key) { unsigned char *sha1_hash; ldns_rdf *sigdata_rdf; ldns_buffer *b64sig; DSA_SIG *sig; uint8_t *data; size_t pad; b64sig = ldns_buffer_new(LDNS_MAX_PACKETLEN); if (!b64sig) { return NULL; } sha1_hash = SHA1((unsigned char*)ldns_buffer_begin(to_sign), ldns_buffer_position(to_sign), NULL); if (!sha1_hash) { ldns_buffer_free(b64sig); return NULL; } sig = DSA_do_sign(sha1_hash, SHA_DIGEST_LENGTH, key); if(!sig) { ldns_buffer_free(b64sig); return NULL; } data = LDNS_XMALLOC(uint8_t, 1 + 2 * SHA_DIGEST_LENGTH); if(!data) { ldns_buffer_free(b64sig); DSA_SIG_free(sig); return NULL; } data[0] = 1; pad = 20 - (size_t) BN_num_bytes(sig->r); if (pad > 0) { memset(data + 1, 0, pad); } BN_bn2bin(sig->r, (unsigned char *) (data + 1) + pad); pad = 20 - (size_t) BN_num_bytes(sig->s); if (pad > 0) { memset(data + 1 + SHA_DIGEST_LENGTH, 0, pad); } BN_bn2bin(sig->s, (unsigned char *) (data + 1 + SHA_DIGEST_LENGTH + pad)); sigdata_rdf = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, 1 + 2 * SHA_DIGEST_LENGTH, data); ldns_buffer_free(b64sig); LDNS_FREE(data); DSA_SIG_free(sig); return sigdata_rdf; } #ifdef USE_ECDSA #ifndef S_SPLINT_S static int ldns_pkey_is_ecdsa(EVP_PKEY* pkey) { EC_KEY* ec; const EC_GROUP* g; if(EVP_PKEY_type(pkey->type) != EVP_PKEY_EC) return 0; ec = EVP_PKEY_get1_EC_KEY(pkey); g = EC_KEY_get0_group(ec); if(!g) { EC_KEY_free(ec); return 0; } if(EC_GROUP_get_curve_name(g) == NID_secp224r1 || EC_GROUP_get_curve_name(g) == NID_X9_62_prime256v1 || EC_GROUP_get_curve_name(g) == NID_secp384r1) { EC_KEY_free(ec); return 1; } /* downref the eckey, the original is still inside the pkey */ EC_KEY_free(ec); return 0; } #endif /* splint */ #endif /* USE_ECDSA */ ldns_rdf * ldns_sign_public_evp(ldns_buffer *to_sign, EVP_PKEY *key, const EVP_MD *digest_type) { unsigned int siglen; ldns_rdf *sigdata_rdf; ldns_buffer *b64sig; EVP_MD_CTX ctx; const EVP_MD *md_type; int r; siglen = 0; b64sig = ldns_buffer_new(LDNS_MAX_PACKETLEN); if (!b64sig) { return NULL; } /* initializes a signing context */ md_type = digest_type; if(!md_type) { /* unknown message difest */ ldns_buffer_free(b64sig); return NULL; } EVP_MD_CTX_init(&ctx); r = EVP_SignInit(&ctx, md_type); if(r == 1) { r = EVP_SignUpdate(&ctx, (unsigned char*) ldns_buffer_begin(to_sign), ldns_buffer_position(to_sign)); } else { ldns_buffer_free(b64sig); return NULL; } if(r == 1) { r = EVP_SignFinal(&ctx, (unsigned char*) ldns_buffer_begin(b64sig), &siglen, key); } else { ldns_buffer_free(b64sig); return NULL; } if(r != 1) { ldns_buffer_free(b64sig); return NULL; } /* unfortunately, OpenSSL output is differenct from DNS DSA format */ #ifndef S_SPLINT_S if (EVP_PKEY_type(key->type) == EVP_PKEY_DSA) { sigdata_rdf = ldns_convert_dsa_rrsig_asn12rdf(b64sig, siglen); #ifdef USE_ECDSA } else if(EVP_PKEY_type(key->type) == EVP_PKEY_EC && ldns_pkey_is_ecdsa(key)) { sigdata_rdf = ldns_convert_ecdsa_rrsig_asn12rdf(b64sig, siglen); #endif } else { /* ok output for other types is the same */ sigdata_rdf = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, siglen, ldns_buffer_begin(b64sig)); } #endif /* splint */ ldns_buffer_free(b64sig); EVP_MD_CTX_cleanup(&ctx); return sigdata_rdf; } ldns_rdf * ldns_sign_public_rsasha1(ldns_buffer *to_sign, RSA *key) { unsigned char *sha1_hash; unsigned int siglen; ldns_rdf *sigdata_rdf; ldns_buffer *b64sig; int result; siglen = 0; b64sig = ldns_buffer_new(LDNS_MAX_PACKETLEN); if (!b64sig) { return NULL; } sha1_hash = SHA1((unsigned char*)ldns_buffer_begin(to_sign), ldns_buffer_position(to_sign), NULL); if (!sha1_hash) { ldns_buffer_free(b64sig); return NULL; } result = RSA_sign(NID_sha1, sha1_hash, SHA_DIGEST_LENGTH, (unsigned char*)ldns_buffer_begin(b64sig), &siglen, key); if (result != 1) { ldns_buffer_free(b64sig); return NULL; } sigdata_rdf = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, siglen, ldns_buffer_begin(b64sig)); ldns_buffer_free(b64sig); /* can't free this buffer ?? */ return sigdata_rdf; } ldns_rdf * ldns_sign_public_rsamd5(ldns_buffer *to_sign, RSA *key) { unsigned char *md5_hash; unsigned int siglen; ldns_rdf *sigdata_rdf; ldns_buffer *b64sig; b64sig = ldns_buffer_new(LDNS_MAX_PACKETLEN); if (!b64sig) { return NULL; } md5_hash = MD5((unsigned char*)ldns_buffer_begin(to_sign), ldns_buffer_position(to_sign), NULL); if (!md5_hash) { ldns_buffer_free(b64sig); return NULL; } RSA_sign(NID_md5, md5_hash, MD5_DIGEST_LENGTH, (unsigned char*)ldns_buffer_begin(b64sig), &siglen, key); sigdata_rdf = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, siglen, ldns_buffer_begin(b64sig)); ldns_buffer_free(b64sig); return sigdata_rdf; } #endif /* HAVE_SSL */ /** * Pushes all rrs from the rrsets of type A and AAAA on gluelist. */ static ldns_status ldns_dnssec_addresses_on_glue_list( ldns_dnssec_rrsets *cur_rrset, ldns_rr_list *glue_list) { ldns_dnssec_rrs *cur_rrs; while (cur_rrset) { if (cur_rrset->type == LDNS_RR_TYPE_A || cur_rrset->type == LDNS_RR_TYPE_AAAA) { for (cur_rrs = cur_rrset->rrs; cur_rrs; cur_rrs = cur_rrs->next) { if (cur_rrs->rr) { if (!ldns_rr_list_push_rr(glue_list, cur_rrs->rr)) { return LDNS_STATUS_MEM_ERR; /* ldns_rr_list_push_rr() * returns false when unable * to increase the capacity * of the ldsn_rr_list */ } } } } cur_rrset = cur_rrset->next; } return LDNS_STATUS_OK; } /** * Marks the names in the zone that are occluded. Those names will be skipped * when walking the tree with the ldns_dnssec_name_node_next_nonglue() * function. But watch out! Names that are partially occluded (like glue with * the same name as the delegation) will not be marked and should specifically * be taken into account separately. * * When glue_list is given (not NULL), in the process of marking the names, all * glue resource records will be pushed to that list, even glue at delegation names. * * \param[in] zone the zone in which to mark the names * \param[in] glue_list the list to which to push the glue rrs * \return LDNS_STATUS_OK on success, an error code otherwise */ ldns_status ldns_dnssec_zone_mark_and_get_glue(ldns_dnssec_zone *zone, ldns_rr_list *glue_list) { ldns_rbnode_t *node; ldns_dnssec_name *name; ldns_rdf *owner; ldns_rdf *cut = NULL; /* keeps track of zone cuts */ /* When the cut is caused by a delegation, below_delegation will be 1. * When caused by a DNAME, below_delegation will be 0. */ int below_delegation = -1; /* init suppresses comiler warning */ ldns_status s; if (!zone || !zone->names) { return LDNS_STATUS_NULL; } for (node = ldns_rbtree_first(zone->names); node != LDNS_RBTREE_NULL; node = ldns_rbtree_next(node)) { name = (ldns_dnssec_name *) node->data; owner = ldns_dnssec_name_name(name); if (cut) { /* The previous node was a zone cut, or a subdomain * below a zone cut. Is this node (still) a subdomain * below the cut? Then the name is occluded. Unless * the name contains a SOA, after which we are * authoritative again. * * FIXME! If there are labels in between the SOA and * the cut, going from the authoritative space (below * the SOA) up into occluded space again, will not be * detected with the contruct below! */ if (ldns_dname_is_subdomain(owner, cut) && !ldns_dnssec_rrsets_contains_type( name->rrsets, LDNS_RR_TYPE_SOA)) { if (below_delegation && glue_list) { s = ldns_dnssec_addresses_on_glue_list( name->rrsets, glue_list); if (s != LDNS_STATUS_OK) { return s; } } name->is_glue = true; /* Mark occluded name! */ continue; } else { cut = NULL; } } /* The node is not below a zone cut. Is it a zone cut itself? * Everything below a SOA is authoritative of course; Except * when the name also contains a DNAME :). */ if (ldns_dnssec_rrsets_contains_type( name->rrsets, LDNS_RR_TYPE_NS) && !ldns_dnssec_rrsets_contains_type( name->rrsets, LDNS_RR_TYPE_SOA)) { cut = owner; below_delegation = 1; if (glue_list) { /* record glue on the zone cut */ s = ldns_dnssec_addresses_on_glue_list( name->rrsets, glue_list); if (s != LDNS_STATUS_OK) { return s; } } } else if (ldns_dnssec_rrsets_contains_type( name->rrsets, LDNS_RR_TYPE_DNAME)) { cut = owner; below_delegation = 0; } } return LDNS_STATUS_OK; } /** * Marks the names in the zone that are occluded. Those names will be skipped * when walking the tree with the ldns_dnssec_name_node_next_nonglue() * function. But watch out! Names that are partially occluded (like glue with * the same name as the delegation) will not be marked and should specifically * be taken into account separately. * * \param[in] zone the zone in which to mark the names * \return LDNS_STATUS_OK on success, an error code otherwise */ ldns_status ldns_dnssec_zone_mark_glue(ldns_dnssec_zone *zone) { return ldns_dnssec_zone_mark_and_get_glue(zone, NULL); } ldns_rbnode_t * ldns_dnssec_name_node_next_nonglue(ldns_rbnode_t *node) { ldns_rbnode_t *next_node = NULL; ldns_dnssec_name *next_name = NULL; bool done = false; if (node == LDNS_RBTREE_NULL) { return NULL; } next_node = node; while (!done) { if (next_node == LDNS_RBTREE_NULL) { return NULL; } else { next_name = (ldns_dnssec_name *)next_node->data; if (!next_name->is_glue) { done = true; } else { next_node = ldns_rbtree_next(next_node); } } } return next_node; } ldns_status ldns_dnssec_zone_create_nsecs(ldns_dnssec_zone *zone, ldns_rr_list *new_rrs) { ldns_rbnode_t *first_node, *cur_node, *next_node; ldns_dnssec_name *cur_name, *next_name; ldns_rr *nsec_rr; uint32_t nsec_ttl; ldns_dnssec_rrsets *soa; /* the TTL of NSEC rrs should be set to the minimum TTL of * the zone SOA (RFC4035 Section 2.3) */ soa = ldns_dnssec_name_find_rrset(zone->soa, LDNS_RR_TYPE_SOA); /* did the caller actually set it? if not, * fall back to default ttl */ if (soa && soa->rrs && soa->rrs->rr && (ldns_rr_rdf(soa->rrs->rr, 6) != NULL)) { nsec_ttl = ldns_rdf2native_int32(ldns_rr_rdf(soa->rrs->rr, 6)); } else { nsec_ttl = LDNS_DEFAULT_TTL; } first_node = ldns_dnssec_name_node_next_nonglue( ldns_rbtree_first(zone->names)); cur_node = first_node; if (cur_node) { next_node = ldns_dnssec_name_node_next_nonglue( ldns_rbtree_next(cur_node)); } else { next_node = NULL; } while (cur_node && next_node) { cur_name = (ldns_dnssec_name *)cur_node->data; next_name = (ldns_dnssec_name *)next_node->data; nsec_rr = ldns_dnssec_create_nsec(cur_name, next_name, LDNS_RR_TYPE_NSEC); ldns_rr_set_ttl(nsec_rr, nsec_ttl); if(ldns_dnssec_name_add_rr(cur_name, nsec_rr)!=LDNS_STATUS_OK){ ldns_rr_free(nsec_rr); return LDNS_STATUS_ERR; } ldns_rr_list_push_rr(new_rrs, nsec_rr); cur_node = next_node; if (cur_node) { next_node = ldns_dnssec_name_node_next_nonglue( ldns_rbtree_next(cur_node)); } } if (cur_node && !next_node) { cur_name = (ldns_dnssec_name *)cur_node->data; next_name = (ldns_dnssec_name *)first_node->data; nsec_rr = ldns_dnssec_create_nsec(cur_name, next_name, LDNS_RR_TYPE_NSEC); ldns_rr_set_ttl(nsec_rr, nsec_ttl); if(ldns_dnssec_name_add_rr(cur_name, nsec_rr)!=LDNS_STATUS_OK){ ldns_rr_free(nsec_rr); return LDNS_STATUS_ERR; } ldns_rr_list_push_rr(new_rrs, nsec_rr); } else { printf("error\n"); } return LDNS_STATUS_OK; } #ifdef HAVE_SSL static void ldns_hashed_names_node_free(ldns_rbnode_t *node, void *arg) { (void) arg; LDNS_FREE(node); } static ldns_status ldns_dnssec_zone_create_nsec3s_mkmap(ldns_dnssec_zone *zone, ldns_rr_list *new_rrs, uint8_t algorithm, uint8_t flags, uint16_t iterations, uint8_t salt_length, uint8_t *salt, ldns_rbtree_t **map) { ldns_rbnode_t *first_name_node; ldns_rbnode_t *current_name_node; ldns_dnssec_name *current_name; ldns_status result = LDNS_STATUS_OK; ldns_rr *nsec_rr; ldns_rr_list *nsec3_list; uint32_t nsec_ttl; ldns_dnssec_rrsets *soa; ldns_rbnode_t *hashmap_node; if (!zone || !new_rrs || !zone->names) { return LDNS_STATUS_ERR; } /* the TTL of NSEC rrs should be set to the minimum TTL of * the zone SOA (RFC4035 Section 2.3) */ soa = ldns_dnssec_name_find_rrset(zone->soa, LDNS_RR_TYPE_SOA); /* did the caller actually set it? if not, * fall back to default ttl */ if (soa && soa->rrs && soa->rrs->rr && ldns_rr_rdf(soa->rrs->rr, 6) != NULL) { nsec_ttl = ldns_rdf2native_int32(ldns_rr_rdf(soa->rrs->rr, 6)); } else { nsec_ttl = LDNS_DEFAULT_TTL; } if (zone->hashed_names) { ldns_traverse_postorder(zone->hashed_names, ldns_hashed_names_node_free, NULL); LDNS_FREE(zone->hashed_names); } zone->hashed_names = ldns_rbtree_create(ldns_dname_compare_v); if (zone->hashed_names && map) { *map = zone->hashed_names; } first_name_node = ldns_dnssec_name_node_next_nonglue( ldns_rbtree_first(zone->names)); current_name_node = first_name_node; while (current_name_node && current_name_node != LDNS_RBTREE_NULL && result == LDNS_STATUS_OK) { current_name = (ldns_dnssec_name *) current_name_node->data; nsec_rr = ldns_dnssec_create_nsec3(current_name, NULL, zone->soa->name, algorithm, flags, iterations, salt_length, salt); /* by default, our nsec based generator adds rrsigs * remove the bitmap for empty nonterminals */ if (!current_name->rrsets) { ldns_rdf_deep_free(ldns_rr_pop_rdf(nsec_rr)); } ldns_rr_set_ttl(nsec_rr, nsec_ttl); result = ldns_dnssec_name_add_rr(current_name, nsec_rr); ldns_rr_list_push_rr(new_rrs, nsec_rr); if (ldns_rr_owner(nsec_rr)) { hashmap_node = LDNS_MALLOC(ldns_rbnode_t); if (hashmap_node == NULL) { return LDNS_STATUS_MEM_ERR; } current_name->hashed_name = ldns_dname_label(ldns_rr_owner(nsec_rr), 0); if (current_name->hashed_name == NULL) { LDNS_FREE(hashmap_node); return LDNS_STATUS_MEM_ERR; } hashmap_node->key = current_name->hashed_name; hashmap_node->data = current_name; if (! ldns_rbtree_insert(zone->hashed_names , hashmap_node)) { LDNS_FREE(hashmap_node); } } current_name_node = ldns_dnssec_name_node_next_nonglue( ldns_rbtree_next(current_name_node)); } if (result != LDNS_STATUS_OK) { return result; } /* Make sorted list of nsec3s (via zone->hashed_names) */ nsec3_list = ldns_rr_list_new(); if (nsec3_list == NULL) { return LDNS_STATUS_MEM_ERR; } for ( hashmap_node = ldns_rbtree_first(zone->hashed_names) ; hashmap_node != LDNS_RBTREE_NULL ; hashmap_node = ldns_rbtree_next(hashmap_node) ) { current_name = (ldns_dnssec_name *) hashmap_node->data; nsec_rr = ((ldns_dnssec_name *) hashmap_node->data)->nsec; if (nsec_rr) { ldns_rr_list_push_rr(nsec3_list, nsec_rr); } } result = ldns_dnssec_chain_nsec3_list(nsec3_list); ldns_rr_list_free(nsec3_list); return result; } ldns_status ldns_dnssec_zone_create_nsec3s(ldns_dnssec_zone *zone, ldns_rr_list *new_rrs, uint8_t algorithm, uint8_t flags, uint16_t iterations, uint8_t salt_length, uint8_t *salt) { return ldns_dnssec_zone_create_nsec3s_mkmap(zone, new_rrs, algorithm, flags, iterations, salt_length, salt, NULL); } #endif /* HAVE_SSL */ ldns_dnssec_rrs * ldns_dnssec_remove_signatures( ldns_dnssec_rrs *signatures , ATTR_UNUSED(ldns_key_list *key_list) , int (*func)(ldns_rr *, void *) , void *arg ) { ldns_dnssec_rrs *base_rrs = signatures; ldns_dnssec_rrs *cur_rr = base_rrs; ldns_dnssec_rrs *prev_rr = NULL; ldns_dnssec_rrs *next_rr; uint16_t keytag; size_t i; if (!cur_rr) { switch(func(NULL, arg)) { case LDNS_SIGNATURE_LEAVE_ADD_NEW: case LDNS_SIGNATURE_REMOVE_ADD_NEW: break; case LDNS_SIGNATURE_LEAVE_NO_ADD: case LDNS_SIGNATURE_REMOVE_NO_ADD: ldns_key_list_set_use(key_list, false); break; default: #ifdef STDERR_MSGS fprintf(stderr, "[XX] unknown return value from callback\n"); #endif break; } return NULL; } (void)func(cur_rr->rr, arg); while (cur_rr) { next_rr = cur_rr->next; switch (func(cur_rr->rr, arg)) { case LDNS_SIGNATURE_LEAVE_ADD_NEW: prev_rr = cur_rr; break; case LDNS_SIGNATURE_LEAVE_NO_ADD: keytag = ldns_rdf2native_int16( ldns_rr_rrsig_keytag(cur_rr->rr)); for (i = 0; i < ldns_key_list_key_count(key_list); i++) { if (ldns_key_keytag(ldns_key_list_key(key_list, i)) == keytag) { ldns_key_set_use(ldns_key_list_key(key_list, i), false); } } prev_rr = cur_rr; break; case LDNS_SIGNATURE_REMOVE_NO_ADD: keytag = ldns_rdf2native_int16( ldns_rr_rrsig_keytag(cur_rr->rr)); for (i = 0; i < ldns_key_list_key_count(key_list); i++) { if (ldns_key_keytag(ldns_key_list_key(key_list, i)) == keytag) { ldns_key_set_use(ldns_key_list_key(key_list, i), false); } } if (prev_rr) { prev_rr->next = next_rr; } else { base_rrs = next_rr; } LDNS_FREE(cur_rr); break; case LDNS_SIGNATURE_REMOVE_ADD_NEW: if (prev_rr) { prev_rr->next = next_rr; } else { base_rrs = next_rr; } LDNS_FREE(cur_rr); break; default: #ifdef STDERR_MSGS fprintf(stderr, "[XX] unknown return value from callback\n"); #endif break; } cur_rr = next_rr; } return base_rrs; } #ifdef HAVE_SSL ldns_status ldns_dnssec_zone_create_rrsigs(ldns_dnssec_zone *zone, ldns_rr_list *new_rrs, ldns_key_list *key_list, int (*func)(ldns_rr *, void*), void *arg) { return ldns_dnssec_zone_create_rrsigs_flg(zone, new_rrs, key_list, func, arg, 0); } /** If there are KSKs use only them and mark ZSKs unused */ static void ldns_key_list_filter_for_dnskey(ldns_key_list *key_list) { int saw_ksk = 0; size_t i; for(i=0; inames); while (cur_node != LDNS_RBTREE_NULL) { cur_name = (ldns_dnssec_name *) cur_node->data; if (!cur_name->is_glue) { on_delegation_point = ldns_dnssec_rrsets_contains_type( cur_name->rrsets, LDNS_RR_TYPE_NS) && !ldns_dnssec_rrsets_contains_type( cur_name->rrsets, LDNS_RR_TYPE_SOA); cur_rrset = cur_name->rrsets; while (cur_rrset) { /* reset keys to use */ ldns_key_list_set_use(key_list, true); /* walk through old sigs, remove the old, and mark which keys (not) to use) */ cur_rrset->signatures = ldns_dnssec_remove_signatures(cur_rrset->signatures, key_list, func, arg); if(!(flags&LDNS_SIGN_DNSKEY_WITH_ZSK) && cur_rrset->type == LDNS_RR_TYPE_DNSKEY) ldns_key_list_filter_for_dnskey(key_list); if(cur_rrset->type != LDNS_RR_TYPE_DNSKEY) ldns_key_list_filter_for_non_dnskey(key_list); /* TODO: just set count to zero? */ rr_list = ldns_rr_list_new(); cur_rr = cur_rrset->rrs; while (cur_rr) { ldns_rr_list_push_rr(rr_list, cur_rr->rr); cur_rr = cur_rr->next; } /* only sign non-delegation RRsets */ /* (glue should have been marked earlier, * except on the delegation points itself) */ if (!on_delegation_point || ldns_rr_list_type(rr_list) == LDNS_RR_TYPE_DS || ldns_rr_list_type(rr_list) == LDNS_RR_TYPE_NSEC || ldns_rr_list_type(rr_list) == LDNS_RR_TYPE_NSEC3) { siglist = ldns_sign_public(rr_list, key_list); for (i = 0; i < ldns_rr_list_rr_count(siglist); i++) { if (cur_rrset->signatures) { result = ldns_dnssec_rrs_add_rr(cur_rrset->signatures, ldns_rr_list_rr(siglist, i)); } else { cur_rrset->signatures = ldns_dnssec_rrs_new(); cur_rrset->signatures->rr = ldns_rr_list_rr(siglist, i); } if (new_rrs) { ldns_rr_list_push_rr(new_rrs, ldns_rr_list_rr(siglist, i)); } } ldns_rr_list_free(siglist); } ldns_rr_list_free(rr_list); cur_rrset = cur_rrset->next; } /* sign the nsec */ ldns_key_list_set_use(key_list, true); cur_name->nsec_signatures = ldns_dnssec_remove_signatures(cur_name->nsec_signatures, key_list, func, arg); ldns_key_list_filter_for_non_dnskey(key_list); rr_list = ldns_rr_list_new(); ldns_rr_list_push_rr(rr_list, cur_name->nsec); siglist = ldns_sign_public(rr_list, key_list); for (i = 0; i < ldns_rr_list_rr_count(siglist); i++) { if (cur_name->nsec_signatures) { result = ldns_dnssec_rrs_add_rr(cur_name->nsec_signatures, ldns_rr_list_rr(siglist, i)); } else { cur_name->nsec_signatures = ldns_dnssec_rrs_new(); cur_name->nsec_signatures->rr = ldns_rr_list_rr(siglist, i); } if (new_rrs) { ldns_rr_list_push_rr(new_rrs, ldns_rr_list_rr(siglist, i)); } } ldns_rr_list_free(siglist); ldns_rr_list_free(rr_list); } cur_node = ldns_rbtree_next(cur_node); } ldns_rr_list_deep_free(pubkey_list); return result; } ldns_status ldns_dnssec_zone_sign(ldns_dnssec_zone *zone, ldns_rr_list *new_rrs, ldns_key_list *key_list, int (*func)(ldns_rr *, void *), void *arg) { return ldns_dnssec_zone_sign_flg(zone, new_rrs, key_list, func, arg, 0); } ldns_status ldns_dnssec_zone_sign_flg(ldns_dnssec_zone *zone, ldns_rr_list *new_rrs, ldns_key_list *key_list, int (*func)(ldns_rr *, void *), void *arg, int flags) { ldns_status result = LDNS_STATUS_OK; if (!zone || !new_rrs || !key_list) { return LDNS_STATUS_ERR; } /* zone is already sorted */ result = ldns_dnssec_zone_mark_glue(zone); if (result != LDNS_STATUS_OK) { return result; } /* check whether we need to add nsecs */ if (zone->names && !((ldns_dnssec_name *)zone->names->root->data)->nsec) { result = ldns_dnssec_zone_create_nsecs(zone, new_rrs); if (result != LDNS_STATUS_OK) { return result; } } result = ldns_dnssec_zone_create_rrsigs_flg(zone, new_rrs, key_list, func, arg, flags); return result; } ldns_status ldns_dnssec_zone_sign_nsec3(ldns_dnssec_zone *zone, ldns_rr_list *new_rrs, ldns_key_list *key_list, int (*func)(ldns_rr *, void *), void *arg, uint8_t algorithm, uint8_t flags, uint16_t iterations, uint8_t salt_length, uint8_t *salt) { return ldns_dnssec_zone_sign_nsec3_flg_mkmap(zone, new_rrs, key_list, func, arg, algorithm, flags, iterations, salt_length, salt, 0, NULL); } ldns_status ldns_dnssec_zone_sign_nsec3_flg_mkmap(ldns_dnssec_zone *zone, ldns_rr_list *new_rrs, ldns_key_list *key_list, int (*func)(ldns_rr *, void *), void *arg, uint8_t algorithm, uint8_t flags, uint16_t iterations, uint8_t salt_length, uint8_t *salt, int signflags, ldns_rbtree_t **map) { ldns_rr *nsec3, *nsec3param; ldns_status result = LDNS_STATUS_OK; /* zone is already sorted */ result = ldns_dnssec_zone_mark_glue(zone); if (result != LDNS_STATUS_OK) { return result; } /* TODO if there are already nsec3s presents and their * parameters are the same as these, we don't have to recreate */ if (zone->names) { /* add empty nonterminals */ result = ldns_dnssec_zone_add_empty_nonterminals(zone); if (result != LDNS_STATUS_OK) { return result; } nsec3 = ((ldns_dnssec_name *)zone->names->root->data)->nsec; if (nsec3 && ldns_rr_get_type(nsec3) == LDNS_RR_TYPE_NSEC3) { /* no need to recreate */ } else { if (!ldns_dnssec_zone_find_rrset(zone, zone->soa->name, LDNS_RR_TYPE_NSEC3PARAM)) { /* create and add the nsec3param rr */ nsec3param = ldns_rr_new_frm_type(LDNS_RR_TYPE_NSEC3PARAM); ldns_rr_set_owner(nsec3param, ldns_rdf_clone(zone->soa->name)); ldns_nsec3_add_param_rdfs(nsec3param, algorithm, flags, iterations, salt_length, salt); /* always set bit 7 of the flags to zero, according to * rfc5155 section 11. The bits are counted from right to left, * so bit 7 in rfc5155 is bit 0 in ldns */ ldns_set_bit(ldns_rdf_data(ldns_rr_rdf(nsec3param, 1)), 0, 0); result = ldns_dnssec_zone_add_rr(zone, nsec3param); if (result != LDNS_STATUS_OK) { return result; } ldns_rr_list_push_rr(new_rrs, nsec3param); } result = ldns_dnssec_zone_create_nsec3s_mkmap(zone, new_rrs, algorithm, flags, iterations, salt_length, salt, map); if (result != LDNS_STATUS_OK) { return result; } } result = ldns_dnssec_zone_create_rrsigs_flg(zone, new_rrs, key_list, func, arg, signflags); } return result; } ldns_status ldns_dnssec_zone_sign_nsec3_flg(ldns_dnssec_zone *zone, ldns_rr_list *new_rrs, ldns_key_list *key_list, int (*func)(ldns_rr *, void *), void *arg, uint8_t algorithm, uint8_t flags, uint16_t iterations, uint8_t salt_length, uint8_t *salt, int signflags) { return ldns_dnssec_zone_sign_nsec3_flg_mkmap(zone, new_rrs, key_list, func, arg, algorithm, flags, iterations, salt_length, salt, signflags, NULL); } ldns_zone * ldns_zone_sign(const ldns_zone *zone, ldns_key_list *key_list) { ldns_dnssec_zone *dnssec_zone; ldns_zone *signed_zone; ldns_rr_list *new_rrs; size_t i; signed_zone = ldns_zone_new(); dnssec_zone = ldns_dnssec_zone_new(); (void) ldns_dnssec_zone_add_rr(dnssec_zone, ldns_zone_soa(zone)); ldns_zone_set_soa(signed_zone, ldns_rr_clone(ldns_zone_soa(zone))); for (i = 0; i < ldns_rr_list_rr_count(ldns_zone_rrs(zone)); i++) { (void) ldns_dnssec_zone_add_rr(dnssec_zone, ldns_rr_list_rr(ldns_zone_rrs(zone), i)); ldns_zone_push_rr(signed_zone, ldns_rr_clone(ldns_rr_list_rr(ldns_zone_rrs(zone), i))); } new_rrs = ldns_rr_list_new(); (void) ldns_dnssec_zone_sign(dnssec_zone, new_rrs, key_list, ldns_dnssec_default_replace_signatures, NULL); for (i = 0; i < ldns_rr_list_rr_count(new_rrs); i++) { ldns_rr_list_push_rr(ldns_zone_rrs(signed_zone), ldns_rr_clone(ldns_rr_list_rr(new_rrs, i))); } ldns_rr_list_deep_free(new_rrs); ldns_dnssec_zone_free(dnssec_zone); return signed_zone; } ldns_zone * ldns_zone_sign_nsec3(ldns_zone *zone, ldns_key_list *key_list, uint8_t algorithm, uint8_t flags, uint16_t iterations, uint8_t salt_length, uint8_t *salt) { ldns_dnssec_zone *dnssec_zone; ldns_zone *signed_zone; ldns_rr_list *new_rrs; size_t i; signed_zone = ldns_zone_new(); dnssec_zone = ldns_dnssec_zone_new(); (void) ldns_dnssec_zone_add_rr(dnssec_zone, ldns_zone_soa(zone)); ldns_zone_set_soa(signed_zone, ldns_rr_clone(ldns_zone_soa(zone))); for (i = 0; i < ldns_rr_list_rr_count(ldns_zone_rrs(zone)); i++) { (void) ldns_dnssec_zone_add_rr(dnssec_zone, ldns_rr_list_rr(ldns_zone_rrs(zone), i)); ldns_zone_push_rr(signed_zone, ldns_rr_clone(ldns_rr_list_rr(ldns_zone_rrs(zone), i))); } new_rrs = ldns_rr_list_new(); (void) ldns_dnssec_zone_sign_nsec3(dnssec_zone, new_rrs, key_list, ldns_dnssec_default_replace_signatures, NULL, algorithm, flags, iterations, salt_length, salt); for (i = 0; i < ldns_rr_list_rr_count(new_rrs); i++) { ldns_rr_list_push_rr(ldns_zone_rrs(signed_zone), ldns_rr_clone(ldns_rr_list_rr(new_rrs, i))); } ldns_rr_list_deep_free(new_rrs); ldns_dnssec_zone_free(dnssec_zone); return signed_zone; } #endif /* HAVE_SSL */ ldns-1.6.17/parse.c0000664000175100017510000002060412264060151013373 0ustar willemwillem/* * a generic (simple) parser. Use to parse rr's, private key * information and /etc/resolv.conf files * * a Net::DNS like library for C * LibDNS Team @ NLnet Labs * (c) NLnet Labs, 2005-2006 * See the file LICENSE for the license */ #include #include #include #include ldns_lookup_table ldns_directive_types[] = { { LDNS_DIR_TTL, "$TTL" }, { LDNS_DIR_ORIGIN, "$ORIGIN" }, { LDNS_DIR_INCLUDE, "$INCLUDE" }, { 0, NULL } }; /* add max_limit here? */ ssize_t ldns_fget_token(FILE *f, char *token, const char *delim, size_t limit) { return ldns_fget_token_l(f, token, delim, limit, NULL); } ssize_t ldns_fget_token_l(FILE *f, char *token, const char *delim, size_t limit, int *line_nr) { int c, prev_c; int p; /* 0 -> no parenthese seen, >0 nr of ( seen */ int com, quoted; char *t; size_t i; const char *d; const char *del; /* standard delimeters */ if (!delim) { /* from isspace(3) */ del = LDNS_PARSE_NORMAL; } else { del = delim; } p = 0; i = 0; com = 0; quoted = 0; prev_c = 0; t = token; if (del[0] == '"') { quoted = 1; } while ((c = getc(f)) != EOF) { if (c == '\r') /* carriage return */ c = ' '; if (c == '(' && prev_c != '\\' && !quoted) { /* this only counts for non-comments */ if (com == 0) { p++; } prev_c = c; continue; } if (c == ')' && prev_c != '\\' && !quoted) { /* this only counts for non-comments */ if (com == 0) { p--; } prev_c = c; continue; } if (p < 0) { /* more ) then ( - close off the string */ *t = '\0'; return 0; } /* do something with comments ; */ if (c == ';' && quoted == 0) { if (prev_c != '\\') { com = 1; } } if (c == '\"' && com == 0 && prev_c != '\\') { quoted = 1 - quoted; } if (c == '\n' && com != 0) { /* comments */ com = 0; *t = ' '; if (line_nr) { *line_nr = *line_nr + 1; } if (p == 0 && i > 0) { goto tokenread; } else { prev_c = c; continue; } } if (com == 1) { *t = ' '; prev_c = c; continue; } if (c == '\n' && p != 0 && t > token) { /* in parentheses */ if (line_nr) { *line_nr = *line_nr + 1; } *t++ = ' '; prev_c = c; continue; } /* check if we hit the delim */ for (d = del; *d; d++) { if (c == *d && i > 0 && prev_c != '\\' && p == 0) { if (c == '\n' && line_nr) { *line_nr = *line_nr + 1; } goto tokenread; } } if (c != '\0' && c != '\n') { i++; } if (limit > 0 && (i >= limit || (size_t)(t-token) >= limit)) { *t = '\0'; return -1; } if (c != '\0' && c != '\n') { *t++ = c; } if (c == '\\' && prev_c == '\\') prev_c = 0; else prev_c = c; } *t = '\0'; if (c == EOF) { return (ssize_t)i; } if (i == 0) { /* nothing read */ return -1; } if (p != 0) { return -1; } return (ssize_t)i; tokenread: ldns_fskipcs_l(f, del, line_nr); *t = '\0'; if (p != 0) { return -1; } return (ssize_t)i; } ssize_t ldns_fget_keyword_data(FILE *f, const char *keyword, const char *k_del, char *data, const char *d_del, size_t data_limit) { return ldns_fget_keyword_data_l(f, keyword, k_del, data, d_del, data_limit, NULL); } ssize_t ldns_fget_keyword_data_l(FILE *f, const char *keyword, const char *k_del, char *data, const char *d_del, size_t data_limit, int *line_nr) { /* we assume: keyword|sep|data */ char *fkeyword; ssize_t i; if(strlen(keyword) >= LDNS_MAX_KEYWORDLEN) return -1; fkeyword = LDNS_XMALLOC(char, LDNS_MAX_KEYWORDLEN); if(!fkeyword) return -1; i = ldns_fget_token(f, fkeyword, k_del, LDNS_MAX_KEYWORDLEN); if(i==0 || i==-1) { LDNS_FREE(fkeyword); return -1; } /* case??? i instead of strlen? */ if (strncmp(fkeyword, keyword, LDNS_MAX_KEYWORDLEN - 1) == 0) { /* whee! */ /* printf("%s\n%s\n", "Matching keyword", fkeyword); */ i = ldns_fget_token_l(f, data, d_del, data_limit, line_nr); LDNS_FREE(fkeyword); return i; } else { /*printf("no match for %s (read: %s)\n", keyword, fkeyword);*/ LDNS_FREE(fkeyword); return -1; } } ssize_t ldns_bget_token(ldns_buffer *b, char *token, const char *delim, size_t limit) { int c, lc; int p; /* 0 -> no parenthese seen, >0 nr of ( seen */ int com, quoted; char *t; size_t i; const char *d; const char *del; /* standard delimiters */ if (!delim) { /* from isspace(3) */ del = LDNS_PARSE_NORMAL; } else { del = delim; } p = 0; i = 0; com = 0; quoted = 0; t = token; lc = 0; if (del[0] == '"') { quoted = 1; } while ((c = ldns_bgetc(b)) != EOF) { if (c == '\r') /* carriage return */ c = ' '; if (c == '(' && lc != '\\' && !quoted) { /* this only counts for non-comments */ if (com == 0) { p++; } lc = c; continue; } if (c == ')' && lc != '\\' && !quoted) { /* this only counts for non-comments */ if (com == 0) { p--; } lc = c; continue; } if (p < 0) { /* more ) then ( */ *t = '\0'; return 0; } /* do something with comments ; */ if (c == ';' && quoted == 0) { if (lc != '\\') { com = 1; } } if (c == '"' && com == 0 && lc != '\\') { quoted = 1 - quoted; } if (c == '\n' && com != 0) { /* comments */ com = 0; *t = ' '; lc = c; continue; } if (com == 1) { *t = ' '; lc = c; continue; } if (c == '\n' && p != 0) { /* in parentheses */ *t++ = ' '; lc = c; continue; } /* check if we hit the delim */ for (d = del; *d; d++) { if (c == *d && lc != '\\' && p == 0) { goto tokenread; } } i++; if (limit > 0 && (i >= limit || (size_t)(t-token) >= limit)) { *t = '\0'; return -1; } *t++ = c; if (c == '\\' && lc == '\\') { lc = 0; } else { lc = c; } } *t = '\0'; if (i == 0) { /* nothing read */ return -1; } if (p != 0) { return -1; } return (ssize_t)i; tokenread: ldns_bskipcs(b, del); *t = '\0'; if (p != 0) { return -1; } return (ssize_t)i; } void ldns_bskipcs(ldns_buffer *buffer, const char *s) { bool found; char c; const char *d; while(ldns_buffer_available_at(buffer, buffer->_position, sizeof(char))) { c = (char) ldns_buffer_read_u8_at(buffer, buffer->_position); found = false; for (d = s; *d; d++) { if (*d == c) { found = true; } } if (found && buffer->_limit > buffer->_position) { buffer->_position += sizeof(char); } else { return; } } } void ldns_fskipcs(FILE *fp, const char *s) { ldns_fskipcs_l(fp, s, NULL); } void ldns_fskipcs_l(FILE *fp, const char *s, int *line_nr) { bool found; int c; const char *d; while ((c = fgetc(fp)) != EOF) { if (line_nr && c == '\n') { *line_nr = *line_nr + 1; } found = false; for (d = s; *d; d++) { if (*d == c) { found = true; } } if (!found) { /* with getc, we've read too far */ ungetc(c, fp); return; } } } ssize_t ldns_bget_keyword_data(ldns_buffer *b, const char *keyword, const char *k_del, char *data, const char *d_del, size_t data_limit) { /* we assume: keyword|sep|data */ char *fkeyword; ssize_t i; if(strlen(keyword) >= LDNS_MAX_KEYWORDLEN) return -1; fkeyword = LDNS_XMALLOC(char, LDNS_MAX_KEYWORDLEN); if(!fkeyword) return -1; /* out of memory */ i = ldns_bget_token(b, fkeyword, k_del, data_limit); if(i==0 || i==-1) { LDNS_FREE(fkeyword); return -1; /* nothing read */ } /* case??? */ if (strncmp(fkeyword, keyword, strlen(keyword)) == 0) { LDNS_FREE(fkeyword); /* whee, the match! */ /* retrieve it's data */ i = ldns_bget_token(b, data, d_del, 0); return i; } else { LDNS_FREE(fkeyword); return -1; } } ldns-1.6.17/buffer.c0000664000175100017510000000735112264060151013536 0ustar willemwillem/* * buffer.c -- generic memory buffer . * * Copyright (c) 2001-2008, NLnet Labs. All rights reserved. * * See LICENSE for the license. * */ #include #include #include ldns_buffer * ldns_buffer_new(size_t capacity) { ldns_buffer *buffer = LDNS_MALLOC(ldns_buffer); if (!buffer) { return NULL; } buffer->_data = (uint8_t *) LDNS_XMALLOC(uint8_t, capacity); if (!buffer->_data) { LDNS_FREE(buffer); return NULL; } buffer->_position = 0; buffer->_limit = buffer->_capacity = capacity; buffer->_fixed = 0; buffer->_status = LDNS_STATUS_OK; ldns_buffer_invariant(buffer); return buffer; } void ldns_buffer_new_frm_data(ldns_buffer *buffer, void *data, size_t size) { assert(data != NULL); buffer->_position = 0; buffer->_limit = buffer->_capacity = size; buffer->_fixed = 0; buffer->_data = LDNS_XMALLOC(uint8_t, size); if(!buffer->_data) { buffer->_status = LDNS_STATUS_MEM_ERR; return; } memcpy(buffer->_data, data, size); buffer->_status = LDNS_STATUS_OK; ldns_buffer_invariant(buffer); } bool ldns_buffer_set_capacity(ldns_buffer *buffer, size_t capacity) { void *data; ldns_buffer_invariant(buffer); assert(buffer->_position <= capacity); data = (uint8_t *) LDNS_XREALLOC(buffer->_data, uint8_t, capacity); if (!data) { buffer->_status = LDNS_STATUS_MEM_ERR; return false; } else { buffer->_data = data; buffer->_limit = buffer->_capacity = capacity; return true; } } bool ldns_buffer_reserve(ldns_buffer *buffer, size_t amount) { ldns_buffer_invariant(buffer); assert(!buffer->_fixed); if (buffer->_capacity < buffer->_position + amount) { size_t new_capacity = buffer->_capacity * 3 / 2; if (new_capacity < buffer->_position + amount) { new_capacity = buffer->_position + amount; } if (!ldns_buffer_set_capacity(buffer, new_capacity)) { buffer->_status = LDNS_STATUS_MEM_ERR; return false; } } buffer->_limit = buffer->_capacity; return true; } int ldns_buffer_printf(ldns_buffer *buffer, const char *format, ...) { va_list args; int written = 0; size_t remaining; if (ldns_buffer_status_ok(buffer)) { ldns_buffer_invariant(buffer); assert(buffer->_limit == buffer->_capacity); remaining = ldns_buffer_remaining(buffer); va_start(args, format); written = vsnprintf((char *) ldns_buffer_current(buffer), remaining, format, args); va_end(args); if (written == -1) { buffer->_status = LDNS_STATUS_INTERNAL_ERR; return -1; } else if ((size_t) written >= remaining) { if (!ldns_buffer_reserve(buffer, (size_t) written + 1)) { buffer->_status = LDNS_STATUS_MEM_ERR; return -1; } va_start(args, format); written = vsnprintf((char *) ldns_buffer_current(buffer), ldns_buffer_remaining(buffer), format, args); va_end(args); if (written == -1) { buffer->_status = LDNS_STATUS_INTERNAL_ERR; return -1; } } buffer->_position += written; } return written; } void ldns_buffer_free(ldns_buffer *buffer) { if (!buffer) { return; } if (!buffer->_fixed) LDNS_FREE(buffer->_data); LDNS_FREE(buffer); } void * ldns_buffer_export(ldns_buffer *buffer) { buffer->_fixed = 1; return buffer->_data; } int ldns_bgetc(ldns_buffer *buffer) { if (!ldns_buffer_available_at(buffer, buffer->_position, sizeof(uint8_t))) { ldns_buffer_set_position(buffer, ldns_buffer_limit(buffer)); /* ldns_buffer_rewind(buffer);*/ return EOF; } return (int)ldns_buffer_read_u8(buffer); } void ldns_buffer_copy(ldns_buffer* result, ldns_buffer* from) { size_t tocopy = ldns_buffer_limit(from); if(tocopy > ldns_buffer_capacity(result)) tocopy = ldns_buffer_capacity(result); ldns_buffer_clear(result); ldns_buffer_write(result, ldns_buffer_begin(from), tocopy); ldns_buffer_flip(result); } ldns-1.6.17/net.c0000664000175100017510000005604712264060151013061 0ustar willemwillem/* * net.c * * Network implementation * All network related functions are grouped here * * a Net::DNS like library for C * * (c) NLnet Labs, 2004-2006 * * See the file LICENSE for the license */ #include #include #ifdef HAVE_NETINET_IN_H #include #endif #ifdef HAVE_SYS_SOCKET_H #include #endif #ifdef HAVE_NETDB_H #include #endif #ifdef HAVE_ARPA_INET_H #include #endif #include #include #include ldns_status ldns_send(ldns_pkt **result_packet, ldns_resolver *r, const ldns_pkt *query_pkt) { ldns_buffer *qb; ldns_status result; ldns_rdf *tsig_mac = NULL; qb = ldns_buffer_new(LDNS_MIN_BUFLEN); if (query_pkt && ldns_pkt_tsig(query_pkt)) { tsig_mac = ldns_rr_rdf(ldns_pkt_tsig(query_pkt), 3); } if (!query_pkt || ldns_pkt2buffer_wire(qb, query_pkt) != LDNS_STATUS_OK) { result = LDNS_STATUS_ERR; } else { result = ldns_send_buffer(result_packet, r, qb, tsig_mac); } ldns_buffer_free(qb); return result; } /* code from rdata.c */ static struct sockaddr_storage * ldns_rdf2native_sockaddr_storage_port( const ldns_rdf *rd, uint16_t port, size_t *size) { struct sockaddr_storage *data; struct sockaddr_in *data_in; struct sockaddr_in6 *data_in6; data = LDNS_MALLOC(struct sockaddr_storage); if (!data) { return NULL; } /* zero the structure for portability */ memset(data, 0, sizeof(struct sockaddr_storage)); switch(ldns_rdf_get_type(rd)) { case LDNS_RDF_TYPE_A: #ifndef S_SPLINT_S data->ss_family = AF_INET; #endif data_in = (struct sockaddr_in*) data; data_in->sin_port = (in_port_t)htons(port); memcpy(&(data_in->sin_addr), ldns_rdf_data(rd), ldns_rdf_size(rd)); *size = sizeof(struct sockaddr_in); return data; case LDNS_RDF_TYPE_AAAA: #ifndef S_SPLINT_S data->ss_family = AF_INET6; #endif data_in6 = (struct sockaddr_in6*) data; data_in6->sin6_port = (in_port_t)htons(port); memcpy(&data_in6->sin6_addr, ldns_rdf_data(rd), ldns_rdf_size(rd)); *size = sizeof(struct sockaddr_in6); return data; default: LDNS_FREE(data); return NULL; } } struct sockaddr_storage * ldns_rdf2native_sockaddr_storage( const ldns_rdf *rd, uint16_t port, size_t *size) { return ldns_rdf2native_sockaddr_storage_port( rd, (port == 0 ? (uint16_t)LDNS_PORT : port), size); } /** best effort to set nonblocking */ static void ldns_sock_nonblock(int sockfd) { #ifdef HAVE_FCNTL int flag; if((flag = fcntl(sockfd, F_GETFL)) != -1) { flag |= O_NONBLOCK; if(fcntl(sockfd, F_SETFL, flag) == -1) { /* ignore error, continue blockingly */ } } #elif defined(HAVE_IOCTLSOCKET) unsigned long on = 1; if(ioctlsocket(sockfd, FIONBIO, &on) != 0) { /* ignore error, continue blockingly */ } #endif } /** best effort to set blocking */ static void ldns_sock_block(int sockfd) { #ifdef HAVE_FCNTL int flag; if((flag = fcntl(sockfd, F_GETFL)) != -1) { flag &= ~O_NONBLOCK; if(fcntl(sockfd, F_SETFL, flag) == -1) { /* ignore error, continue */ } } #elif defined(HAVE_IOCTLSOCKET) unsigned long off = 0; if(ioctlsocket(sockfd, FIONBIO, &off) != 0) { /* ignore error, continue */ } #endif } /** wait for a socket to become ready */ static int ldns_sock_wait(int sockfd, struct timeval timeout, int write) { int ret; #ifndef S_SPLINT_S fd_set fds; FD_ZERO(&fds); FD_SET(FD_SET_T sockfd, &fds); if(write) ret = select(sockfd+1, NULL, &fds, NULL, &timeout); else ret = select(sockfd+1, &fds, NULL, NULL, &timeout); #endif if(ret == 0) /* timeout expired */ return 0; else if(ret == -1) /* error */ return 0; return 1; } static int ldns_tcp_connect_from(const struct sockaddr_storage *to, socklen_t tolen, const struct sockaddr_storage *from, socklen_t fromlen, struct timeval timeout) { int sockfd; #ifndef S_SPLINT_S if ((sockfd = socket((int)((struct sockaddr*)to)->sa_family, SOCK_STREAM, IPPROTO_TCP)) == -1) { return 0; } #endif if (from && bind(sockfd, (const struct sockaddr*)from, fromlen) == -1){ return 0; } /* perform nonblocking connect, to be able to wait with select() */ ldns_sock_nonblock(sockfd); if (connect(sockfd, (struct sockaddr*)to, tolen) == -1) { #ifndef USE_WINSOCK #ifdef EINPROGRESS if(errno != EINPROGRESS) { #else if(1) { #endif close(sockfd); return 0; } #else /* USE_WINSOCK */ if(WSAGetLastError() != WSAEINPROGRESS && WSAGetLastError() != WSAEWOULDBLOCK) { closesocket(sockfd); return 0; } #endif /* error was only telling us that it would block */ } /* wait(write) until connected or error */ while(1) { int error = 0; socklen_t len = (socklen_t)sizeof(error); if(!ldns_sock_wait(sockfd, timeout, 1)) { #ifndef USE_WINSOCK close(sockfd); #else closesocket(sockfd); #endif return 0; } /* check if there is a pending error for nonblocking connect */ if(getsockopt(sockfd, SOL_SOCKET, SO_ERROR, (void*)&error, &len) < 0) { #ifndef USE_WINSOCK error = errno; /* on solaris errno is error */ #else error = WSAGetLastError(); #endif } #ifndef USE_WINSOCK #if defined(EINPROGRESS) && defined(EWOULDBLOCK) if(error == EINPROGRESS || error == EWOULDBLOCK) continue; /* try again */ #endif else if(error != 0) { close(sockfd); /* error in errno for our user */ errno = error; return 0; } #else /* USE_WINSOCK */ if(error == WSAEINPROGRESS) continue; else if(error == WSAEWOULDBLOCK) continue; else if(error != 0) { closesocket(sockfd); errno = error; return 0; } #endif /* USE_WINSOCK */ /* connected */ break; } /* set the socket blocking again */ ldns_sock_block(sockfd); return sockfd; } int ldns_tcp_connect(const struct sockaddr_storage *to, socklen_t tolen, struct timeval timeout) { return ldns_tcp_connect_from(to, tolen, NULL, 0, timeout); } static int ldns_tcp_bgsend_from(ldns_buffer *qbin, const struct sockaddr_storage *to, socklen_t tolen, const struct sockaddr_storage *from, socklen_t fromlen, struct timeval timeout) { int sockfd; sockfd = ldns_tcp_connect_from(to, tolen, from, fromlen, timeout); if (sockfd == 0) { return 0; } if (ldns_tcp_send_query(qbin, sockfd, to, tolen) == 0) { #ifndef USE_WINSOCK close(sockfd); #else closesocket(sockfd); #endif return 0; } return sockfd; } int ldns_tcp_bgsend(ldns_buffer *qbin, const struct sockaddr_storage *to, socklen_t tolen, struct timeval timeout) { return ldns_tcp_bgsend_from(qbin, to, tolen, NULL, 0, timeout); } /* keep in mind that in DNS tcp messages the first 2 bytes signal the * amount data to expect */ static ldns_status ldns_tcp_send_from(uint8_t **result, ldns_buffer *qbin, const struct sockaddr_storage *to, socklen_t tolen, const struct sockaddr_storage *from, socklen_t fromlen, struct timeval timeout, size_t *answer_size) { int sockfd; uint8_t *answer; sockfd = ldns_tcp_bgsend_from(qbin, to, tolen, from, fromlen, timeout); if (sockfd == 0) { return LDNS_STATUS_ERR; } answer = ldns_tcp_read_wire_timeout(sockfd, answer_size, timeout); #ifndef USE_WINSOCK close(sockfd); #else closesocket(sockfd); #endif if (*answer_size == 0) { /* oops */ return LDNS_STATUS_NETWORK_ERR; } /* resize accordingly */ *result = LDNS_XREALLOC(answer, uint8_t, (size_t)*answer_size); if(!*result) { LDNS_FREE(answer); return LDNS_STATUS_MEM_ERR; } return LDNS_STATUS_OK; } ldns_status ldns_tcp_send(uint8_t **result, ldns_buffer *qbin, const struct sockaddr_storage *to, socklen_t tolen, struct timeval timeout, size_t *answer_size) { return ldns_tcp_send_from(result, qbin, to, tolen, NULL, 0, timeout, answer_size); } int ldns_udp_connect(const struct sockaddr_storage *to, struct timeval ATTR_UNUSED(timeout)) { int sockfd; #ifndef S_SPLINT_S if ((sockfd = socket((int)((struct sockaddr*)to)->sa_family, SOCK_DGRAM, IPPROTO_UDP)) == -1) { return 0; } #endif return sockfd; } static int ldns_udp_bgsend_from(ldns_buffer *qbin, const struct sockaddr_storage *to , socklen_t tolen, const struct sockaddr_storage *from, socklen_t fromlen, struct timeval timeout) { int sockfd; sockfd = ldns_udp_connect(to, timeout); if (sockfd == 0) { return 0; } if (from && bind(sockfd, (const struct sockaddr*)from, fromlen) == -1){ return 0; } if (ldns_udp_send_query(qbin, sockfd, to, tolen) == 0) { #ifndef USE_WINSOCK close(sockfd); #else closesocket(sockfd); #endif return 0; } return sockfd; } int ldns_udp_bgsend(ldns_buffer *qbin, const struct sockaddr_storage *to , socklen_t tolen, struct timeval timeout) { return ldns_udp_bgsend_from(qbin, to, tolen, NULL, 0, timeout); } static ldns_status ldns_udp_send_from(uint8_t **result, ldns_buffer *qbin, const struct sockaddr_storage *to , socklen_t tolen, const struct sockaddr_storage *from, socklen_t fromlen, struct timeval timeout, size_t *answer_size) { int sockfd; uint8_t *answer; sockfd = ldns_udp_bgsend_from(qbin, to, tolen, from, fromlen, timeout); if (sockfd == 0) { return LDNS_STATUS_SOCKET_ERROR; } /* wait for an response*/ if(!ldns_sock_wait(sockfd, timeout, 0)) { #ifndef USE_WINSOCK close(sockfd); #else closesocket(sockfd); #endif return LDNS_STATUS_NETWORK_ERR; } /* set to nonblocking, so if the checksum is bad, it becomes * an EGAIN error and the ldns_udp_send function does not block, * but returns a 'NETWORK_ERROR' much like a timeout. */ ldns_sock_nonblock(sockfd); answer = ldns_udp_read_wire(sockfd, answer_size, NULL, NULL); #ifndef USE_WINSOCK close(sockfd); #else closesocket(sockfd); #endif if (*answer_size == 0) { /* oops */ return LDNS_STATUS_NETWORK_ERR; } *result = answer; return LDNS_STATUS_OK; } ldns_status ldns_udp_send(uint8_t **result, ldns_buffer *qbin, const struct sockaddr_storage *to , socklen_t tolen, struct timeval timeout, size_t *answer_size) { return ldns_udp_send_from(result, qbin, to, tolen, NULL, 0, timeout, answer_size); } ldns_status ldns_send_buffer(ldns_pkt **result, ldns_resolver *r, ldns_buffer *qb, ldns_rdf *tsig_mac) { uint8_t i; struct sockaddr_storage *src = NULL; size_t src_len; struct sockaddr_storage *ns; size_t ns_len; struct timeval tv_s; struct timeval tv_e; ldns_rdf **ns_array; size_t *rtt; ldns_pkt *reply; bool all_servers_rtt_inf; uint8_t retries; uint8_t *reply_bytes = NULL; size_t reply_size = 0; ldns_status status, send_status; assert(r != NULL); status = LDNS_STATUS_OK; rtt = ldns_resolver_rtt(r); ns_array = ldns_resolver_nameservers(r); reply = NULL; ns_len = 0; all_servers_rtt_inf = true; if (ldns_resolver_random(r)) { ldns_resolver_nameservers_randomize(r); } if(ldns_resolver_source(r)) { src = ldns_rdf2native_sockaddr_storage_port( ldns_resolver_source(r), 0, &src_len); } /* loop through all defined nameservers */ for (i = 0; i < ldns_resolver_nameserver_count(r); i++) { if (rtt[i] == LDNS_RESOLV_RTT_INF) { /* not reachable nameserver! */ continue; } /* maybe verbosity setting? printf("Sending to "); ldns_rdf_print(stdout, ns_array[i]); printf("\n"); */ ns = ldns_rdf2native_sockaddr_storage(ns_array[i], ldns_resolver_port(r), &ns_len); #ifndef S_SPLINT_S if ((ns->ss_family == AF_INET) && (ldns_resolver_ip6(r) == LDNS_RESOLV_INET6)) { /* not reachable */ LDNS_FREE(ns); continue; } if ((ns->ss_family == AF_INET6) && (ldns_resolver_ip6(r) == LDNS_RESOLV_INET)) { /* not reachable */ LDNS_FREE(ns); continue; } #endif all_servers_rtt_inf = false; gettimeofday(&tv_s, NULL); send_status = LDNS_STATUS_ERR; /* reply_bytes implicitly handles our error */ if (ldns_resolver_usevc(r)) { for (retries = ldns_resolver_retry(r); retries > 0; retries--) { send_status = ldns_tcp_send_from(&reply_bytes, qb, ns, (socklen_t)ns_len, src, (socklen_t)src_len, ldns_resolver_timeout(r), &reply_size); if (send_status == LDNS_STATUS_OK) { break; } } } else { for (retries = ldns_resolver_retry(r); retries > 0; retries--) { /* ldns_rdf_print(stdout, ns_array[i]); */ send_status = ldns_udp_send_from(&reply_bytes, qb, ns, (socklen_t)ns_len, src, (socklen_t)src_len, ldns_resolver_timeout(r), &reply_size); if (send_status == LDNS_STATUS_OK) { break; } } } if (send_status != LDNS_STATUS_OK) { ldns_resolver_set_nameserver_rtt(r, i, LDNS_RESOLV_RTT_INF); status = send_status; } /* obey the fail directive */ if (!reply_bytes) { /* the current nameserver seems to have a problem, blacklist it */ if (ldns_resolver_fail(r)) { LDNS_FREE(ns); return LDNS_STATUS_ERR; } else { LDNS_FREE(ns); continue; } } status = ldns_wire2pkt(&reply, reply_bytes, reply_size); if (status != LDNS_STATUS_OK) { LDNS_FREE(reply_bytes); LDNS_FREE(ns); return status; } LDNS_FREE(ns); gettimeofday(&tv_e, NULL); if (reply) { ldns_pkt_set_querytime(reply, (uint32_t) ((tv_e.tv_sec - tv_s.tv_sec) * 1000) + (tv_e.tv_usec - tv_s.tv_usec) / 1000); ldns_pkt_set_answerfrom(reply, ldns_rdf_clone(ns_array[i])); ldns_pkt_set_timestamp(reply, tv_s); ldns_pkt_set_size(reply, reply_size); break; } else { if (ldns_resolver_fail(r)) { /* if fail is set bail out, after the first * one */ break; } } /* wait retrans seconds... */ sleep((unsigned int) ldns_resolver_retrans(r)); } if(src) { LDNS_FREE(src); } if (all_servers_rtt_inf) { LDNS_FREE(reply_bytes); return LDNS_STATUS_RES_NO_NS; } #ifdef HAVE_SSL if (tsig_mac && reply && reply_bytes) { if (!ldns_pkt_tsig_verify(reply, reply_bytes, reply_size, ldns_resolver_tsig_keyname(r), ldns_resolver_tsig_keydata(r), tsig_mac)) { status = LDNS_STATUS_CRYPTO_TSIG_BOGUS; } } #else (void)tsig_mac; #endif /* HAVE_SSL */ LDNS_FREE(reply_bytes); if (result) { *result = reply; } return status; } ssize_t ldns_tcp_send_query(ldns_buffer *qbin, int sockfd, const struct sockaddr_storage *to, socklen_t tolen) { uint8_t *sendbuf; ssize_t bytes; /* add length of packet */ sendbuf = LDNS_XMALLOC(uint8_t, ldns_buffer_position(qbin) + 2); if(!sendbuf) return 0; ldns_write_uint16(sendbuf, ldns_buffer_position(qbin)); memcpy(sendbuf + 2, ldns_buffer_begin(qbin), ldns_buffer_position(qbin)); bytes = sendto(sockfd, (void*)sendbuf, ldns_buffer_position(qbin) + 2, 0, (struct sockaddr *)to, tolen); LDNS_FREE(sendbuf); if (bytes == -1 || (size_t) bytes != ldns_buffer_position(qbin) + 2 ) { return 0; } return bytes; } /* don't wait for an answer */ ssize_t ldns_udp_send_query(ldns_buffer *qbin, int sockfd, const struct sockaddr_storage *to, socklen_t tolen) { ssize_t bytes; bytes = sendto(sockfd, (void*)ldns_buffer_begin(qbin), ldns_buffer_position(qbin), 0, (struct sockaddr *)to, tolen); if (bytes == -1 || (size_t)bytes != ldns_buffer_position(qbin)) { return 0; } if ((size_t) bytes != ldns_buffer_position(qbin)) { return 0; } return bytes; } uint8_t * ldns_udp_read_wire(int sockfd, size_t *size, struct sockaddr_storage *from, socklen_t *fromlen) { uint8_t *wire, *wireout; ssize_t wire_size; wire = LDNS_XMALLOC(uint8_t, LDNS_MAX_PACKETLEN); if (!wire) { *size = 0; return NULL; } wire_size = recvfrom(sockfd, (void*)wire, LDNS_MAX_PACKETLEN, 0, (struct sockaddr *)from, fromlen); /* recvfrom can also return 0 */ if (wire_size == -1 || wire_size == 0) { *size = 0; LDNS_FREE(wire); return NULL; } *size = (size_t)wire_size; wireout = LDNS_XREALLOC(wire, uint8_t, (size_t)wire_size); if(!wireout) LDNS_FREE(wire); return wireout; } uint8_t * ldns_tcp_read_wire_timeout(int sockfd, size_t *size, struct timeval timeout) { uint8_t *wire; uint16_t wire_size; ssize_t bytes = 0, rc = 0; wire = LDNS_XMALLOC(uint8_t, 2); if (!wire) { *size = 0; return NULL; } while (bytes < 2) { if(!ldns_sock_wait(sockfd, timeout, 0)) { *size = 0; LDNS_FREE(wire); return NULL; } rc = recv(sockfd, (void*) (wire + bytes), (size_t) (2 - bytes), 0); if (rc == -1 || rc == 0) { *size = 0; LDNS_FREE(wire); return NULL; } bytes += rc; } wire_size = ldns_read_uint16(wire); LDNS_FREE(wire); wire = LDNS_XMALLOC(uint8_t, wire_size); if (!wire) { *size = 0; return NULL; } bytes = 0; while (bytes < (ssize_t) wire_size) { if(!ldns_sock_wait(sockfd, timeout, 0)) { *size = 0; LDNS_FREE(wire); return NULL; } rc = recv(sockfd, (void*) (wire + bytes), (size_t) (wire_size - bytes), 0); if (rc == -1 || rc == 0) { LDNS_FREE(wire); *size = 0; return NULL; } bytes += rc; } *size = (size_t) bytes; return wire; } uint8_t * ldns_tcp_read_wire(int sockfd, size_t *size) { uint8_t *wire; uint16_t wire_size; ssize_t bytes = 0, rc = 0; wire = LDNS_XMALLOC(uint8_t, 2); if (!wire) { *size = 0; return NULL; } while (bytes < 2) { rc = recv(sockfd, (void*) (wire + bytes), (size_t) (2 - bytes), 0); if (rc == -1 || rc == 0) { *size = 0; LDNS_FREE(wire); return NULL; } bytes += rc; } wire_size = ldns_read_uint16(wire); LDNS_FREE(wire); wire = LDNS_XMALLOC(uint8_t, wire_size); if (!wire) { *size = 0; return NULL; } bytes = 0; while (bytes < (ssize_t) wire_size) { rc = recv(sockfd, (void*) (wire + bytes), (size_t) (wire_size - bytes), 0); if (rc == -1 || rc == 0) { LDNS_FREE(wire); *size = 0; return NULL; } bytes += rc; } *size = (size_t) bytes; return wire; } #ifndef S_SPLINT_S ldns_rdf * ldns_sockaddr_storage2rdf(struct sockaddr_storage *sock, uint16_t *port) { ldns_rdf *addr; struct sockaddr_in *data_in; struct sockaddr_in6 *data_in6; switch(sock->ss_family) { case AF_INET: data_in = (struct sockaddr_in*)sock; if (port) { *port = ntohs((uint16_t)data_in->sin_port); } addr = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_A, LDNS_IP4ADDRLEN, &data_in->sin_addr); break; case AF_INET6: data_in6 = (struct sockaddr_in6*)sock; if (port) { *port = ntohs((uint16_t)data_in6->sin6_port); } addr = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_AAAA, LDNS_IP6ADDRLEN, &data_in6->sin6_addr); break; default: if (port) { *port = 0; } return NULL; } return addr; } #endif /* code from resolver.c */ ldns_status ldns_axfr_start(ldns_resolver *resolver, ldns_rdf *domain, ldns_rr_class class) { ldns_pkt *query; ldns_buffer *query_wire; struct sockaddr_storage *src = NULL; size_t src_len = 0; struct sockaddr_storage *ns = NULL; size_t ns_len = 0; size_t ns_i; ldns_status status; if (!resolver || ldns_resolver_nameserver_count(resolver) < 1) { return LDNS_STATUS_ERR; } query = ldns_pkt_query_new(ldns_rdf_clone(domain), LDNS_RR_TYPE_AXFR, class, 0); if (!query) { return LDNS_STATUS_ADDRESS_ERR; } if(ldns_resolver_source(resolver)) { src = ldns_rdf2native_sockaddr_storage_port( ldns_resolver_source(resolver), 0, &src_len); } /* For AXFR, we have to make the connection ourselves */ /* try all nameservers (which usually would mean v4 fallback if * @hostname is used */ for (ns_i = 0; ns_i < ldns_resolver_nameserver_count(resolver) && resolver->_socket == 0; ns_i++) { if (ns != NULL) { LDNS_FREE(ns); } ns = ldns_rdf2native_sockaddr_storage( resolver->_nameservers[ns_i], ldns_resolver_port(resolver), &ns_len); resolver->_socket = ldns_tcp_connect_from( ns, (socklen_t)ns_len, src, (socklen_t)src_len, ldns_resolver_timeout(resolver)); } if (resolver->_socket == 0) { ldns_pkt_free(query); LDNS_FREE(ns); return LDNS_STATUS_NETWORK_ERR; } #ifdef HAVE_SSL if (ldns_resolver_tsig_keyname(resolver) && ldns_resolver_tsig_keydata(resolver)) { status = ldns_pkt_tsig_sign(query, ldns_resolver_tsig_keyname(resolver), ldns_resolver_tsig_keydata(resolver), 300, ldns_resolver_tsig_algorithm(resolver), NULL); if (status != LDNS_STATUS_OK) { /* to prevent problems on subsequent calls to * ldns_axfr_start we have to close the socket here! */ #ifndef USE_WINSOCK close(resolver->_socket); #else closesocket(resolver->_socket); #endif resolver->_socket = 0; ldns_pkt_free(query); LDNS_FREE(ns); return LDNS_STATUS_CRYPTO_TSIG_ERR; } } #endif /* HAVE_SSL */ /* Convert the query to a buffer * Is this necessary? */ query_wire = ldns_buffer_new(LDNS_MAX_PACKETLEN); if(!query_wire) { ldns_pkt_free(query); LDNS_FREE(ns); #ifndef USE_WINSOCK close(resolver->_socket); #else closesocket(resolver->_socket); #endif resolver->_socket = 0; return LDNS_STATUS_MEM_ERR; } status = ldns_pkt2buffer_wire(query_wire, query); if (status != LDNS_STATUS_OK) { ldns_pkt_free(query); ldns_buffer_free(query_wire); LDNS_FREE(ns); /* to prevent problems on subsequent calls to ldns_axfr_start * we have to close the socket here! */ #ifndef USE_WINSOCK close(resolver->_socket); #else closesocket(resolver->_socket); #endif resolver->_socket = 0; return status; } /* Send the query */ if (ldns_tcp_send_query(query_wire, resolver->_socket, ns, (socklen_t)ns_len) == 0) { ldns_pkt_free(query); ldns_buffer_free(query_wire); LDNS_FREE(ns); /* to prevent problems on subsequent calls to ldns_axfr_start * we have to close the socket here! */ #ifndef USE_WINSOCK close(resolver->_socket); #else closesocket(resolver->_socket); #endif resolver->_socket = 0; return LDNS_STATUS_NETWORK_ERR; } ldns_pkt_free(query); ldns_buffer_free(query_wire); LDNS_FREE(ns); /* * The AXFR is done once the second SOA record is sent */ resolver->_axfr_soa_count = 0; return LDNS_STATUS_OK; } ldns-1.6.17/aclocal.m40000664000175100017510000113525312264060157013773 0ustar willemwillem# generated automatically by aclocal 1.11.3 -*- Autoconf -*- # Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, # 2005, 2006, 2007, 2008, 2009, 2010, 2011 Free Software Foundation, # Inc. # This file is free software; the Free Software Foundation # gives unlimited permission to copy and/or distribute it, # with or without modifications, as long as this notice is preserved. # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY, to the extent permitted by law; without # even the implied warranty of MERCHANTABILITY or FITNESS FOR A # PARTICULAR PURPOSE. # libtool.m4 - Configure libtool for the host system. -*-Autoconf-*- # # Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, # 2006, 2007, 2008, 2009, 2010, 2011 Free Software # Foundation, Inc. # Written by Gordon Matzigkeit, 1996 # # This file is free software; the Free Software Foundation gives # unlimited permission to copy and/or distribute it, with or without # modifications, as long as this notice is preserved. m4_define([_LT_COPYING], [dnl # Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, # 2006, 2007, 2008, 2009, 2010, 2011 Free Software # Foundation, Inc. # Written by Gordon Matzigkeit, 1996 # # This file is part of GNU Libtool. # # GNU Libtool is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License as # published by the Free Software Foundation; either version 2 of # the License, or (at your option) any later version. # # As a special exception to the GNU General Public License, # if you distribute this file as part of a program or library that # is built using GNU Libtool, you may include this file under the # same distribution terms that you use for the rest of that program. # # GNU Libtool is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with GNU Libtool; see the file COPYING. If not, a copy # can be downloaded from http://www.gnu.org/licenses/gpl.html, or # obtained by writing to the Free Software Foundation, Inc., # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ]) # serial 57 LT_INIT # LT_PREREQ(VERSION) # ------------------ # Complain and exit if this libtool version is less that VERSION. m4_defun([LT_PREREQ], [m4_if(m4_version_compare(m4_defn([LT_PACKAGE_VERSION]), [$1]), -1, [m4_default([$3], [m4_fatal([Libtool version $1 or higher is required], 63)])], [$2])]) # _LT_CHECK_BUILDDIR # ------------------ # Complain if the absolute build directory name contains unusual characters m4_defun([_LT_CHECK_BUILDDIR], [case `pwd` in *\ * | *\ *) AC_MSG_WARN([Libtool does not cope well with whitespace in `pwd`]) ;; esac ]) # LT_INIT([OPTIONS]) # ------------------ AC_DEFUN([LT_INIT], [AC_PREREQ([2.58])dnl We use AC_INCLUDES_DEFAULT AC_REQUIRE([AC_CONFIG_AUX_DIR_DEFAULT])dnl AC_BEFORE([$0], [LT_LANG])dnl AC_BEFORE([$0], [LT_OUTPUT])dnl AC_BEFORE([$0], [LTDL_INIT])dnl m4_require([_LT_CHECK_BUILDDIR])dnl dnl Autoconf doesn't catch unexpanded LT_ macros by default: m4_pattern_forbid([^_?LT_[A-Z_]+$])dnl m4_pattern_allow([^(_LT_EOF|LT_DLGLOBAL|LT_DLLAZY_OR_NOW|LT_MULTI_MODULE)$])dnl dnl aclocal doesn't pull ltoptions.m4, ltsugar.m4, or ltversion.m4 dnl unless we require an AC_DEFUNed macro: AC_REQUIRE([LTOPTIONS_VERSION])dnl AC_REQUIRE([LTSUGAR_VERSION])dnl AC_REQUIRE([LTVERSION_VERSION])dnl AC_REQUIRE([LTOBSOLETE_VERSION])dnl m4_require([_LT_PROG_LTMAIN])dnl _LT_SHELL_INIT([SHELL=${CONFIG_SHELL-/bin/sh}]) dnl Parse OPTIONS _LT_SET_OPTIONS([$0], [$1]) # This can be used to rebuild libtool when needed LIBTOOL_DEPS="$ltmain" # Always use our own libtool. LIBTOOL='$(SHELL) $(top_builddir)/libtool' AC_SUBST(LIBTOOL)dnl _LT_SETUP # Only expand once: m4_define([LT_INIT]) ])# LT_INIT # Old names: AU_ALIAS([AC_PROG_LIBTOOL], [LT_INIT]) AU_ALIAS([AM_PROG_LIBTOOL], [LT_INIT]) dnl aclocal-1.4 backwards compatibility: dnl AC_DEFUN([AC_PROG_LIBTOOL], []) dnl AC_DEFUN([AM_PROG_LIBTOOL], []) # _LT_CC_BASENAME(CC) # ------------------- # Calculate cc_basename. Skip known compiler wrappers and cross-prefix. m4_defun([_LT_CC_BASENAME], [for cc_temp in $1""; do case $cc_temp in compile | *[[\\/]]compile | ccache | *[[\\/]]ccache ) ;; distcc | *[[\\/]]distcc | purify | *[[\\/]]purify ) ;; \-*) ;; *) break;; esac done cc_basename=`$ECHO "$cc_temp" | $SED "s%.*/%%; s%^$host_alias-%%"` ]) # _LT_FILEUTILS_DEFAULTS # ---------------------- # It is okay to use these file commands and assume they have been set # sensibly after `m4_require([_LT_FILEUTILS_DEFAULTS])'. m4_defun([_LT_FILEUTILS_DEFAULTS], [: ${CP="cp -f"} : ${MV="mv -f"} : ${RM="rm -f"} ])# _LT_FILEUTILS_DEFAULTS # _LT_SETUP # --------- m4_defun([_LT_SETUP], [AC_REQUIRE([AC_CANONICAL_HOST])dnl AC_REQUIRE([AC_CANONICAL_BUILD])dnl AC_REQUIRE([_LT_PREPARE_SED_QUOTE_VARS])dnl AC_REQUIRE([_LT_PROG_ECHO_BACKSLASH])dnl _LT_DECL([], [PATH_SEPARATOR], [1], [The PATH separator for the build system])dnl dnl _LT_DECL([], [host_alias], [0], [The host system])dnl _LT_DECL([], [host], [0])dnl _LT_DECL([], [host_os], [0])dnl dnl _LT_DECL([], [build_alias], [0], [The build system])dnl _LT_DECL([], [build], [0])dnl _LT_DECL([], [build_os], [0])dnl dnl AC_REQUIRE([AC_PROG_CC])dnl AC_REQUIRE([LT_PATH_LD])dnl AC_REQUIRE([LT_PATH_NM])dnl dnl AC_REQUIRE([AC_PROG_LN_S])dnl test -z "$LN_S" && LN_S="ln -s" _LT_DECL([], [LN_S], [1], [Whether we need soft or hard links])dnl dnl AC_REQUIRE([LT_CMD_MAX_LEN])dnl _LT_DECL([objext], [ac_objext], [0], [Object file suffix (normally "o")])dnl _LT_DECL([], [exeext], [0], [Executable file suffix (normally "")])dnl dnl m4_require([_LT_FILEUTILS_DEFAULTS])dnl m4_require([_LT_CHECK_SHELL_FEATURES])dnl m4_require([_LT_PATH_CONVERSION_FUNCTIONS])dnl m4_require([_LT_CMD_RELOAD])dnl m4_require([_LT_CHECK_MAGIC_METHOD])dnl m4_require([_LT_CHECK_SHAREDLIB_FROM_LINKLIB])dnl m4_require([_LT_CMD_OLD_ARCHIVE])dnl m4_require([_LT_CMD_GLOBAL_SYMBOLS])dnl m4_require([_LT_WITH_SYSROOT])dnl _LT_CONFIG_LIBTOOL_INIT([ # See if we are running on zsh, and set the options which allow our # commands through without removal of \ escapes INIT. if test -n "\${ZSH_VERSION+set}" ; then setopt NO_GLOB_SUBST fi ]) if test -n "${ZSH_VERSION+set}" ; then setopt NO_GLOB_SUBST fi _LT_CHECK_OBJDIR m4_require([_LT_TAG_COMPILER])dnl case $host_os in aix3*) # AIX sometimes has problems with the GCC collect2 program. For some # reason, if we set the COLLECT_NAMES environment variable, the problems # vanish in a puff of smoke. if test "X${COLLECT_NAMES+set}" != Xset; then COLLECT_NAMES= export COLLECT_NAMES fi ;; esac # Global variables: ofile=libtool can_build_shared=yes # All known linkers require a `.a' archive for static linking (except MSVC, # which needs '.lib'). libext=a with_gnu_ld="$lt_cv_prog_gnu_ld" old_CC="$CC" old_CFLAGS="$CFLAGS" # Set sane defaults for various variables test -z "$CC" && CC=cc test -z "$LTCC" && LTCC=$CC test -z "$LTCFLAGS" && LTCFLAGS=$CFLAGS test -z "$LD" && LD=ld test -z "$ac_objext" && ac_objext=o _LT_CC_BASENAME([$compiler]) # Only perform the check for file, if the check method requires it test -z "$MAGIC_CMD" && MAGIC_CMD=file case $deplibs_check_method in file_magic*) if test "$file_magic_cmd" = '$MAGIC_CMD'; then _LT_PATH_MAGIC fi ;; esac # Use C for the default configuration in the libtool script LT_SUPPORTED_TAG([CC]) _LT_LANG_C_CONFIG _LT_LANG_DEFAULT_CONFIG _LT_CONFIG_COMMANDS ])# _LT_SETUP # _LT_PREPARE_SED_QUOTE_VARS # -------------------------- # Define a few sed substitution that help us do robust quoting. m4_defun([_LT_PREPARE_SED_QUOTE_VARS], [# Backslashify metacharacters that are still active within # double-quoted strings. sed_quote_subst='s/\([["`$\\]]\)/\\\1/g' # Same as above, but do not quote variable references. double_quote_subst='s/\([["`\\]]\)/\\\1/g' # Sed substitution to delay expansion of an escaped shell variable in a # double_quote_subst'ed string. delay_variable_subst='s/\\\\\\\\\\\$/\\\\\\$/g' # Sed substitution to delay expansion of an escaped single quote. delay_single_quote_subst='s/'\''/'\'\\\\\\\'\''/g' # Sed substitution to avoid accidental globbing in evaled expressions no_glob_subst='s/\*/\\\*/g' ]) # _LT_PROG_LTMAIN # --------------- # Note that this code is called both from `configure', and `config.status' # now that we use AC_CONFIG_COMMANDS to generate libtool. Notably, # `config.status' has no value for ac_aux_dir unless we are using Automake, # so we pass a copy along to make sure it has a sensible value anyway. m4_defun([_LT_PROG_LTMAIN], [m4_ifdef([AC_REQUIRE_AUX_FILE], [AC_REQUIRE_AUX_FILE([ltmain.sh])])dnl _LT_CONFIG_LIBTOOL_INIT([ac_aux_dir='$ac_aux_dir']) ltmain="$ac_aux_dir/ltmain.sh" ])# _LT_PROG_LTMAIN # So that we can recreate a full libtool script including additional # tags, we accumulate the chunks of code to send to AC_CONFIG_COMMANDS # in macros and then make a single call at the end using the `libtool' # label. # _LT_CONFIG_LIBTOOL_INIT([INIT-COMMANDS]) # ---------------------------------------- # Register INIT-COMMANDS to be passed to AC_CONFIG_COMMANDS later. m4_define([_LT_CONFIG_LIBTOOL_INIT], [m4_ifval([$1], [m4_append([_LT_OUTPUT_LIBTOOL_INIT], [$1 ])])]) # Initialize. m4_define([_LT_OUTPUT_LIBTOOL_INIT]) # _LT_CONFIG_LIBTOOL([COMMANDS]) # ------------------------------ # Register COMMANDS to be passed to AC_CONFIG_COMMANDS later. m4_define([_LT_CONFIG_LIBTOOL], [m4_ifval([$1], [m4_append([_LT_OUTPUT_LIBTOOL_COMMANDS], [$1 ])])]) # Initialize. m4_define([_LT_OUTPUT_LIBTOOL_COMMANDS]) # _LT_CONFIG_SAVE_COMMANDS([COMMANDS], [INIT_COMMANDS]) # ----------------------------------------------------- m4_defun([_LT_CONFIG_SAVE_COMMANDS], [_LT_CONFIG_LIBTOOL([$1]) _LT_CONFIG_LIBTOOL_INIT([$2]) ]) # _LT_FORMAT_COMMENT([COMMENT]) # ----------------------------- # Add leading comment marks to the start of each line, and a trailing # full-stop to the whole comment if one is not present already. m4_define([_LT_FORMAT_COMMENT], [m4_ifval([$1], [ m4_bpatsubst([m4_bpatsubst([$1], [^ *], [# ])], [['`$\]], [\\\&])]m4_bmatch([$1], [[!?.]$], [], [.]) )]) # _LT_DECL([CONFIGNAME], VARNAME, VALUE, [DESCRIPTION], [IS-TAGGED?]) # ------------------------------------------------------------------- # CONFIGNAME is the name given to the value in the libtool script. # VARNAME is the (base) name used in the configure script. # VALUE may be 0, 1 or 2 for a computed quote escaped value based on # VARNAME. Any other value will be used directly. m4_define([_LT_DECL], [lt_if_append_uniq([lt_decl_varnames], [$2], [, ], [lt_dict_add_subkey([lt_decl_dict], [$2], [libtool_name], [m4_ifval([$1], [$1], [$2])]) lt_dict_add_subkey([lt_decl_dict], [$2], [value], [$3]) m4_ifval([$4], [lt_dict_add_subkey([lt_decl_dict], [$2], [description], [$4])]) lt_dict_add_subkey([lt_decl_dict], [$2], [tagged?], [m4_ifval([$5], [yes], [no])])]) ]) # _LT_TAGDECL([CONFIGNAME], VARNAME, VALUE, [DESCRIPTION]) # -------------------------------------------------------- m4_define([_LT_TAGDECL], [_LT_DECL([$1], [$2], [$3], [$4], [yes])]) # lt_decl_tag_varnames([SEPARATOR], [VARNAME1...]) # ------------------------------------------------ m4_define([lt_decl_tag_varnames], [_lt_decl_filter([tagged?], [yes], $@)]) # _lt_decl_filter(SUBKEY, VALUE, [SEPARATOR], [VARNAME1..]) # --------------------------------------------------------- m4_define([_lt_decl_filter], [m4_case([$#], [0], [m4_fatal([$0: too few arguments: $#])], [1], [m4_fatal([$0: too few arguments: $#: $1])], [2], [lt_dict_filter([lt_decl_dict], [$1], [$2], [], lt_decl_varnames)], [3], [lt_dict_filter([lt_decl_dict], [$1], [$2], [$3], lt_decl_varnames)], [lt_dict_filter([lt_decl_dict], $@)])[]dnl ]) # lt_decl_quote_varnames([SEPARATOR], [VARNAME1...]) # -------------------------------------------------- m4_define([lt_decl_quote_varnames], [_lt_decl_filter([value], [1], $@)]) # lt_decl_dquote_varnames([SEPARATOR], [VARNAME1...]) # --------------------------------------------------- m4_define([lt_decl_dquote_varnames], [_lt_decl_filter([value], [2], $@)]) # lt_decl_varnames_tagged([SEPARATOR], [VARNAME1...]) # --------------------------------------------------- m4_define([lt_decl_varnames_tagged], [m4_assert([$# <= 2])dnl _$0(m4_quote(m4_default([$1], [[, ]])), m4_ifval([$2], [[$2]], [m4_dquote(lt_decl_tag_varnames)]), m4_split(m4_normalize(m4_quote(_LT_TAGS)), [ ]))]) m4_define([_lt_decl_varnames_tagged], [m4_ifval([$3], [lt_combine([$1], [$2], [_], $3)])]) # lt_decl_all_varnames([SEPARATOR], [VARNAME1...]) # ------------------------------------------------ m4_define([lt_decl_all_varnames], [_$0(m4_quote(m4_default([$1], [[, ]])), m4_if([$2], [], m4_quote(lt_decl_varnames), m4_quote(m4_shift($@))))[]dnl ]) m4_define([_lt_decl_all_varnames], [lt_join($@, lt_decl_varnames_tagged([$1], lt_decl_tag_varnames([[, ]], m4_shift($@))))dnl ]) # _LT_CONFIG_STATUS_DECLARE([VARNAME]) # ------------------------------------ # Quote a variable value, and forward it to `config.status' so that its # declaration there will have the same value as in `configure'. VARNAME # must have a single quote delimited value for this to work. m4_define([_LT_CONFIG_STATUS_DECLARE], [$1='`$ECHO "$][$1" | $SED "$delay_single_quote_subst"`']) # _LT_CONFIG_STATUS_DECLARATIONS # ------------------------------ # We delimit libtool config variables with single quotes, so when # we write them to config.status, we have to be sure to quote all # embedded single quotes properly. In configure, this macro expands # each variable declared with _LT_DECL (and _LT_TAGDECL) into: # # ='`$ECHO "$" | $SED "$delay_single_quote_subst"`' m4_defun([_LT_CONFIG_STATUS_DECLARATIONS], [m4_foreach([_lt_var], m4_quote(lt_decl_all_varnames), [m4_n([_LT_CONFIG_STATUS_DECLARE(_lt_var)])])]) # _LT_LIBTOOL_TAGS # ---------------- # Output comment and list of tags supported by the script m4_defun([_LT_LIBTOOL_TAGS], [_LT_FORMAT_COMMENT([The names of the tagged configurations supported by this script])dnl available_tags="_LT_TAGS"dnl ]) # _LT_LIBTOOL_DECLARE(VARNAME, [TAG]) # ----------------------------------- # Extract the dictionary values for VARNAME (optionally with TAG) and # expand to a commented shell variable setting: # # # Some comment about what VAR is for. # visible_name=$lt_internal_name m4_define([_LT_LIBTOOL_DECLARE], [_LT_FORMAT_COMMENT(m4_quote(lt_dict_fetch([lt_decl_dict], [$1], [description])))[]dnl m4_pushdef([_libtool_name], m4_quote(lt_dict_fetch([lt_decl_dict], [$1], [libtool_name])))[]dnl m4_case(m4_quote(lt_dict_fetch([lt_decl_dict], [$1], [value])), [0], [_libtool_name=[$]$1], [1], [_libtool_name=$lt_[]$1], [2], [_libtool_name=$lt_[]$1], [_libtool_name=lt_dict_fetch([lt_decl_dict], [$1], [value])])[]dnl m4_ifval([$2], [_$2])[]m4_popdef([_libtool_name])[]dnl ]) # _LT_LIBTOOL_CONFIG_VARS # ----------------------- # Produce commented declarations of non-tagged libtool config variables # suitable for insertion in the LIBTOOL CONFIG section of the `libtool' # script. Tagged libtool config variables (even for the LIBTOOL CONFIG # section) are produced by _LT_LIBTOOL_TAG_VARS. m4_defun([_LT_LIBTOOL_CONFIG_VARS], [m4_foreach([_lt_var], m4_quote(_lt_decl_filter([tagged?], [no], [], lt_decl_varnames)), [m4_n([_LT_LIBTOOL_DECLARE(_lt_var)])])]) # _LT_LIBTOOL_TAG_VARS(TAG) # ------------------------- m4_define([_LT_LIBTOOL_TAG_VARS], [m4_foreach([_lt_var], m4_quote(lt_decl_tag_varnames), [m4_n([_LT_LIBTOOL_DECLARE(_lt_var, [$1])])])]) # _LT_TAGVAR(VARNAME, [TAGNAME]) # ------------------------------ m4_define([_LT_TAGVAR], [m4_ifval([$2], [$1_$2], [$1])]) # _LT_CONFIG_COMMANDS # ------------------- # Send accumulated output to $CONFIG_STATUS. Thanks to the lists of # variables for single and double quote escaping we saved from calls # to _LT_DECL, we can put quote escaped variables declarations # into `config.status', and then the shell code to quote escape them in # for loops in `config.status'. Finally, any additional code accumulated # from calls to _LT_CONFIG_LIBTOOL_INIT is expanded. m4_defun([_LT_CONFIG_COMMANDS], [AC_PROVIDE_IFELSE([LT_OUTPUT], dnl If the libtool generation code has been placed in $CONFIG_LT, dnl instead of duplicating it all over again into config.status, dnl then we will have config.status run $CONFIG_LT later, so it dnl needs to know what name is stored there: [AC_CONFIG_COMMANDS([libtool], [$SHELL $CONFIG_LT || AS_EXIT(1)], [CONFIG_LT='$CONFIG_LT'])], dnl If the libtool generation code is destined for config.status, dnl expand the accumulated commands and init code now: [AC_CONFIG_COMMANDS([libtool], [_LT_OUTPUT_LIBTOOL_COMMANDS], [_LT_OUTPUT_LIBTOOL_COMMANDS_INIT])]) ])#_LT_CONFIG_COMMANDS # Initialize. m4_define([_LT_OUTPUT_LIBTOOL_COMMANDS_INIT], [ # The HP-UX ksh and POSIX shell print the target directory to stdout # if CDPATH is set. (unset CDPATH) >/dev/null 2>&1 && unset CDPATH sed_quote_subst='$sed_quote_subst' double_quote_subst='$double_quote_subst' delay_variable_subst='$delay_variable_subst' _LT_CONFIG_STATUS_DECLARATIONS LTCC='$LTCC' LTCFLAGS='$LTCFLAGS' compiler='$compiler_DEFAULT' # A function that is used when there is no print builtin or printf. func_fallback_echo () { eval 'cat <<_LTECHO_EOF \$[]1 _LTECHO_EOF' } # Quote evaled strings. for var in lt_decl_all_varnames([[ \ ]], lt_decl_quote_varnames); do case \`eval \\\\\$ECHO \\\\""\\\\\$\$var"\\\\"\` in *[[\\\\\\\`\\"\\\$]]*) eval "lt_\$var=\\\\\\"\\\`\\\$ECHO \\"\\\$\$var\\" | \\\$SED \\"\\\$sed_quote_subst\\"\\\`\\\\\\"" ;; *) eval "lt_\$var=\\\\\\"\\\$\$var\\\\\\"" ;; esac done # Double-quote double-evaled strings. for var in lt_decl_all_varnames([[ \ ]], lt_decl_dquote_varnames); do case \`eval \\\\\$ECHO \\\\""\\\\\$\$var"\\\\"\` in *[[\\\\\\\`\\"\\\$]]*) eval "lt_\$var=\\\\\\"\\\`\\\$ECHO \\"\\\$\$var\\" | \\\$SED -e \\"\\\$double_quote_subst\\" -e \\"\\\$sed_quote_subst\\" -e \\"\\\$delay_variable_subst\\"\\\`\\\\\\"" ;; *) eval "lt_\$var=\\\\\\"\\\$\$var\\\\\\"" ;; esac done _LT_OUTPUT_LIBTOOL_INIT ]) # _LT_GENERATED_FILE_INIT(FILE, [COMMENT]) # ------------------------------------ # Generate a child script FILE with all initialization necessary to # reuse the environment learned by the parent script, and make the # file executable. If COMMENT is supplied, it is inserted after the # `#!' sequence but before initialization text begins. After this # macro, additional text can be appended to FILE to form the body of # the child script. The macro ends with non-zero status if the # file could not be fully written (such as if the disk is full). m4_ifdef([AS_INIT_GENERATED], [m4_defun([_LT_GENERATED_FILE_INIT],[AS_INIT_GENERATED($@)])], [m4_defun([_LT_GENERATED_FILE_INIT], [m4_require([AS_PREPARE])]dnl [m4_pushdef([AS_MESSAGE_LOG_FD])]dnl [lt_write_fail=0 cat >$1 <<_ASEOF || lt_write_fail=1 #! $SHELL # Generated by $as_me. $2 SHELL=\${CONFIG_SHELL-$SHELL} export SHELL _ASEOF cat >>$1 <<\_ASEOF || lt_write_fail=1 AS_SHELL_SANITIZE _AS_PREPARE exec AS_MESSAGE_FD>&1 _ASEOF test $lt_write_fail = 0 && chmod +x $1[]dnl m4_popdef([AS_MESSAGE_LOG_FD])])])# _LT_GENERATED_FILE_INIT # LT_OUTPUT # --------- # This macro allows early generation of the libtool script (before # AC_OUTPUT is called), incase it is used in configure for compilation # tests. AC_DEFUN([LT_OUTPUT], [: ${CONFIG_LT=./config.lt} AC_MSG_NOTICE([creating $CONFIG_LT]) _LT_GENERATED_FILE_INIT(["$CONFIG_LT"], [# Run this file to recreate a libtool stub with the current configuration.]) cat >>"$CONFIG_LT" <<\_LTEOF lt_cl_silent=false exec AS_MESSAGE_LOG_FD>>config.log { echo AS_BOX([Running $as_me.]) } >&AS_MESSAGE_LOG_FD lt_cl_help="\ \`$as_me' creates a local libtool stub from the current configuration, for use in further configure time tests before the real libtool is generated. Usage: $[0] [[OPTIONS]] -h, --help print this help, then exit -V, --version print version number, then exit -q, --quiet do not print progress messages -d, --debug don't remove temporary files Report bugs to ." lt_cl_version="\ m4_ifset([AC_PACKAGE_NAME], [AC_PACKAGE_NAME ])config.lt[]dnl m4_ifset([AC_PACKAGE_VERSION], [ AC_PACKAGE_VERSION]) configured by $[0], generated by m4_PACKAGE_STRING. Copyright (C) 2011 Free Software Foundation, Inc. This config.lt script is free software; the Free Software Foundation gives unlimited permision to copy, distribute and modify it." while test $[#] != 0 do case $[1] in --version | --v* | -V ) echo "$lt_cl_version"; exit 0 ;; --help | --h* | -h ) echo "$lt_cl_help"; exit 0 ;; --debug | --d* | -d ) debug=: ;; --quiet | --q* | --silent | --s* | -q ) lt_cl_silent=: ;; -*) AC_MSG_ERROR([unrecognized option: $[1] Try \`$[0] --help' for more information.]) ;; *) AC_MSG_ERROR([unrecognized argument: $[1] Try \`$[0] --help' for more information.]) ;; esac shift done if $lt_cl_silent; then exec AS_MESSAGE_FD>/dev/null fi _LTEOF cat >>"$CONFIG_LT" <<_LTEOF _LT_OUTPUT_LIBTOOL_COMMANDS_INIT _LTEOF cat >>"$CONFIG_LT" <<\_LTEOF AC_MSG_NOTICE([creating $ofile]) _LT_OUTPUT_LIBTOOL_COMMANDS AS_EXIT(0) _LTEOF chmod +x "$CONFIG_LT" # configure is writing to config.log, but config.lt does its own redirection, # appending to config.log, which fails on DOS, as config.log is still kept # open by configure. Here we exec the FD to /dev/null, effectively closing # config.log, so it can be properly (re)opened and appended to by config.lt. lt_cl_success=: test "$silent" = yes && lt_config_lt_args="$lt_config_lt_args --quiet" exec AS_MESSAGE_LOG_FD>/dev/null $SHELL "$CONFIG_LT" $lt_config_lt_args || lt_cl_success=false exec AS_MESSAGE_LOG_FD>>config.log $lt_cl_success || AS_EXIT(1) ])# LT_OUTPUT # _LT_CONFIG(TAG) # --------------- # If TAG is the built-in tag, create an initial libtool script with a # default configuration from the untagged config vars. Otherwise add code # to config.status for appending the configuration named by TAG from the # matching tagged config vars. m4_defun([_LT_CONFIG], [m4_require([_LT_FILEUTILS_DEFAULTS])dnl _LT_CONFIG_SAVE_COMMANDS([ m4_define([_LT_TAG], m4_if([$1], [], [C], [$1]))dnl m4_if(_LT_TAG, [C], [ # See if we are running on zsh, and set the options which allow our # commands through without removal of \ escapes. if test -n "${ZSH_VERSION+set}" ; then setopt NO_GLOB_SUBST fi cfgfile="${ofile}T" trap "$RM \"$cfgfile\"; exit 1" 1 2 15 $RM "$cfgfile" cat <<_LT_EOF >> "$cfgfile" #! $SHELL # `$ECHO "$ofile" | sed 's%^.*/%%'` - Provide generalized library-building support services. # Generated automatically by $as_me ($PACKAGE$TIMESTAMP) $VERSION # Libtool was configured on host `(hostname || uname -n) 2>/dev/null | sed 1q`: # NOTE: Changes made to this file will be lost: look at ltmain.sh. # _LT_COPYING _LT_LIBTOOL_TAGS # ### BEGIN LIBTOOL CONFIG _LT_LIBTOOL_CONFIG_VARS _LT_LIBTOOL_TAG_VARS # ### END LIBTOOL CONFIG _LT_EOF case $host_os in aix3*) cat <<\_LT_EOF >> "$cfgfile" # AIX sometimes has problems with the GCC collect2 program. For some # reason, if we set the COLLECT_NAMES environment variable, the problems # vanish in a puff of smoke. if test "X${COLLECT_NAMES+set}" != Xset; then COLLECT_NAMES= export COLLECT_NAMES fi _LT_EOF ;; esac _LT_PROG_LTMAIN # We use sed instead of cat because bash on DJGPP gets confused if # if finds mixed CR/LF and LF-only lines. Since sed operates in # text mode, it properly converts lines to CR/LF. This bash problem # is reportedly fixed, but why not run on old versions too? sed '$q' "$ltmain" >> "$cfgfile" \ || (rm -f "$cfgfile"; exit 1) _LT_PROG_REPLACE_SHELLFNS mv -f "$cfgfile" "$ofile" || (rm -f "$ofile" && cp "$cfgfile" "$ofile" && rm -f "$cfgfile") chmod +x "$ofile" ], [cat <<_LT_EOF >> "$ofile" dnl Unfortunately we have to use $1 here, since _LT_TAG is not expanded dnl in a comment (ie after a #). # ### BEGIN LIBTOOL TAG CONFIG: $1 _LT_LIBTOOL_TAG_VARS(_LT_TAG) # ### END LIBTOOL TAG CONFIG: $1 _LT_EOF ])dnl /m4_if ], [m4_if([$1], [], [ PACKAGE='$PACKAGE' VERSION='$VERSION' TIMESTAMP='$TIMESTAMP' RM='$RM' ofile='$ofile'], []) ])dnl /_LT_CONFIG_SAVE_COMMANDS ])# _LT_CONFIG # LT_SUPPORTED_TAG(TAG) # --------------------- # Trace this macro to discover what tags are supported by the libtool # --tag option, using: # autoconf --trace 'LT_SUPPORTED_TAG:$1' AC_DEFUN([LT_SUPPORTED_TAG], []) # C support is built-in for now m4_define([_LT_LANG_C_enabled], []) m4_define([_LT_TAGS], []) # LT_LANG(LANG) # ------------- # Enable libtool support for the given language if not already enabled. AC_DEFUN([LT_LANG], [AC_BEFORE([$0], [LT_OUTPUT])dnl m4_case([$1], [C], [_LT_LANG(C)], [C++], [_LT_LANG(CXX)], [Go], [_LT_LANG(GO)], [Java], [_LT_LANG(GCJ)], [Fortran 77], [_LT_LANG(F77)], [Fortran], [_LT_LANG(FC)], [Windows Resource], [_LT_LANG(RC)], [m4_ifdef([_LT_LANG_]$1[_CONFIG], [_LT_LANG($1)], [m4_fatal([$0: unsupported language: "$1"])])])dnl ])# LT_LANG # _LT_LANG(LANGNAME) # ------------------ m4_defun([_LT_LANG], [m4_ifdef([_LT_LANG_]$1[_enabled], [], [LT_SUPPORTED_TAG([$1])dnl m4_append([_LT_TAGS], [$1 ])dnl m4_define([_LT_LANG_]$1[_enabled], [])dnl _LT_LANG_$1_CONFIG($1)])dnl ])# _LT_LANG m4_ifndef([AC_PROG_GO], [ # NOTE: This macro has been submitted for inclusion into # # GNU Autoconf as AC_PROG_GO. When it is available in # # a released version of Autoconf we should remove this # # macro and use it instead. # m4_defun([AC_PROG_GO], [AC_LANG_PUSH(Go)dnl AC_ARG_VAR([GOC], [Go compiler command])dnl AC_ARG_VAR([GOFLAGS], [Go compiler flags])dnl _AC_ARG_VAR_LDFLAGS()dnl AC_CHECK_TOOL(GOC, gccgo) if test -z "$GOC"; then if test -n "$ac_tool_prefix"; then AC_CHECK_PROG(GOC, [${ac_tool_prefix}gccgo], [${ac_tool_prefix}gccgo]) fi fi if test -z "$GOC"; then AC_CHECK_PROG(GOC, gccgo, gccgo, false) fi ])#m4_defun ])#m4_ifndef # _LT_LANG_DEFAULT_CONFIG # ----------------------- m4_defun([_LT_LANG_DEFAULT_CONFIG], [AC_PROVIDE_IFELSE([AC_PROG_CXX], [LT_LANG(CXX)], [m4_define([AC_PROG_CXX], defn([AC_PROG_CXX])[LT_LANG(CXX)])]) AC_PROVIDE_IFELSE([AC_PROG_F77], [LT_LANG(F77)], [m4_define([AC_PROG_F77], defn([AC_PROG_F77])[LT_LANG(F77)])]) AC_PROVIDE_IFELSE([AC_PROG_FC], [LT_LANG(FC)], [m4_define([AC_PROG_FC], defn([AC_PROG_FC])[LT_LANG(FC)])]) dnl The call to [A][M_PROG_GCJ] is quoted like that to stop aclocal dnl pulling things in needlessly. AC_PROVIDE_IFELSE([AC_PROG_GCJ], [LT_LANG(GCJ)], [AC_PROVIDE_IFELSE([A][M_PROG_GCJ], [LT_LANG(GCJ)], [AC_PROVIDE_IFELSE([LT_PROG_GCJ], [LT_LANG(GCJ)], [m4_ifdef([AC_PROG_GCJ], [m4_define([AC_PROG_GCJ], defn([AC_PROG_GCJ])[LT_LANG(GCJ)])]) m4_ifdef([A][M_PROG_GCJ], [m4_define([A][M_PROG_GCJ], defn([A][M_PROG_GCJ])[LT_LANG(GCJ)])]) m4_ifdef([LT_PROG_GCJ], [m4_define([LT_PROG_GCJ], defn([LT_PROG_GCJ])[LT_LANG(GCJ)])])])])]) AC_PROVIDE_IFELSE([AC_PROG_GO], [LT_LANG(GO)], [m4_define([AC_PROG_GO], defn([AC_PROG_GO])[LT_LANG(GO)])]) AC_PROVIDE_IFELSE([LT_PROG_RC], [LT_LANG(RC)], [m4_define([LT_PROG_RC], defn([LT_PROG_RC])[LT_LANG(RC)])]) ])# _LT_LANG_DEFAULT_CONFIG # Obsolete macros: AU_DEFUN([AC_LIBTOOL_CXX], [LT_LANG(C++)]) AU_DEFUN([AC_LIBTOOL_F77], [LT_LANG(Fortran 77)]) AU_DEFUN([AC_LIBTOOL_FC], [LT_LANG(Fortran)]) AU_DEFUN([AC_LIBTOOL_GCJ], [LT_LANG(Java)]) AU_DEFUN([AC_LIBTOOL_RC], [LT_LANG(Windows Resource)]) dnl aclocal-1.4 backwards compatibility: dnl AC_DEFUN([AC_LIBTOOL_CXX], []) dnl AC_DEFUN([AC_LIBTOOL_F77], []) dnl AC_DEFUN([AC_LIBTOOL_FC], []) dnl AC_DEFUN([AC_LIBTOOL_GCJ], []) dnl AC_DEFUN([AC_LIBTOOL_RC], []) # _LT_TAG_COMPILER # ---------------- m4_defun([_LT_TAG_COMPILER], [AC_REQUIRE([AC_PROG_CC])dnl _LT_DECL([LTCC], [CC], [1], [A C compiler])dnl _LT_DECL([LTCFLAGS], [CFLAGS], [1], [LTCC compiler flags])dnl _LT_TAGDECL([CC], [compiler], [1], [A language specific compiler])dnl _LT_TAGDECL([with_gcc], [GCC], [0], [Is the compiler the GNU compiler?])dnl # If no C compiler was specified, use CC. LTCC=${LTCC-"$CC"} # If no C compiler flags were specified, use CFLAGS. LTCFLAGS=${LTCFLAGS-"$CFLAGS"} # Allow CC to be a program name with arguments. compiler=$CC ])# _LT_TAG_COMPILER # _LT_COMPILER_BOILERPLATE # ------------------------ # Check for compiler boilerplate output or warnings with # the simple compiler test code. m4_defun([_LT_COMPILER_BOILERPLATE], [m4_require([_LT_DECL_SED])dnl ac_outfile=conftest.$ac_objext echo "$lt_simple_compile_test_code" >conftest.$ac_ext eval "$ac_compile" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err _lt_compiler_boilerplate=`cat conftest.err` $RM conftest* ])# _LT_COMPILER_BOILERPLATE # _LT_LINKER_BOILERPLATE # ---------------------- # Check for linker boilerplate output or warnings with # the simple link test code. m4_defun([_LT_LINKER_BOILERPLATE], [m4_require([_LT_DECL_SED])dnl ac_outfile=conftest.$ac_objext echo "$lt_simple_link_test_code" >conftest.$ac_ext eval "$ac_link" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err _lt_linker_boilerplate=`cat conftest.err` $RM -r conftest* ])# _LT_LINKER_BOILERPLATE # _LT_REQUIRED_DARWIN_CHECKS # ------------------------- m4_defun_once([_LT_REQUIRED_DARWIN_CHECKS],[ case $host_os in rhapsody* | darwin*) AC_CHECK_TOOL([DSYMUTIL], [dsymutil], [:]) AC_CHECK_TOOL([NMEDIT], [nmedit], [:]) AC_CHECK_TOOL([LIPO], [lipo], [:]) AC_CHECK_TOOL([OTOOL], [otool], [:]) AC_CHECK_TOOL([OTOOL64], [otool64], [:]) _LT_DECL([], [DSYMUTIL], [1], [Tool to manipulate archived DWARF debug symbol files on Mac OS X]) _LT_DECL([], [NMEDIT], [1], [Tool to change global to local symbols on Mac OS X]) _LT_DECL([], [LIPO], [1], [Tool to manipulate fat objects and archives on Mac OS X]) _LT_DECL([], [OTOOL], [1], [ldd/readelf like tool for Mach-O binaries on Mac OS X]) _LT_DECL([], [OTOOL64], [1], [ldd/readelf like tool for 64 bit Mach-O binaries on Mac OS X 10.4]) AC_CACHE_CHECK([for -single_module linker flag],[lt_cv_apple_cc_single_mod], [lt_cv_apple_cc_single_mod=no if test -z "${LT_MULTI_MODULE}"; then # By default we will add the -single_module flag. You can override # by either setting the environment variable LT_MULTI_MODULE # non-empty at configure time, or by adding -multi_module to the # link flags. rm -rf libconftest.dylib* echo "int foo(void){return 1;}" > conftest.c echo "$LTCC $LTCFLAGS $LDFLAGS -o libconftest.dylib \ -dynamiclib -Wl,-single_module conftest.c" >&AS_MESSAGE_LOG_FD $LTCC $LTCFLAGS $LDFLAGS -o libconftest.dylib \ -dynamiclib -Wl,-single_module conftest.c 2>conftest.err _lt_result=$? # If there is a non-empty error log, and "single_module" # appears in it, assume the flag caused a linker warning if test -s conftest.err && $GREP single_module conftest.err; then cat conftest.err >&AS_MESSAGE_LOG_FD # Otherwise, if the output was created with a 0 exit code from # the compiler, it worked. elif test -f libconftest.dylib && test $_lt_result -eq 0; then lt_cv_apple_cc_single_mod=yes else cat conftest.err >&AS_MESSAGE_LOG_FD fi rm -rf libconftest.dylib* rm -f conftest.* fi]) AC_CACHE_CHECK([for -exported_symbols_list linker flag], [lt_cv_ld_exported_symbols_list], [lt_cv_ld_exported_symbols_list=no save_LDFLAGS=$LDFLAGS echo "_main" > conftest.sym LDFLAGS="$LDFLAGS -Wl,-exported_symbols_list,conftest.sym" AC_LINK_IFELSE([AC_LANG_PROGRAM([],[])], [lt_cv_ld_exported_symbols_list=yes], [lt_cv_ld_exported_symbols_list=no]) LDFLAGS="$save_LDFLAGS" ]) AC_CACHE_CHECK([for -force_load linker flag],[lt_cv_ld_force_load], [lt_cv_ld_force_load=no cat > conftest.c << _LT_EOF int forced_loaded() { return 2;} _LT_EOF echo "$LTCC $LTCFLAGS -c -o conftest.o conftest.c" >&AS_MESSAGE_LOG_FD $LTCC $LTCFLAGS -c -o conftest.o conftest.c 2>&AS_MESSAGE_LOG_FD echo "$AR cru libconftest.a conftest.o" >&AS_MESSAGE_LOG_FD $AR cru libconftest.a conftest.o 2>&AS_MESSAGE_LOG_FD echo "$RANLIB libconftest.a" >&AS_MESSAGE_LOG_FD $RANLIB libconftest.a 2>&AS_MESSAGE_LOG_FD cat > conftest.c << _LT_EOF int main() { return 0;} _LT_EOF echo "$LTCC $LTCFLAGS $LDFLAGS -o conftest conftest.c -Wl,-force_load,./libconftest.a" >&AS_MESSAGE_LOG_FD $LTCC $LTCFLAGS $LDFLAGS -o conftest conftest.c -Wl,-force_load,./libconftest.a 2>conftest.err _lt_result=$? if test -s conftest.err && $GREP force_load conftest.err; then cat conftest.err >&AS_MESSAGE_LOG_FD elif test -f conftest && test $_lt_result -eq 0 && $GREP forced_load conftest >/dev/null 2>&1 ; then lt_cv_ld_force_load=yes else cat conftest.err >&AS_MESSAGE_LOG_FD fi rm -f conftest.err libconftest.a conftest conftest.c rm -rf conftest.dSYM ]) case $host_os in rhapsody* | darwin1.[[012]]) _lt_dar_allow_undefined='${wl}-undefined ${wl}suppress' ;; darwin1.*) _lt_dar_allow_undefined='${wl}-flat_namespace ${wl}-undefined ${wl}suppress' ;; darwin*) # darwin 5.x on # if running on 10.5 or later, the deployment target defaults # to the OS version, if on x86, and 10.4, the deployment # target defaults to 10.4. Don't you love it? case ${MACOSX_DEPLOYMENT_TARGET-10.0},$host in 10.0,*86*-darwin8*|10.0,*-darwin[[91]]*) _lt_dar_allow_undefined='${wl}-undefined ${wl}dynamic_lookup' ;; 10.[[012]]*) _lt_dar_allow_undefined='${wl}-flat_namespace ${wl}-undefined ${wl}suppress' ;; 10.*) _lt_dar_allow_undefined='${wl}-undefined ${wl}dynamic_lookup' ;; esac ;; esac if test "$lt_cv_apple_cc_single_mod" = "yes"; then _lt_dar_single_mod='$single_module' fi if test "$lt_cv_ld_exported_symbols_list" = "yes"; then _lt_dar_export_syms=' ${wl}-exported_symbols_list,$output_objdir/${libname}-symbols.expsym' else _lt_dar_export_syms='~$NMEDIT -s $output_objdir/${libname}-symbols.expsym ${lib}' fi if test "$DSYMUTIL" != ":" && test "$lt_cv_ld_force_load" = "no"; then _lt_dsymutil='~$DSYMUTIL $lib || :' else _lt_dsymutil= fi ;; esac ]) # _LT_DARWIN_LINKER_FEATURES([TAG]) # --------------------------------- # Checks for linker and compiler features on darwin m4_defun([_LT_DARWIN_LINKER_FEATURES], [ m4_require([_LT_REQUIRED_DARWIN_CHECKS]) _LT_TAGVAR(archive_cmds_need_lc, $1)=no _LT_TAGVAR(hardcode_direct, $1)=no _LT_TAGVAR(hardcode_automatic, $1)=yes _LT_TAGVAR(hardcode_shlibpath_var, $1)=unsupported if test "$lt_cv_ld_force_load" = "yes"; then _LT_TAGVAR(whole_archive_flag_spec, $1)='`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience ${wl}-force_load,$conv\"; done; func_echo_all \"$new_convenience\"`' m4_case([$1], [F77], [_LT_TAGVAR(compiler_needs_object, $1)=yes], [FC], [_LT_TAGVAR(compiler_needs_object, $1)=yes]) else _LT_TAGVAR(whole_archive_flag_spec, $1)='' fi _LT_TAGVAR(link_all_deplibs, $1)=yes _LT_TAGVAR(allow_undefined_flag, $1)="$_lt_dar_allow_undefined" case $cc_basename in ifort*) _lt_dar_can_shared=yes ;; *) _lt_dar_can_shared=$GCC ;; esac if test "$_lt_dar_can_shared" = "yes"; then output_verbose_link_cmd=func_echo_all _LT_TAGVAR(archive_cmds, $1)="\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring $_lt_dar_single_mod${_lt_dsymutil}" _LT_TAGVAR(module_cmds, $1)="\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags${_lt_dsymutil}" _LT_TAGVAR(archive_expsym_cmds, $1)="sed 's,^,_,' < \$export_symbols > \$output_objdir/\${libname}-symbols.expsym~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring ${_lt_dar_single_mod}${_lt_dar_export_syms}${_lt_dsymutil}" _LT_TAGVAR(module_expsym_cmds, $1)="sed -e 's,^,_,' < \$export_symbols > \$output_objdir/\${libname}-symbols.expsym~\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags${_lt_dar_export_syms}${_lt_dsymutil}" m4_if([$1], [CXX], [ if test "$lt_cv_apple_cc_single_mod" != "yes"; then _LT_TAGVAR(archive_cmds, $1)="\$CC -r -keep_private_externs -nostdlib -o \${lib}-master.o \$libobjs~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \${lib}-master.o \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring${_lt_dsymutil}" _LT_TAGVAR(archive_expsym_cmds, $1)="sed 's,^,_,' < \$export_symbols > \$output_objdir/\${libname}-symbols.expsym~\$CC -r -keep_private_externs -nostdlib -o \${lib}-master.o \$libobjs~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \${lib}-master.o \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring${_lt_dar_export_syms}${_lt_dsymutil}" fi ],[]) else _LT_TAGVAR(ld_shlibs, $1)=no fi ]) # _LT_SYS_MODULE_PATH_AIX([TAGNAME]) # ---------------------------------- # Links a minimal program and checks the executable # for the system default hardcoded library path. In most cases, # this is /usr/lib:/lib, but when the MPI compilers are used # the location of the communication and MPI libs are included too. # If we don't find anything, use the default library path according # to the aix ld manual. # Store the results from the different compilers for each TAGNAME. # Allow to override them for all tags through lt_cv_aix_libpath. m4_defun([_LT_SYS_MODULE_PATH_AIX], [m4_require([_LT_DECL_SED])dnl if test "${lt_cv_aix_libpath+set}" = set; then aix_libpath=$lt_cv_aix_libpath else AC_CACHE_VAL([_LT_TAGVAR([lt_cv_aix_libpath_], [$1])], [AC_LINK_IFELSE([AC_LANG_PROGRAM],[ lt_aix_libpath_sed='[ /Import File Strings/,/^$/ { /^0/ { s/^0 *\([^ ]*\) *$/\1/ p } }]' _LT_TAGVAR([lt_cv_aix_libpath_], [$1])=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"` # Check for a 64-bit object if we didn't find anything. if test -z "$_LT_TAGVAR([lt_cv_aix_libpath_], [$1])"; then _LT_TAGVAR([lt_cv_aix_libpath_], [$1])=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"` fi],[]) if test -z "$_LT_TAGVAR([lt_cv_aix_libpath_], [$1])"; then _LT_TAGVAR([lt_cv_aix_libpath_], [$1])="/usr/lib:/lib" fi ]) aix_libpath=$_LT_TAGVAR([lt_cv_aix_libpath_], [$1]) fi ])# _LT_SYS_MODULE_PATH_AIX # _LT_SHELL_INIT(ARG) # ------------------- m4_define([_LT_SHELL_INIT], [m4_divert_text([M4SH-INIT], [$1 ])])# _LT_SHELL_INIT # _LT_PROG_ECHO_BACKSLASH # ----------------------- # Find how we can fake an echo command that does not interpret backslash. # In particular, with Autoconf 2.60 or later we add some code to the start # of the generated configure script which will find a shell with a builtin # printf (which we can use as an echo command). m4_defun([_LT_PROG_ECHO_BACKSLASH], [ECHO='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO$ECHO AC_MSG_CHECKING([how to print strings]) # Test print first, because it will be a builtin if present. if test "X`( print -r -- -n ) 2>/dev/null`" = X-n && \ test "X`print -r -- $ECHO 2>/dev/null`" = "X$ECHO"; then ECHO='print -r --' elif test "X`printf %s $ECHO 2>/dev/null`" = "X$ECHO"; then ECHO='printf %s\n' else # Use this function as a fallback that always works. func_fallback_echo () { eval 'cat <<_LTECHO_EOF $[]1 _LTECHO_EOF' } ECHO='func_fallback_echo' fi # func_echo_all arg... # Invoke $ECHO with all args, space-separated. func_echo_all () { $ECHO "$*" } case "$ECHO" in printf*) AC_MSG_RESULT([printf]) ;; print*) AC_MSG_RESULT([print -r]) ;; *) AC_MSG_RESULT([cat]) ;; esac m4_ifdef([_AS_DETECT_SUGGESTED], [_AS_DETECT_SUGGESTED([ test -n "${ZSH_VERSION+set}${BASH_VERSION+set}" || ( ECHO='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO$ECHO PATH=/empty FPATH=/empty; export PATH FPATH test "X`printf %s $ECHO`" = "X$ECHO" \ || test "X`print -r -- $ECHO`" = "X$ECHO" )])]) _LT_DECL([], [SHELL], [1], [Shell to use when invoking shell scripts]) _LT_DECL([], [ECHO], [1], [An echo program that protects backslashes]) ])# _LT_PROG_ECHO_BACKSLASH # _LT_WITH_SYSROOT # ---------------- AC_DEFUN([_LT_WITH_SYSROOT], [AC_MSG_CHECKING([for sysroot]) AC_ARG_WITH([sysroot], [ --with-sysroot[=DIR] Search for dependent libraries within DIR (or the compiler's sysroot if not specified).], [], [with_sysroot=no]) dnl lt_sysroot will always be passed unquoted. We quote it here dnl in case the user passed a directory name. lt_sysroot= case ${with_sysroot} in #( yes) if test "$GCC" = yes; then lt_sysroot=`$CC --print-sysroot 2>/dev/null` fi ;; #( /*) lt_sysroot=`echo "$with_sysroot" | sed -e "$sed_quote_subst"` ;; #( no|'') ;; #( *) AC_MSG_RESULT([${with_sysroot}]) AC_MSG_ERROR([The sysroot must be an absolute path.]) ;; esac AC_MSG_RESULT([${lt_sysroot:-no}]) _LT_DECL([], [lt_sysroot], [0], [The root where to search for ]dnl [dependent libraries, and in which our libraries should be installed.])]) # _LT_ENABLE_LOCK # --------------- m4_defun([_LT_ENABLE_LOCK], [AC_ARG_ENABLE([libtool-lock], [AS_HELP_STRING([--disable-libtool-lock], [avoid locking (might break parallel builds)])]) test "x$enable_libtool_lock" != xno && enable_libtool_lock=yes # Some flags need to be propagated to the compiler or linker for good # libtool support. case $host in ia64-*-hpux*) # Find out which ABI we are using. echo 'int i;' > conftest.$ac_ext if AC_TRY_EVAL(ac_compile); then case `/usr/bin/file conftest.$ac_objext` in *ELF-32*) HPUX_IA64_MODE="32" ;; *ELF-64*) HPUX_IA64_MODE="64" ;; esac fi rm -rf conftest* ;; *-*-irix6*) # Find out which ABI we are using. echo '[#]line '$LINENO' "configure"' > conftest.$ac_ext if AC_TRY_EVAL(ac_compile); then if test "$lt_cv_prog_gnu_ld" = yes; then case `/usr/bin/file conftest.$ac_objext` in *32-bit*) LD="${LD-ld} -melf32bsmip" ;; *N32*) LD="${LD-ld} -melf32bmipn32" ;; *64-bit*) LD="${LD-ld} -melf64bmip" ;; esac else case `/usr/bin/file conftest.$ac_objext` in *32-bit*) LD="${LD-ld} -32" ;; *N32*) LD="${LD-ld} -n32" ;; *64-bit*) LD="${LD-ld} -64" ;; esac fi fi rm -rf conftest* ;; x86_64-*kfreebsd*-gnu|x86_64-*linux*|ppc*-*linux*|powerpc*-*linux*| \ s390*-*linux*|s390*-*tpf*|sparc*-*linux*) # Find out which ABI we are using. echo 'int i;' > conftest.$ac_ext if AC_TRY_EVAL(ac_compile); then case `/usr/bin/file conftest.o` in *32-bit*) case $host in x86_64-*kfreebsd*-gnu) LD="${LD-ld} -m elf_i386_fbsd" ;; x86_64-*linux*) LD="${LD-ld} -m elf_i386" ;; ppc64-*linux*|powerpc64-*linux*) LD="${LD-ld} -m elf32ppclinux" ;; s390x-*linux*) LD="${LD-ld} -m elf_s390" ;; sparc64-*linux*) LD="${LD-ld} -m elf32_sparc" ;; esac ;; *64-bit*) case $host in x86_64-*kfreebsd*-gnu) LD="${LD-ld} -m elf_x86_64_fbsd" ;; x86_64-*linux*) LD="${LD-ld} -m elf_x86_64" ;; ppc*-*linux*|powerpc*-*linux*) LD="${LD-ld} -m elf64ppc" ;; s390*-*linux*|s390*-*tpf*) LD="${LD-ld} -m elf64_s390" ;; sparc*-*linux*) LD="${LD-ld} -m elf64_sparc" ;; esac ;; esac fi rm -rf conftest* ;; *-*-sco3.2v5*) # On SCO OpenServer 5, we need -belf to get full-featured binaries. SAVE_CFLAGS="$CFLAGS" CFLAGS="$CFLAGS -belf" AC_CACHE_CHECK([whether the C compiler needs -belf], lt_cv_cc_needs_belf, [AC_LANG_PUSH(C) AC_LINK_IFELSE([AC_LANG_PROGRAM([[]],[[]])],[lt_cv_cc_needs_belf=yes],[lt_cv_cc_needs_belf=no]) AC_LANG_POP]) if test x"$lt_cv_cc_needs_belf" != x"yes"; then # this is probably gcc 2.8.0, egcs 1.0 or newer; no need for -belf CFLAGS="$SAVE_CFLAGS" fi ;; *-*solaris*) # Find out which ABI we are using. echo 'int i;' > conftest.$ac_ext if AC_TRY_EVAL(ac_compile); then case `/usr/bin/file conftest.o` in *64-bit*) case $lt_cv_prog_gnu_ld in yes*) case $host in i?86-*-solaris*) LD="${LD-ld} -m elf_x86_64" ;; sparc*-*-solaris*) LD="${LD-ld} -m elf64_sparc" ;; esac # GNU ld 2.21 introduced _sol2 emulations. Use them if available. if ${LD-ld} -V | grep _sol2 >/dev/null 2>&1; then LD="${LD-ld}_sol2" fi ;; *) if ${LD-ld} -64 -r -o conftest2.o conftest.o >/dev/null 2>&1; then LD="${LD-ld} -64" fi ;; esac ;; esac fi rm -rf conftest* ;; esac need_locks="$enable_libtool_lock" ])# _LT_ENABLE_LOCK # _LT_PROG_AR # ----------- m4_defun([_LT_PROG_AR], [AC_CHECK_TOOLS(AR, [ar], false) : ${AR=ar} : ${AR_FLAGS=cru} _LT_DECL([], [AR], [1], [The archiver]) _LT_DECL([], [AR_FLAGS], [1], [Flags to create an archive]) AC_CACHE_CHECK([for archiver @FILE support], [lt_cv_ar_at_file], [lt_cv_ar_at_file=no AC_COMPILE_IFELSE([AC_LANG_PROGRAM], [echo conftest.$ac_objext > conftest.lst lt_ar_try='$AR $AR_FLAGS libconftest.a @conftest.lst >&AS_MESSAGE_LOG_FD' AC_TRY_EVAL([lt_ar_try]) if test "$ac_status" -eq 0; then # Ensure the archiver fails upon bogus file names. rm -f conftest.$ac_objext libconftest.a AC_TRY_EVAL([lt_ar_try]) if test "$ac_status" -ne 0; then lt_cv_ar_at_file=@ fi fi rm -f conftest.* libconftest.a ]) ]) if test "x$lt_cv_ar_at_file" = xno; then archiver_list_spec= else archiver_list_spec=$lt_cv_ar_at_file fi _LT_DECL([], [archiver_list_spec], [1], [How to feed a file listing to the archiver]) ])# _LT_PROG_AR # _LT_CMD_OLD_ARCHIVE # ------------------- m4_defun([_LT_CMD_OLD_ARCHIVE], [_LT_PROG_AR AC_CHECK_TOOL(STRIP, strip, :) test -z "$STRIP" && STRIP=: _LT_DECL([], [STRIP], [1], [A symbol stripping program]) AC_CHECK_TOOL(RANLIB, ranlib, :) test -z "$RANLIB" && RANLIB=: _LT_DECL([], [RANLIB], [1], [Commands used to install an old-style archive]) # Determine commands to create old-style static archives. old_archive_cmds='$AR $AR_FLAGS $oldlib$oldobjs' old_postinstall_cmds='chmod 644 $oldlib' old_postuninstall_cmds= if test -n "$RANLIB"; then case $host_os in openbsd*) old_postinstall_cmds="$old_postinstall_cmds~\$RANLIB -t \$tool_oldlib" ;; *) old_postinstall_cmds="$old_postinstall_cmds~\$RANLIB \$tool_oldlib" ;; esac old_archive_cmds="$old_archive_cmds~\$RANLIB \$tool_oldlib" fi case $host_os in darwin*) lock_old_archive_extraction=yes ;; *) lock_old_archive_extraction=no ;; esac _LT_DECL([], [old_postinstall_cmds], [2]) _LT_DECL([], [old_postuninstall_cmds], [2]) _LT_TAGDECL([], [old_archive_cmds], [2], [Commands used to build an old-style archive]) _LT_DECL([], [lock_old_archive_extraction], [0], [Whether to use a lock for old archive extraction]) ])# _LT_CMD_OLD_ARCHIVE # _LT_COMPILER_OPTION(MESSAGE, VARIABLE-NAME, FLAGS, # [OUTPUT-FILE], [ACTION-SUCCESS], [ACTION-FAILURE]) # ---------------------------------------------------------------- # Check whether the given compiler option works AC_DEFUN([_LT_COMPILER_OPTION], [m4_require([_LT_FILEUTILS_DEFAULTS])dnl m4_require([_LT_DECL_SED])dnl AC_CACHE_CHECK([$1], [$2], [$2=no m4_if([$4], , [ac_outfile=conftest.$ac_objext], [ac_outfile=$4]) echo "$lt_simple_compile_test_code" > conftest.$ac_ext lt_compiler_flag="$3" # Insert the option either (1) after the last *FLAGS variable, or # (2) before a word containing "conftest.", or (3) at the end. # Note that $ac_compile itself does not contain backslashes and begins # with a dollar sign (not a hyphen), so the echo should work correctly. # The option is referenced via a variable to avoid confusing sed. lt_compile=`echo "$ac_compile" | $SED \ -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \ -e 's: [[^ ]]*conftest\.: $lt_compiler_flag&:; t' \ -e 's:$: $lt_compiler_flag:'` (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&AS_MESSAGE_LOG_FD) (eval "$lt_compile" 2>conftest.err) ac_status=$? cat conftest.err >&AS_MESSAGE_LOG_FD echo "$as_me:$LINENO: \$? = $ac_status" >&AS_MESSAGE_LOG_FD if (exit $ac_status) && test -s "$ac_outfile"; then # The compiler can only warn and ignore the option if not recognized # So say no if there are warnings other than the usual output. $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' >conftest.exp $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2 if test ! -s conftest.er2 || diff conftest.exp conftest.er2 >/dev/null; then $2=yes fi fi $RM conftest* ]) if test x"[$]$2" = xyes; then m4_if([$5], , :, [$5]) else m4_if([$6], , :, [$6]) fi ])# _LT_COMPILER_OPTION # Old name: AU_ALIAS([AC_LIBTOOL_COMPILER_OPTION], [_LT_COMPILER_OPTION]) dnl aclocal-1.4 backwards compatibility: dnl AC_DEFUN([AC_LIBTOOL_COMPILER_OPTION], []) # _LT_LINKER_OPTION(MESSAGE, VARIABLE-NAME, FLAGS, # [ACTION-SUCCESS], [ACTION-FAILURE]) # ---------------------------------------------------- # Check whether the given linker option works AC_DEFUN([_LT_LINKER_OPTION], [m4_require([_LT_FILEUTILS_DEFAULTS])dnl m4_require([_LT_DECL_SED])dnl AC_CACHE_CHECK([$1], [$2], [$2=no save_LDFLAGS="$LDFLAGS" LDFLAGS="$LDFLAGS $3" echo "$lt_simple_link_test_code" > conftest.$ac_ext if (eval $ac_link 2>conftest.err) && test -s conftest$ac_exeext; then # The linker can only warn and ignore the option if not recognized # So say no if there are warnings if test -s conftest.err; then # Append any errors to the config.log. cat conftest.err 1>&AS_MESSAGE_LOG_FD $ECHO "$_lt_linker_boilerplate" | $SED '/^$/d' > conftest.exp $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2 if diff conftest.exp conftest.er2 >/dev/null; then $2=yes fi else $2=yes fi fi $RM -r conftest* LDFLAGS="$save_LDFLAGS" ]) if test x"[$]$2" = xyes; then m4_if([$4], , :, [$4]) else m4_if([$5], , :, [$5]) fi ])# _LT_LINKER_OPTION # Old name: AU_ALIAS([AC_LIBTOOL_LINKER_OPTION], [_LT_LINKER_OPTION]) dnl aclocal-1.4 backwards compatibility: dnl AC_DEFUN([AC_LIBTOOL_LINKER_OPTION], []) # LT_CMD_MAX_LEN #--------------- AC_DEFUN([LT_CMD_MAX_LEN], [AC_REQUIRE([AC_CANONICAL_HOST])dnl # find the maximum length of command line arguments AC_MSG_CHECKING([the maximum length of command line arguments]) AC_CACHE_VAL([lt_cv_sys_max_cmd_len], [dnl i=0 teststring="ABCD" case $build_os in msdosdjgpp*) # On DJGPP, this test can blow up pretty badly due to problems in libc # (any single argument exceeding 2000 bytes causes a buffer overrun # during glob expansion). Even if it were fixed, the result of this # check would be larger than it should be. lt_cv_sys_max_cmd_len=12288; # 12K is about right ;; gnu*) # Under GNU Hurd, this test is not required because there is # no limit to the length of command line arguments. # Libtool will interpret -1 as no limit whatsoever lt_cv_sys_max_cmd_len=-1; ;; cygwin* | mingw* | cegcc*) # On Win9x/ME, this test blows up -- it succeeds, but takes # about 5 minutes as the teststring grows exponentially. # Worse, since 9x/ME are not pre-emptively multitasking, # you end up with a "frozen" computer, even though with patience # the test eventually succeeds (with a max line length of 256k). # Instead, let's just punt: use the minimum linelength reported by # all of the supported platforms: 8192 (on NT/2K/XP). lt_cv_sys_max_cmd_len=8192; ;; mint*) # On MiNT this can take a long time and run out of memory. lt_cv_sys_max_cmd_len=8192; ;; amigaos*) # On AmigaOS with pdksh, this test takes hours, literally. # So we just punt and use a minimum line length of 8192. lt_cv_sys_max_cmd_len=8192; ;; netbsd* | freebsd* | openbsd* | darwin* | dragonfly*) # This has been around since 386BSD, at least. Likely further. if test -x /sbin/sysctl; then lt_cv_sys_max_cmd_len=`/sbin/sysctl -n kern.argmax` elif test -x /usr/sbin/sysctl; then lt_cv_sys_max_cmd_len=`/usr/sbin/sysctl -n kern.argmax` else lt_cv_sys_max_cmd_len=65536 # usable default for all BSDs fi # And add a safety zone lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 4` lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \* 3` ;; interix*) # We know the value 262144 and hardcode it with a safety zone (like BSD) lt_cv_sys_max_cmd_len=196608 ;; os2*) # The test takes a long time on OS/2. lt_cv_sys_max_cmd_len=8192 ;; osf*) # Dr. Hans Ekkehard Plesser reports seeing a kernel panic running configure # due to this test when exec_disable_arg_limit is 1 on Tru64. It is not # nice to cause kernel panics so lets avoid the loop below. # First set a reasonable default. lt_cv_sys_max_cmd_len=16384 # if test -x /sbin/sysconfig; then case `/sbin/sysconfig -q proc exec_disable_arg_limit` in *1*) lt_cv_sys_max_cmd_len=-1 ;; esac fi ;; sco3.2v5*) lt_cv_sys_max_cmd_len=102400 ;; sysv5* | sco5v6* | sysv4.2uw2*) kargmax=`grep ARG_MAX /etc/conf/cf.d/stune 2>/dev/null` if test -n "$kargmax"; then lt_cv_sys_max_cmd_len=`echo $kargmax | sed 's/.*[[ ]]//'` else lt_cv_sys_max_cmd_len=32768 fi ;; *) lt_cv_sys_max_cmd_len=`(getconf ARG_MAX) 2> /dev/null` if test -n "$lt_cv_sys_max_cmd_len"; then lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 4` lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \* 3` else # Make teststring a little bigger before we do anything with it. # a 1K string should be a reasonable start. for i in 1 2 3 4 5 6 7 8 ; do teststring=$teststring$teststring done SHELL=${SHELL-${CONFIG_SHELL-/bin/sh}} # If test is not a shell built-in, we'll probably end up computing a # maximum length that is only half of the actual maximum length, but # we can't tell. while { test "X"`env echo "$teststring$teststring" 2>/dev/null` \ = "X$teststring$teststring"; } >/dev/null 2>&1 && test $i != 17 # 1/2 MB should be enough do i=`expr $i + 1` teststring=$teststring$teststring done # Only check the string length outside the loop. lt_cv_sys_max_cmd_len=`expr "X$teststring" : ".*" 2>&1` teststring= # Add a significant safety factor because C++ compilers can tack on # massive amounts of additional arguments before passing them to the # linker. It appears as though 1/2 is a usable value. lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 2` fi ;; esac ]) if test -n $lt_cv_sys_max_cmd_len ; then AC_MSG_RESULT($lt_cv_sys_max_cmd_len) else AC_MSG_RESULT(none) fi max_cmd_len=$lt_cv_sys_max_cmd_len _LT_DECL([], [max_cmd_len], [0], [What is the maximum length of a command?]) ])# LT_CMD_MAX_LEN # Old name: AU_ALIAS([AC_LIBTOOL_SYS_MAX_CMD_LEN], [LT_CMD_MAX_LEN]) dnl aclocal-1.4 backwards compatibility: dnl AC_DEFUN([AC_LIBTOOL_SYS_MAX_CMD_LEN], []) # _LT_HEADER_DLFCN # ---------------- m4_defun([_LT_HEADER_DLFCN], [AC_CHECK_HEADERS([dlfcn.h], [], [], [AC_INCLUDES_DEFAULT])dnl ])# _LT_HEADER_DLFCN # _LT_TRY_DLOPEN_SELF (ACTION-IF-TRUE, ACTION-IF-TRUE-W-USCORE, # ACTION-IF-FALSE, ACTION-IF-CROSS-COMPILING) # ---------------------------------------------------------------- m4_defun([_LT_TRY_DLOPEN_SELF], [m4_require([_LT_HEADER_DLFCN])dnl if test "$cross_compiling" = yes; then : [$4] else lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2 lt_status=$lt_dlunknown cat > conftest.$ac_ext <<_LT_EOF [#line $LINENO "configure" #include "confdefs.h" #if HAVE_DLFCN_H #include #endif #include #ifdef RTLD_GLOBAL # define LT_DLGLOBAL RTLD_GLOBAL #else # ifdef DL_GLOBAL # define LT_DLGLOBAL DL_GLOBAL # else # define LT_DLGLOBAL 0 # endif #endif /* We may have to define LT_DLLAZY_OR_NOW in the command line if we find out it does not work in some platform. */ #ifndef LT_DLLAZY_OR_NOW # ifdef RTLD_LAZY # define LT_DLLAZY_OR_NOW RTLD_LAZY # else # ifdef DL_LAZY # define LT_DLLAZY_OR_NOW DL_LAZY # else # ifdef RTLD_NOW # define LT_DLLAZY_OR_NOW RTLD_NOW # else # ifdef DL_NOW # define LT_DLLAZY_OR_NOW DL_NOW # else # define LT_DLLAZY_OR_NOW 0 # endif # endif # endif # endif #endif /* When -fvisbility=hidden is used, assume the code has been annotated correspondingly for the symbols needed. */ #if defined(__GNUC__) && (((__GNUC__ == 3) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 3)) int fnord () __attribute__((visibility("default"))); #endif int fnord () { return 42; } int main () { void *self = dlopen (0, LT_DLGLOBAL|LT_DLLAZY_OR_NOW); int status = $lt_dlunknown; if (self) { if (dlsym (self,"fnord")) status = $lt_dlno_uscore; else { if (dlsym( self,"_fnord")) status = $lt_dlneed_uscore; else puts (dlerror ()); } /* dlclose (self); */ } else puts (dlerror ()); return status; }] _LT_EOF if AC_TRY_EVAL(ac_link) && test -s conftest${ac_exeext} 2>/dev/null; then (./conftest; exit; ) >&AS_MESSAGE_LOG_FD 2>/dev/null lt_status=$? case x$lt_status in x$lt_dlno_uscore) $1 ;; x$lt_dlneed_uscore) $2 ;; x$lt_dlunknown|x*) $3 ;; esac else : # compilation failed $3 fi fi rm -fr conftest* ])# _LT_TRY_DLOPEN_SELF # LT_SYS_DLOPEN_SELF # ------------------ AC_DEFUN([LT_SYS_DLOPEN_SELF], [m4_require([_LT_HEADER_DLFCN])dnl if test "x$enable_dlopen" != xyes; then enable_dlopen=unknown enable_dlopen_self=unknown enable_dlopen_self_static=unknown else lt_cv_dlopen=no lt_cv_dlopen_libs= case $host_os in beos*) lt_cv_dlopen="load_add_on" lt_cv_dlopen_libs= lt_cv_dlopen_self=yes ;; mingw* | pw32* | cegcc*) lt_cv_dlopen="LoadLibrary" lt_cv_dlopen_libs= ;; cygwin*) lt_cv_dlopen="dlopen" lt_cv_dlopen_libs= ;; darwin*) # if libdl is installed we need to link against it AC_CHECK_LIB([dl], [dlopen], [lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-ldl"],[ lt_cv_dlopen="dyld" lt_cv_dlopen_libs= lt_cv_dlopen_self=yes ]) ;; *) AC_CHECK_FUNC([shl_load], [lt_cv_dlopen="shl_load"], [AC_CHECK_LIB([dld], [shl_load], [lt_cv_dlopen="shl_load" lt_cv_dlopen_libs="-ldld"], [AC_CHECK_FUNC([dlopen], [lt_cv_dlopen="dlopen"], [AC_CHECK_LIB([dl], [dlopen], [lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-ldl"], [AC_CHECK_LIB([svld], [dlopen], [lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-lsvld"], [AC_CHECK_LIB([dld], [dld_link], [lt_cv_dlopen="dld_link" lt_cv_dlopen_libs="-ldld"]) ]) ]) ]) ]) ]) ;; esac if test "x$lt_cv_dlopen" != xno; then enable_dlopen=yes else enable_dlopen=no fi case $lt_cv_dlopen in dlopen) save_CPPFLAGS="$CPPFLAGS" test "x$ac_cv_header_dlfcn_h" = xyes && CPPFLAGS="$CPPFLAGS -DHAVE_DLFCN_H" save_LDFLAGS="$LDFLAGS" wl=$lt_prog_compiler_wl eval LDFLAGS=\"\$LDFLAGS $export_dynamic_flag_spec\" save_LIBS="$LIBS" LIBS="$lt_cv_dlopen_libs $LIBS" AC_CACHE_CHECK([whether a program can dlopen itself], lt_cv_dlopen_self, [dnl _LT_TRY_DLOPEN_SELF( lt_cv_dlopen_self=yes, lt_cv_dlopen_self=yes, lt_cv_dlopen_self=no, lt_cv_dlopen_self=cross) ]) if test "x$lt_cv_dlopen_self" = xyes; then wl=$lt_prog_compiler_wl eval LDFLAGS=\"\$LDFLAGS $lt_prog_compiler_static\" AC_CACHE_CHECK([whether a statically linked program can dlopen itself], lt_cv_dlopen_self_static, [dnl _LT_TRY_DLOPEN_SELF( lt_cv_dlopen_self_static=yes, lt_cv_dlopen_self_static=yes, lt_cv_dlopen_self_static=no, lt_cv_dlopen_self_static=cross) ]) fi CPPFLAGS="$save_CPPFLAGS" LDFLAGS="$save_LDFLAGS" LIBS="$save_LIBS" ;; esac case $lt_cv_dlopen_self in yes|no) enable_dlopen_self=$lt_cv_dlopen_self ;; *) enable_dlopen_self=unknown ;; esac case $lt_cv_dlopen_self_static in yes|no) enable_dlopen_self_static=$lt_cv_dlopen_self_static ;; *) enable_dlopen_self_static=unknown ;; esac fi _LT_DECL([dlopen_support], [enable_dlopen], [0], [Whether dlopen is supported]) _LT_DECL([dlopen_self], [enable_dlopen_self], [0], [Whether dlopen of programs is supported]) _LT_DECL([dlopen_self_static], [enable_dlopen_self_static], [0], [Whether dlopen of statically linked programs is supported]) ])# LT_SYS_DLOPEN_SELF # Old name: AU_ALIAS([AC_LIBTOOL_DLOPEN_SELF], [LT_SYS_DLOPEN_SELF]) dnl aclocal-1.4 backwards compatibility: dnl AC_DEFUN([AC_LIBTOOL_DLOPEN_SELF], []) # _LT_COMPILER_C_O([TAGNAME]) # --------------------------- # Check to see if options -c and -o are simultaneously supported by compiler. # This macro does not hard code the compiler like AC_PROG_CC_C_O. m4_defun([_LT_COMPILER_C_O], [m4_require([_LT_DECL_SED])dnl m4_require([_LT_FILEUTILS_DEFAULTS])dnl m4_require([_LT_TAG_COMPILER])dnl AC_CACHE_CHECK([if $compiler supports -c -o file.$ac_objext], [_LT_TAGVAR(lt_cv_prog_compiler_c_o, $1)], [_LT_TAGVAR(lt_cv_prog_compiler_c_o, $1)=no $RM -r conftest 2>/dev/null mkdir conftest cd conftest mkdir out echo "$lt_simple_compile_test_code" > conftest.$ac_ext lt_compiler_flag="-o out/conftest2.$ac_objext" # Insert the option either (1) after the last *FLAGS variable, or # (2) before a word containing "conftest.", or (3) at the end. # Note that $ac_compile itself does not contain backslashes and begins # with a dollar sign (not a hyphen), so the echo should work correctly. lt_compile=`echo "$ac_compile" | $SED \ -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \ -e 's: [[^ ]]*conftest\.: $lt_compiler_flag&:; t' \ -e 's:$: $lt_compiler_flag:'` (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&AS_MESSAGE_LOG_FD) (eval "$lt_compile" 2>out/conftest.err) ac_status=$? cat out/conftest.err >&AS_MESSAGE_LOG_FD echo "$as_me:$LINENO: \$? = $ac_status" >&AS_MESSAGE_LOG_FD if (exit $ac_status) && test -s out/conftest2.$ac_objext then # The compiler can only warn and ignore the option if not recognized # So say no if there are warnings $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' > out/conftest.exp $SED '/^$/d; /^ *+/d' out/conftest.err >out/conftest.er2 if test ! -s out/conftest.er2 || diff out/conftest.exp out/conftest.er2 >/dev/null; then _LT_TAGVAR(lt_cv_prog_compiler_c_o, $1)=yes fi fi chmod u+w . 2>&AS_MESSAGE_LOG_FD $RM conftest* # SGI C++ compiler will create directory out/ii_files/ for # template instantiation test -d out/ii_files && $RM out/ii_files/* && rmdir out/ii_files $RM out/* && rmdir out cd .. $RM -r conftest $RM conftest* ]) _LT_TAGDECL([compiler_c_o], [lt_cv_prog_compiler_c_o], [1], [Does compiler simultaneously support -c and -o options?]) ])# _LT_COMPILER_C_O # _LT_COMPILER_FILE_LOCKS([TAGNAME]) # ---------------------------------- # Check to see if we can do hard links to lock some files if needed m4_defun([_LT_COMPILER_FILE_LOCKS], [m4_require([_LT_ENABLE_LOCK])dnl m4_require([_LT_FILEUTILS_DEFAULTS])dnl _LT_COMPILER_C_O([$1]) hard_links="nottested" if test "$_LT_TAGVAR(lt_cv_prog_compiler_c_o, $1)" = no && test "$need_locks" != no; then # do not overwrite the value of need_locks provided by the user AC_MSG_CHECKING([if we can lock with hard links]) hard_links=yes $RM conftest* ln conftest.a conftest.b 2>/dev/null && hard_links=no touch conftest.a ln conftest.a conftest.b 2>&5 || hard_links=no ln conftest.a conftest.b 2>/dev/null && hard_links=no AC_MSG_RESULT([$hard_links]) if test "$hard_links" = no; then AC_MSG_WARN([`$CC' does not support `-c -o', so `make -j' may be unsafe]) need_locks=warn fi else need_locks=no fi _LT_DECL([], [need_locks], [1], [Must we lock files when doing compilation?]) ])# _LT_COMPILER_FILE_LOCKS # _LT_CHECK_OBJDIR # ---------------- m4_defun([_LT_CHECK_OBJDIR], [AC_CACHE_CHECK([for objdir], [lt_cv_objdir], [rm -f .libs 2>/dev/null mkdir .libs 2>/dev/null if test -d .libs; then lt_cv_objdir=.libs else # MS-DOS does not allow filenames that begin with a dot. lt_cv_objdir=_libs fi rmdir .libs 2>/dev/null]) objdir=$lt_cv_objdir _LT_DECL([], [objdir], [0], [The name of the directory that contains temporary libtool files])dnl m4_pattern_allow([LT_OBJDIR])dnl AC_DEFINE_UNQUOTED(LT_OBJDIR, "$lt_cv_objdir/", [Define to the sub-directory in which libtool stores uninstalled libraries.]) ])# _LT_CHECK_OBJDIR # _LT_LINKER_HARDCODE_LIBPATH([TAGNAME]) # -------------------------------------- # Check hardcoding attributes. m4_defun([_LT_LINKER_HARDCODE_LIBPATH], [AC_MSG_CHECKING([how to hardcode library paths into programs]) _LT_TAGVAR(hardcode_action, $1)= if test -n "$_LT_TAGVAR(hardcode_libdir_flag_spec, $1)" || test -n "$_LT_TAGVAR(runpath_var, $1)" || test "X$_LT_TAGVAR(hardcode_automatic, $1)" = "Xyes" ; then # We can hardcode non-existent directories. if test "$_LT_TAGVAR(hardcode_direct, $1)" != no && # If the only mechanism to avoid hardcoding is shlibpath_var, we # have to relink, otherwise we might link with an installed library # when we should be linking with a yet-to-be-installed one ## test "$_LT_TAGVAR(hardcode_shlibpath_var, $1)" != no && test "$_LT_TAGVAR(hardcode_minus_L, $1)" != no; then # Linking always hardcodes the temporary library directory. _LT_TAGVAR(hardcode_action, $1)=relink else # We can link without hardcoding, and we can hardcode nonexisting dirs. _LT_TAGVAR(hardcode_action, $1)=immediate fi else # We cannot hardcode anything, or else we can only hardcode existing # directories. _LT_TAGVAR(hardcode_action, $1)=unsupported fi AC_MSG_RESULT([$_LT_TAGVAR(hardcode_action, $1)]) if test "$_LT_TAGVAR(hardcode_action, $1)" = relink || test "$_LT_TAGVAR(inherit_rpath, $1)" = yes; then # Fast installation is not supported enable_fast_install=no elif test "$shlibpath_overrides_runpath" = yes || test "$enable_shared" = no; then # Fast installation is not necessary enable_fast_install=needless fi _LT_TAGDECL([], [hardcode_action], [0], [How to hardcode a shared library path into an executable]) ])# _LT_LINKER_HARDCODE_LIBPATH # _LT_CMD_STRIPLIB # ---------------- m4_defun([_LT_CMD_STRIPLIB], [m4_require([_LT_DECL_EGREP]) striplib= old_striplib= AC_MSG_CHECKING([whether stripping libraries is possible]) if test -n "$STRIP" && $STRIP -V 2>&1 | $GREP "GNU strip" >/dev/null; then test -z "$old_striplib" && old_striplib="$STRIP --strip-debug" test -z "$striplib" && striplib="$STRIP --strip-unneeded" AC_MSG_RESULT([yes]) else # FIXME - insert some real tests, host_os isn't really good enough case $host_os in darwin*) if test -n "$STRIP" ; then striplib="$STRIP -x" old_striplib="$STRIP -S" AC_MSG_RESULT([yes]) else AC_MSG_RESULT([no]) fi ;; *) AC_MSG_RESULT([no]) ;; esac fi _LT_DECL([], [old_striplib], [1], [Commands to strip libraries]) _LT_DECL([], [striplib], [1]) ])# _LT_CMD_STRIPLIB # _LT_SYS_DYNAMIC_LINKER([TAG]) # ----------------------------- # PORTME Fill in your ld.so characteristics m4_defun([_LT_SYS_DYNAMIC_LINKER], [AC_REQUIRE([AC_CANONICAL_HOST])dnl m4_require([_LT_DECL_EGREP])dnl m4_require([_LT_FILEUTILS_DEFAULTS])dnl m4_require([_LT_DECL_OBJDUMP])dnl m4_require([_LT_DECL_SED])dnl m4_require([_LT_CHECK_SHELL_FEATURES])dnl AC_MSG_CHECKING([dynamic linker characteristics]) m4_if([$1], [], [ if test "$GCC" = yes; then case $host_os in darwin*) lt_awk_arg="/^libraries:/,/LR/" ;; *) lt_awk_arg="/^libraries:/" ;; esac case $host_os in mingw* | cegcc*) lt_sed_strip_eq="s,=\([[A-Za-z]]:\),\1,g" ;; *) lt_sed_strip_eq="s,=/,/,g" ;; esac lt_search_path_spec=`$CC -print-search-dirs | awk $lt_awk_arg | $SED -e "s/^libraries://" -e $lt_sed_strip_eq` case $lt_search_path_spec in *\;*) # if the path contains ";" then we assume it to be the separator # otherwise default to the standard path separator (i.e. ":") - it is # assumed that no part of a normal pathname contains ";" but that should # okay in the real world where ";" in dirpaths is itself problematic. lt_search_path_spec=`$ECHO "$lt_search_path_spec" | $SED 's/;/ /g'` ;; *) lt_search_path_spec=`$ECHO "$lt_search_path_spec" | $SED "s/$PATH_SEPARATOR/ /g"` ;; esac # Ok, now we have the path, separated by spaces, we can step through it # and add multilib dir if necessary. lt_tmp_lt_search_path_spec= lt_multi_os_dir=`$CC $CPPFLAGS $CFLAGS $LDFLAGS -print-multi-os-directory 2>/dev/null` for lt_sys_path in $lt_search_path_spec; do if test -d "$lt_sys_path/$lt_multi_os_dir"; then lt_tmp_lt_search_path_spec="$lt_tmp_lt_search_path_spec $lt_sys_path/$lt_multi_os_dir" else test -d "$lt_sys_path" && \ lt_tmp_lt_search_path_spec="$lt_tmp_lt_search_path_spec $lt_sys_path" fi done lt_search_path_spec=`$ECHO "$lt_tmp_lt_search_path_spec" | awk ' BEGIN {RS=" "; FS="/|\n";} { lt_foo=""; lt_count=0; for (lt_i = NF; lt_i > 0; lt_i--) { if ($lt_i != "" && $lt_i != ".") { if ($lt_i == "..") { lt_count++; } else { if (lt_count == 0) { lt_foo="/" $lt_i lt_foo; } else { lt_count--; } } } } if (lt_foo != "") { lt_freq[[lt_foo]]++; } if (lt_freq[[lt_foo]] == 1) { print lt_foo; } }'` # AWK program above erroneously prepends '/' to C:/dos/paths # for these hosts. case $host_os in mingw* | cegcc*) lt_search_path_spec=`$ECHO "$lt_search_path_spec" |\ $SED 's,/\([[A-Za-z]]:\),\1,g'` ;; esac sys_lib_search_path_spec=`$ECHO "$lt_search_path_spec" | $lt_NL2SP` else sys_lib_search_path_spec="/lib /usr/lib /usr/local/lib" fi]) library_names_spec= libname_spec='lib$name' soname_spec= shrext_cmds=".so" postinstall_cmds= postuninstall_cmds= finish_cmds= finish_eval= shlibpath_var= shlibpath_overrides_runpath=unknown version_type=none dynamic_linker="$host_os ld.so" sys_lib_dlsearch_path_spec="/lib /usr/lib" need_lib_prefix=unknown hardcode_into_libs=no # when you set need_version to no, make sure it does not cause -set_version # flags to be left without arguments need_version=unknown case $host_os in aix3*) version_type=linux # correct to gnu/linux during the next big refactor library_names_spec='${libname}${release}${shared_ext}$versuffix $libname.a' shlibpath_var=LIBPATH # AIX 3 has no versioning support, so we append a major version to the name. soname_spec='${libname}${release}${shared_ext}$major' ;; aix[[4-9]]*) version_type=linux # correct to gnu/linux during the next big refactor need_lib_prefix=no need_version=no hardcode_into_libs=yes if test "$host_cpu" = ia64; then # AIX 5 supports IA64 library_names_spec='${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext}$versuffix $libname${shared_ext}' shlibpath_var=LD_LIBRARY_PATH else # With GCC up to 2.95.x, collect2 would create an import file # for dependence libraries. The import file would start with # the line `#! .'. This would cause the generated library to # depend on `.', always an invalid library. This was fixed in # development snapshots of GCC prior to 3.0. case $host_os in aix4 | aix4.[[01]] | aix4.[[01]].*) if { echo '#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 97)' echo ' yes ' echo '#endif'; } | ${CC} -E - | $GREP yes > /dev/null; then : else can_build_shared=no fi ;; esac # AIX (on Power*) has no versioning support, so currently we can not hardcode correct # soname into executable. Probably we can add versioning support to # collect2, so additional links can be useful in future. if test "$aix_use_runtimelinking" = yes; then # If using run time linking (on AIX 4.2 or later) use lib.so # instead of lib.a to let people know that these are not # typical AIX shared libraries. library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' else # We preserve .a as extension for shared libraries through AIX4.2 # and later when we are not doing run time linking. library_names_spec='${libname}${release}.a $libname.a' soname_spec='${libname}${release}${shared_ext}$major' fi shlibpath_var=LIBPATH fi ;; amigaos*) case $host_cpu in powerpc) # Since July 2007 AmigaOS4 officially supports .so libraries. # When compiling the executable, add -use-dynld -Lsobjs: to the compileline. library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' ;; m68k) library_names_spec='$libname.ixlibrary $libname.a' # Create ${libname}_ixlibrary.a entries in /sys/libs. finish_eval='for lib in `ls $libdir/*.ixlibrary 2>/dev/null`; do libname=`func_echo_all "$lib" | $SED '\''s%^.*/\([[^/]]*\)\.ixlibrary$%\1%'\''`; test $RM /sys/libs/${libname}_ixlibrary.a; $show "cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a"; cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a || exit 1; done' ;; esac ;; beos*) library_names_spec='${libname}${shared_ext}' dynamic_linker="$host_os ld.so" shlibpath_var=LIBRARY_PATH ;; bsdi[[45]]*) version_type=linux # correct to gnu/linux during the next big refactor need_version=no library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' soname_spec='${libname}${release}${shared_ext}$major' finish_cmds='PATH="\$PATH:/sbin" ldconfig $libdir' shlibpath_var=LD_LIBRARY_PATH sys_lib_search_path_spec="/shlib /usr/lib /usr/X11/lib /usr/contrib/lib /lib /usr/local/lib" sys_lib_dlsearch_path_spec="/shlib /usr/lib /usr/local/lib" # the default ld.so.conf also contains /usr/contrib/lib and # /usr/X11R6/lib (/usr/X11 is a link to /usr/X11R6), but let us allow # libtool to hard-code these into programs ;; cygwin* | mingw* | pw32* | cegcc*) version_type=windows shrext_cmds=".dll" need_version=no need_lib_prefix=no case $GCC,$cc_basename in yes,*) # gcc library_names_spec='$libname.dll.a' # DLL is installed to $(libdir)/../bin by postinstall_cmds postinstall_cmds='base_file=`basename \${file}`~ dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\${base_file}'\''i; echo \$dlname'\''`~ dldir=$destdir/`dirname \$dlpath`~ test -d \$dldir || mkdir -p \$dldir~ $install_prog $dir/$dlname \$dldir/$dlname~ chmod a+x \$dldir/$dlname~ if test -n '\''$stripme'\'' && test -n '\''$striplib'\''; then eval '\''$striplib \$dldir/$dlname'\'' || exit \$?; fi' postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; echo \$dlname'\''`~ dlpath=$dir/\$dldll~ $RM \$dlpath' shlibpath_overrides_runpath=yes case $host_os in cygwin*) # Cygwin DLLs use 'cyg' prefix rather than 'lib' soname_spec='`echo ${libname} | sed -e 's/^lib/cyg/'``echo ${release} | $SED -e 's/[[.]]/-/g'`${versuffix}${shared_ext}' m4_if([$1], [],[ sys_lib_search_path_spec="$sys_lib_search_path_spec /usr/lib/w32api"]) ;; mingw* | cegcc*) # MinGW DLLs use traditional 'lib' prefix soname_spec='${libname}`echo ${release} | $SED -e 's/[[.]]/-/g'`${versuffix}${shared_ext}' ;; pw32*) # pw32 DLLs use 'pw' prefix rather than 'lib' library_names_spec='`echo ${libname} | sed -e 's/^lib/pw/'``echo ${release} | $SED -e 's/[[.]]/-/g'`${versuffix}${shared_ext}' ;; esac dynamic_linker='Win32 ld.exe' ;; *,cl*) # Native MSVC libname_spec='$name' soname_spec='${libname}`echo ${release} | $SED -e 's/[[.]]/-/g'`${versuffix}${shared_ext}' library_names_spec='${libname}.dll.lib' case $build_os in mingw*) sys_lib_search_path_spec= lt_save_ifs=$IFS IFS=';' for lt_path in $LIB do IFS=$lt_save_ifs # Let DOS variable expansion print the short 8.3 style file name. lt_path=`cd "$lt_path" 2>/dev/null && cmd //C "for %i in (".") do @echo %~si"` sys_lib_search_path_spec="$sys_lib_search_path_spec $lt_path" done IFS=$lt_save_ifs # Convert to MSYS style. sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | sed -e 's|\\\\|/|g' -e 's| \\([[a-zA-Z]]\\):| /\\1|g' -e 's|^ ||'` ;; cygwin*) # Convert to unix form, then to dos form, then back to unix form # but this time dos style (no spaces!) so that the unix form looks # like /cygdrive/c/PROGRA~1:/cygdr... sys_lib_search_path_spec=`cygpath --path --unix "$LIB"` sys_lib_search_path_spec=`cygpath --path --dos "$sys_lib_search_path_spec" 2>/dev/null` sys_lib_search_path_spec=`cygpath --path --unix "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"` ;; *) sys_lib_search_path_spec="$LIB" if $ECHO "$sys_lib_search_path_spec" | [$GREP ';[c-zC-Z]:/' >/dev/null]; then # It is most probably a Windows format PATH. sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | $SED -e 's/;/ /g'` else sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"` fi # FIXME: find the short name or the path components, as spaces are # common. (e.g. "Program Files" -> "PROGRA~1") ;; esac # DLL is installed to $(libdir)/../bin by postinstall_cmds postinstall_cmds='base_file=`basename \${file}`~ dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\${base_file}'\''i; echo \$dlname'\''`~ dldir=$destdir/`dirname \$dlpath`~ test -d \$dldir || mkdir -p \$dldir~ $install_prog $dir/$dlname \$dldir/$dlname' postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; echo \$dlname'\''`~ dlpath=$dir/\$dldll~ $RM \$dlpath' shlibpath_overrides_runpath=yes dynamic_linker='Win32 link.exe' ;; *) # Assume MSVC wrapper library_names_spec='${libname}`echo ${release} | $SED -e 's/[[.]]/-/g'`${versuffix}${shared_ext} $libname.lib' dynamic_linker='Win32 ld.exe' ;; esac # FIXME: first we should search . and the directory the executable is in shlibpath_var=PATH ;; darwin* | rhapsody*) dynamic_linker="$host_os dyld" version_type=darwin need_lib_prefix=no need_version=no library_names_spec='${libname}${release}${major}$shared_ext ${libname}$shared_ext' soname_spec='${libname}${release}${major}$shared_ext' shlibpath_overrides_runpath=yes shlibpath_var=DYLD_LIBRARY_PATH shrext_cmds='`test .$module = .yes && echo .so || echo .dylib`' m4_if([$1], [],[ sys_lib_search_path_spec="$sys_lib_search_path_spec /usr/local/lib"]) sys_lib_dlsearch_path_spec='/usr/local/lib /lib /usr/lib' ;; dgux*) version_type=linux # correct to gnu/linux during the next big refactor need_lib_prefix=no need_version=no library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname$shared_ext' soname_spec='${libname}${release}${shared_ext}$major' shlibpath_var=LD_LIBRARY_PATH ;; freebsd* | dragonfly*) # DragonFly does not have aout. When/if they implement a new # versioning mechanism, adjust this. if test -x /usr/bin/objformat; then objformat=`/usr/bin/objformat` else case $host_os in freebsd[[23]].*) objformat=aout ;; *) objformat=elf ;; esac fi version_type=freebsd-$objformat case $version_type in freebsd-elf*) library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}' need_version=no need_lib_prefix=no ;; freebsd-*) library_names_spec='${libname}${release}${shared_ext}$versuffix $libname${shared_ext}$versuffix' need_version=yes ;; esac shlibpath_var=LD_LIBRARY_PATH case $host_os in freebsd2.*) shlibpath_overrides_runpath=yes ;; freebsd3.[[01]]* | freebsdelf3.[[01]]*) shlibpath_overrides_runpath=yes hardcode_into_libs=yes ;; freebsd3.[[2-9]]* | freebsdelf3.[[2-9]]* | \ freebsd4.[[0-5]] | freebsdelf4.[[0-5]] | freebsd4.1.1 | freebsdelf4.1.1) shlibpath_overrides_runpath=no hardcode_into_libs=yes ;; *) # from 4.6 on, and DragonFly shlibpath_overrides_runpath=yes hardcode_into_libs=yes ;; esac ;; gnu*) version_type=linux # correct to gnu/linux during the next big refactor need_lib_prefix=no need_version=no library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}${major} ${libname}${shared_ext}' soname_spec='${libname}${release}${shared_ext}$major' shlibpath_var=LD_LIBRARY_PATH shlibpath_overrides_runpath=no hardcode_into_libs=yes ;; haiku*) version_type=linux # correct to gnu/linux during the next big refactor need_lib_prefix=no need_version=no dynamic_linker="$host_os runtime_loader" library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}${major} ${libname}${shared_ext}' soname_spec='${libname}${release}${shared_ext}$major' shlibpath_var=LIBRARY_PATH shlibpath_overrides_runpath=yes sys_lib_dlsearch_path_spec='/boot/home/config/lib /boot/common/lib /boot/system/lib' hardcode_into_libs=yes ;; hpux9* | hpux10* | hpux11*) # Give a soname corresponding to the major version so that dld.sl refuses to # link against other versions. version_type=sunos need_lib_prefix=no need_version=no case $host_cpu in ia64*) shrext_cmds='.so' hardcode_into_libs=yes dynamic_linker="$host_os dld.so" shlibpath_var=LD_LIBRARY_PATH shlibpath_overrides_runpath=yes # Unless +noenvvar is specified. library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' soname_spec='${libname}${release}${shared_ext}$major' if test "X$HPUX_IA64_MODE" = X32; then sys_lib_search_path_spec="/usr/lib/hpux32 /usr/local/lib/hpux32 /usr/local/lib" else sys_lib_search_path_spec="/usr/lib/hpux64 /usr/local/lib/hpux64" fi sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec ;; hppa*64*) shrext_cmds='.sl' hardcode_into_libs=yes dynamic_linker="$host_os dld.sl" shlibpath_var=LD_LIBRARY_PATH # How should we handle SHLIB_PATH shlibpath_overrides_runpath=yes # Unless +noenvvar is specified. library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' soname_spec='${libname}${release}${shared_ext}$major' sys_lib_search_path_spec="/usr/lib/pa20_64 /usr/ccs/lib/pa20_64" sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec ;; *) shrext_cmds='.sl' dynamic_linker="$host_os dld.sl" shlibpath_var=SHLIB_PATH shlibpath_overrides_runpath=no # +s is required to enable SHLIB_PATH library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' soname_spec='${libname}${release}${shared_ext}$major' ;; esac # HP-UX runs *really* slowly unless shared libraries are mode 555, ... postinstall_cmds='chmod 555 $lib' # or fails outright, so override atomically: install_override_mode=555 ;; interix[[3-9]]*) version_type=linux # correct to gnu/linux during the next big refactor need_lib_prefix=no need_version=no library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}' soname_spec='${libname}${release}${shared_ext}$major' dynamic_linker='Interix 3.x ld.so.1 (PE, like ELF)' shlibpath_var=LD_LIBRARY_PATH shlibpath_overrides_runpath=no hardcode_into_libs=yes ;; irix5* | irix6* | nonstopux*) case $host_os in nonstopux*) version_type=nonstopux ;; *) if test "$lt_cv_prog_gnu_ld" = yes; then version_type=linux # correct to gnu/linux during the next big refactor else version_type=irix fi ;; esac need_lib_prefix=no need_version=no soname_spec='${libname}${release}${shared_ext}$major' library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext} $libname${shared_ext}' case $host_os in irix5* | nonstopux*) libsuff= shlibsuff= ;; *) case $LD in # libtool.m4 will add one of these switches to LD *-32|*"-32 "|*-melf32bsmip|*"-melf32bsmip ") libsuff= shlibsuff= libmagic=32-bit;; *-n32|*"-n32 "|*-melf32bmipn32|*"-melf32bmipn32 ") libsuff=32 shlibsuff=N32 libmagic=N32;; *-64|*"-64 "|*-melf64bmip|*"-melf64bmip ") libsuff=64 shlibsuff=64 libmagic=64-bit;; *) libsuff= shlibsuff= libmagic=never-match;; esac ;; esac shlibpath_var=LD_LIBRARY${shlibsuff}_PATH shlibpath_overrides_runpath=no sys_lib_search_path_spec="/usr/lib${libsuff} /lib${libsuff} /usr/local/lib${libsuff}" sys_lib_dlsearch_path_spec="/usr/lib${libsuff} /lib${libsuff}" hardcode_into_libs=yes ;; # No shared lib support for Linux oldld, aout, or coff. linux*oldld* | linux*aout* | linux*coff*) dynamic_linker=no ;; # This must be glibc/ELF. linux* | k*bsd*-gnu | kopensolaris*-gnu) version_type=linux # correct to gnu/linux during the next big refactor need_lib_prefix=no need_version=no library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' soname_spec='${libname}${release}${shared_ext}$major' finish_cmds='PATH="\$PATH:/sbin" ldconfig -n $libdir' shlibpath_var=LD_LIBRARY_PATH shlibpath_overrides_runpath=no # Some binutils ld are patched to set DT_RUNPATH AC_CACHE_VAL([lt_cv_shlibpath_overrides_runpath], [lt_cv_shlibpath_overrides_runpath=no save_LDFLAGS=$LDFLAGS save_libdir=$libdir eval "libdir=/foo; wl=\"$_LT_TAGVAR(lt_prog_compiler_wl, $1)\"; \ LDFLAGS=\"\$LDFLAGS $_LT_TAGVAR(hardcode_libdir_flag_spec, $1)\"" AC_LINK_IFELSE([AC_LANG_PROGRAM([],[])], [AS_IF([ ($OBJDUMP -p conftest$ac_exeext) 2>/dev/null | grep "RUNPATH.*$libdir" >/dev/null], [lt_cv_shlibpath_overrides_runpath=yes])]) LDFLAGS=$save_LDFLAGS libdir=$save_libdir ]) shlibpath_overrides_runpath=$lt_cv_shlibpath_overrides_runpath # This implies no fast_install, which is unacceptable. # Some rework will be needed to allow for fast_install # before this can be enabled. hardcode_into_libs=yes # Append ld.so.conf contents to the search path if test -f /etc/ld.so.conf; then lt_ld_extra=`awk '/^include / { system(sprintf("cd /etc; cat %s 2>/dev/null", \[$]2)); skip = 1; } { if (!skip) print \[$]0; skip = 0; }' < /etc/ld.so.conf | $SED -e 's/#.*//;/^[ ]*hwcap[ ]/d;s/[:, ]/ /g;s/=[^=]*$//;s/=[^= ]* / /g;s/"//g;/^$/d' | tr '\n' ' '` sys_lib_dlsearch_path_spec="/lib /usr/lib $lt_ld_extra" fi # We used to test for /lib/ld.so.1 and disable shared libraries on # powerpc, because MkLinux only supported shared libraries with the # GNU dynamic linker. Since this was broken with cross compilers, # most powerpc-linux boxes support dynamic linking these days and # people can always --disable-shared, the test was removed, and we # assume the GNU/Linux dynamic linker is in use. dynamic_linker='GNU/Linux ld.so' ;; netbsdelf*-gnu) version_type=linux need_lib_prefix=no need_version=no library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}' soname_spec='${libname}${release}${shared_ext}$major' shlibpath_var=LD_LIBRARY_PATH shlibpath_overrides_runpath=no hardcode_into_libs=yes dynamic_linker='NetBSD ld.elf_so' ;; netbsd*) version_type=sunos need_lib_prefix=no need_version=no if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix' finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir' dynamic_linker='NetBSD (a.out) ld.so' else library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}' soname_spec='${libname}${release}${shared_ext}$major' dynamic_linker='NetBSD ld.elf_so' fi shlibpath_var=LD_LIBRARY_PATH shlibpath_overrides_runpath=yes hardcode_into_libs=yes ;; newsos6) version_type=linux # correct to gnu/linux during the next big refactor library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' shlibpath_var=LD_LIBRARY_PATH shlibpath_overrides_runpath=yes ;; *nto* | *qnx*) version_type=qnx need_lib_prefix=no need_version=no library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' soname_spec='${libname}${release}${shared_ext}$major' shlibpath_var=LD_LIBRARY_PATH shlibpath_overrides_runpath=no hardcode_into_libs=yes dynamic_linker='ldqnx.so' ;; openbsd*) version_type=sunos sys_lib_dlsearch_path_spec="/usr/lib" need_lib_prefix=no # Some older versions of OpenBSD (3.3 at least) *do* need versioned libs. case $host_os in openbsd3.3 | openbsd3.3.*) need_version=yes ;; *) need_version=no ;; esac library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix' finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir' shlibpath_var=LD_LIBRARY_PATH if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then case $host_os in openbsd2.[[89]] | openbsd2.[[89]].*) shlibpath_overrides_runpath=no ;; *) shlibpath_overrides_runpath=yes ;; esac else shlibpath_overrides_runpath=yes fi ;; os2*) libname_spec='$name' shrext_cmds=".dll" need_lib_prefix=no library_names_spec='$libname${shared_ext} $libname.a' dynamic_linker='OS/2 ld.exe' shlibpath_var=LIBPATH ;; osf3* | osf4* | osf5*) version_type=osf need_lib_prefix=no need_version=no soname_spec='${libname}${release}${shared_ext}$major' library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' shlibpath_var=LD_LIBRARY_PATH sys_lib_search_path_spec="/usr/shlib /usr/ccs/lib /usr/lib/cmplrs/cc /usr/lib /usr/local/lib /var/shlib" sys_lib_dlsearch_path_spec="$sys_lib_search_path_spec" ;; rdos*) dynamic_linker=no ;; solaris*) version_type=linux # correct to gnu/linux during the next big refactor need_lib_prefix=no need_version=no library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' soname_spec='${libname}${release}${shared_ext}$major' shlibpath_var=LD_LIBRARY_PATH shlibpath_overrides_runpath=yes hardcode_into_libs=yes # ldd complains unless libraries are executable postinstall_cmds='chmod +x $lib' ;; sunos4*) version_type=sunos library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix' finish_cmds='PATH="\$PATH:/usr/etc" ldconfig $libdir' shlibpath_var=LD_LIBRARY_PATH shlibpath_overrides_runpath=yes if test "$with_gnu_ld" = yes; then need_lib_prefix=no fi need_version=yes ;; sysv4 | sysv4.3*) version_type=linux # correct to gnu/linux during the next big refactor library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' soname_spec='${libname}${release}${shared_ext}$major' shlibpath_var=LD_LIBRARY_PATH case $host_vendor in sni) shlibpath_overrides_runpath=no need_lib_prefix=no runpath_var=LD_RUN_PATH ;; siemens) need_lib_prefix=no ;; motorola) need_lib_prefix=no need_version=no shlibpath_overrides_runpath=no sys_lib_search_path_spec='/lib /usr/lib /usr/ccs/lib' ;; esac ;; sysv4*MP*) if test -d /usr/nec ;then version_type=linux # correct to gnu/linux during the next big refactor library_names_spec='$libname${shared_ext}.$versuffix $libname${shared_ext}.$major $libname${shared_ext}' soname_spec='$libname${shared_ext}.$major' shlibpath_var=LD_LIBRARY_PATH fi ;; sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*) version_type=freebsd-elf need_lib_prefix=no need_version=no library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}' soname_spec='${libname}${release}${shared_ext}$major' shlibpath_var=LD_LIBRARY_PATH shlibpath_overrides_runpath=yes hardcode_into_libs=yes if test "$with_gnu_ld" = yes; then sys_lib_search_path_spec='/usr/local/lib /usr/gnu/lib /usr/ccs/lib /usr/lib /lib' else sys_lib_search_path_spec='/usr/ccs/lib /usr/lib' case $host_os in sco3.2v5*) sys_lib_search_path_spec="$sys_lib_search_path_spec /lib" ;; esac fi sys_lib_dlsearch_path_spec='/usr/lib' ;; tpf*) # TPF is a cross-target only. Preferred cross-host = GNU/Linux. version_type=linux # correct to gnu/linux during the next big refactor need_lib_prefix=no need_version=no library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' shlibpath_var=LD_LIBRARY_PATH shlibpath_overrides_runpath=no hardcode_into_libs=yes ;; uts4*) version_type=linux # correct to gnu/linux during the next big refactor library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' soname_spec='${libname}${release}${shared_ext}$major' shlibpath_var=LD_LIBRARY_PATH ;; *) dynamic_linker=no ;; esac AC_MSG_RESULT([$dynamic_linker]) test "$dynamic_linker" = no && can_build_shared=no variables_saved_for_relink="PATH $shlibpath_var $runpath_var" if test "$GCC" = yes; then variables_saved_for_relink="$variables_saved_for_relink GCC_EXEC_PREFIX COMPILER_PATH LIBRARY_PATH" fi if test "${lt_cv_sys_lib_search_path_spec+set}" = set; then sys_lib_search_path_spec="$lt_cv_sys_lib_search_path_spec" fi if test "${lt_cv_sys_lib_dlsearch_path_spec+set}" = set; then sys_lib_dlsearch_path_spec="$lt_cv_sys_lib_dlsearch_path_spec" fi _LT_DECL([], [variables_saved_for_relink], [1], [Variables whose values should be saved in libtool wrapper scripts and restored at link time]) _LT_DECL([], [need_lib_prefix], [0], [Do we need the "lib" prefix for modules?]) _LT_DECL([], [need_version], [0], [Do we need a version for libraries?]) _LT_DECL([], [version_type], [0], [Library versioning type]) _LT_DECL([], [runpath_var], [0], [Shared library runtime path variable]) _LT_DECL([], [shlibpath_var], [0],[Shared library path variable]) _LT_DECL([], [shlibpath_overrides_runpath], [0], [Is shlibpath searched before the hard-coded library search path?]) _LT_DECL([], [libname_spec], [1], [Format of library name prefix]) _LT_DECL([], [library_names_spec], [1], [[List of archive names. First name is the real one, the rest are links. The last name is the one that the linker finds with -lNAME]]) _LT_DECL([], [soname_spec], [1], [[The coded name of the library, if different from the real name]]) _LT_DECL([], [install_override_mode], [1], [Permission mode override for installation of shared libraries]) _LT_DECL([], [postinstall_cmds], [2], [Command to use after installation of a shared archive]) _LT_DECL([], [postuninstall_cmds], [2], [Command to use after uninstallation of a shared archive]) _LT_DECL([], [finish_cmds], [2], [Commands used to finish a libtool library installation in a directory]) _LT_DECL([], [finish_eval], [1], [[As "finish_cmds", except a single script fragment to be evaled but not shown]]) _LT_DECL([], [hardcode_into_libs], [0], [Whether we should hardcode library paths into libraries]) _LT_DECL([], [sys_lib_search_path_spec], [2], [Compile-time system search path for libraries]) _LT_DECL([], [sys_lib_dlsearch_path_spec], [2], [Run-time system search path for libraries]) ])# _LT_SYS_DYNAMIC_LINKER # _LT_PATH_TOOL_PREFIX(TOOL) # -------------------------- # find a file program which can recognize shared library AC_DEFUN([_LT_PATH_TOOL_PREFIX], [m4_require([_LT_DECL_EGREP])dnl AC_MSG_CHECKING([for $1]) AC_CACHE_VAL(lt_cv_path_MAGIC_CMD, [case $MAGIC_CMD in [[\\/*] | ?:[\\/]*]) lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a path. ;; *) lt_save_MAGIC_CMD="$MAGIC_CMD" lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR dnl $ac_dummy forces splitting on constant user-supplied paths. dnl POSIX.2 word splitting is done only on the output of word expansions, dnl not every word. This closes a longstanding sh security hole. ac_dummy="m4_if([$2], , $PATH, [$2])" for ac_dir in $ac_dummy; do IFS="$lt_save_ifs" test -z "$ac_dir" && ac_dir=. if test -f $ac_dir/$1; then lt_cv_path_MAGIC_CMD="$ac_dir/$1" if test -n "$file_magic_test_file"; then case $deplibs_check_method in "file_magic "*) file_magic_regex=`expr "$deplibs_check_method" : "file_magic \(.*\)"` MAGIC_CMD="$lt_cv_path_MAGIC_CMD" if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null | $EGREP "$file_magic_regex" > /dev/null; then : else cat <<_LT_EOF 1>&2 *** Warning: the command libtool uses to detect shared libraries, *** $file_magic_cmd, produces output that libtool cannot recognize. *** The result is that libtool may fail to recognize shared libraries *** as such. This will affect the creation of libtool libraries that *** depend on shared libraries, but programs linked with such libtool *** libraries will work regardless of this problem. Nevertheless, you *** may want to report the problem to your system manager and/or to *** bug-libtool@gnu.org _LT_EOF fi ;; esac fi break fi done IFS="$lt_save_ifs" MAGIC_CMD="$lt_save_MAGIC_CMD" ;; esac]) MAGIC_CMD="$lt_cv_path_MAGIC_CMD" if test -n "$MAGIC_CMD"; then AC_MSG_RESULT($MAGIC_CMD) else AC_MSG_RESULT(no) fi _LT_DECL([], [MAGIC_CMD], [0], [Used to examine libraries when file_magic_cmd begins with "file"])dnl ])# _LT_PATH_TOOL_PREFIX # Old name: AU_ALIAS([AC_PATH_TOOL_PREFIX], [_LT_PATH_TOOL_PREFIX]) dnl aclocal-1.4 backwards compatibility: dnl AC_DEFUN([AC_PATH_TOOL_PREFIX], []) # _LT_PATH_MAGIC # -------------- # find a file program which can recognize a shared library m4_defun([_LT_PATH_MAGIC], [_LT_PATH_TOOL_PREFIX(${ac_tool_prefix}file, /usr/bin$PATH_SEPARATOR$PATH) if test -z "$lt_cv_path_MAGIC_CMD"; then if test -n "$ac_tool_prefix"; then _LT_PATH_TOOL_PREFIX(file, /usr/bin$PATH_SEPARATOR$PATH) else MAGIC_CMD=: fi fi ])# _LT_PATH_MAGIC # LT_PATH_LD # ---------- # find the pathname to the GNU or non-GNU linker AC_DEFUN([LT_PATH_LD], [AC_REQUIRE([AC_PROG_CC])dnl AC_REQUIRE([AC_CANONICAL_HOST])dnl AC_REQUIRE([AC_CANONICAL_BUILD])dnl m4_require([_LT_DECL_SED])dnl m4_require([_LT_DECL_EGREP])dnl m4_require([_LT_PROG_ECHO_BACKSLASH])dnl AC_ARG_WITH([gnu-ld], [AS_HELP_STRING([--with-gnu-ld], [assume the C compiler uses GNU ld @<:@default=no@:>@])], [test "$withval" = no || with_gnu_ld=yes], [with_gnu_ld=no])dnl ac_prog=ld if test "$GCC" = yes; then # Check if gcc -print-prog-name=ld gives a path. AC_MSG_CHECKING([for ld used by $CC]) case $host in *-*-mingw*) # gcc leaves a trailing carriage return which upsets mingw ac_prog=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;; *) ac_prog=`($CC -print-prog-name=ld) 2>&5` ;; esac case $ac_prog in # Accept absolute paths. [[\\/]]* | ?:[[\\/]]*) re_direlt='/[[^/]][[^/]]*/\.\./' # Canonicalize the pathname of ld ac_prog=`$ECHO "$ac_prog"| $SED 's%\\\\%/%g'` while $ECHO "$ac_prog" | $GREP "$re_direlt" > /dev/null 2>&1; do ac_prog=`$ECHO $ac_prog| $SED "s%$re_direlt%/%"` done test -z "$LD" && LD="$ac_prog" ;; "") # If it fails, then pretend we aren't using GCC. ac_prog=ld ;; *) # If it is relative, then search for the first ld in PATH. with_gnu_ld=unknown ;; esac elif test "$with_gnu_ld" = yes; then AC_MSG_CHECKING([for GNU ld]) else AC_MSG_CHECKING([for non-GNU ld]) fi AC_CACHE_VAL(lt_cv_path_LD, [if test -z "$LD"; then lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR for ac_dir in $PATH; do IFS="$lt_save_ifs" test -z "$ac_dir" && ac_dir=. if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then lt_cv_path_LD="$ac_dir/$ac_prog" # Check to see if the program is GNU ld. I'd rather use --version, # but apparently some variants of GNU ld only accept -v. # Break only if it was the GNU/non-GNU ld that we prefer. case `"$lt_cv_path_LD" -v 2>&1 &1 /dev/null 2>&1; then lt_cv_deplibs_check_method='file_magic ^x86 archive import|^x86 DLL' lt_cv_file_magic_cmd='func_win32_libid' else # Keep this pattern in sync with the one in func_win32_libid. lt_cv_deplibs_check_method='file_magic file format (pei*-i386(.*architecture: i386)?|pe-arm-wince|pe-x86-64)' lt_cv_file_magic_cmd='$OBJDUMP -f' fi ;; cegcc*) # use the weaker test based on 'objdump'. See mingw*. lt_cv_deplibs_check_method='file_magic file format pe-arm-.*little(.*architecture: arm)?' lt_cv_file_magic_cmd='$OBJDUMP -f' ;; darwin* | rhapsody*) lt_cv_deplibs_check_method=pass_all ;; freebsd* | dragonfly*) if echo __ELF__ | $CC -E - | $GREP __ELF__ > /dev/null; then case $host_cpu in i*86 ) # Not sure whether the presence of OpenBSD here was a mistake. # Let's accept both of them until this is cleared up. lt_cv_deplibs_check_method='file_magic (FreeBSD|OpenBSD|DragonFly)/i[[3-9]]86 (compact )?demand paged shared library' lt_cv_file_magic_cmd=/usr/bin/file lt_cv_file_magic_test_file=`echo /usr/lib/libc.so.*` ;; esac else lt_cv_deplibs_check_method=pass_all fi ;; gnu*) lt_cv_deplibs_check_method=pass_all ;; haiku*) lt_cv_deplibs_check_method=pass_all ;; hpux10.20* | hpux11*) lt_cv_file_magic_cmd=/usr/bin/file case $host_cpu in ia64*) lt_cv_deplibs_check_method='file_magic (s[[0-9]][[0-9]][[0-9]]|ELF-[[0-9]][[0-9]]) shared object file - IA64' lt_cv_file_magic_test_file=/usr/lib/hpux32/libc.so ;; hppa*64*) [lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|ELF[ -][0-9][0-9])(-bit)?( [LM]SB)? shared object( file)?[, -]* PA-RISC [0-9]\.[0-9]'] lt_cv_file_magic_test_file=/usr/lib/pa20_64/libc.sl ;; *) lt_cv_deplibs_check_method='file_magic (s[[0-9]][[0-9]][[0-9]]|PA-RISC[[0-9]]\.[[0-9]]) shared library' lt_cv_file_magic_test_file=/usr/lib/libc.sl ;; esac ;; interix[[3-9]]*) # PIC code is broken on Interix 3.x, that's why |\.a not |_pic\.a here lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so|\.a)$' ;; irix5* | irix6* | nonstopux*) case $LD in *-32|*"-32 ") libmagic=32-bit;; *-n32|*"-n32 ") libmagic=N32;; *-64|*"-64 ") libmagic=64-bit;; *) libmagic=never-match;; esac lt_cv_deplibs_check_method=pass_all ;; # This must be glibc/ELF. linux* | k*bsd*-gnu | kopensolaris*-gnu) lt_cv_deplibs_check_method=pass_all ;; netbsd* | netbsdelf*-gnu) if echo __ELF__ | $CC -E - | $GREP __ELF__ > /dev/null; then lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so\.[[0-9]]+\.[[0-9]]+|_pic\.a)$' else lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so|_pic\.a)$' fi ;; newos6*) lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[ML]]SB (executable|dynamic lib)' lt_cv_file_magic_cmd=/usr/bin/file lt_cv_file_magic_test_file=/usr/lib/libnls.so ;; *nto* | *qnx*) lt_cv_deplibs_check_method=pass_all ;; openbsd*) if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so\.[[0-9]]+\.[[0-9]]+|\.so|_pic\.a)$' else lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so\.[[0-9]]+\.[[0-9]]+|_pic\.a)$' fi ;; osf3* | osf4* | osf5*) lt_cv_deplibs_check_method=pass_all ;; rdos*) lt_cv_deplibs_check_method=pass_all ;; solaris*) lt_cv_deplibs_check_method=pass_all ;; sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*) lt_cv_deplibs_check_method=pass_all ;; sysv4 | sysv4.3*) case $host_vendor in motorola) lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[ML]]SB (shared object|dynamic lib) M[[0-9]][[0-9]]* Version [[0-9]]' lt_cv_file_magic_test_file=`echo /usr/lib/libc.so*` ;; ncr) lt_cv_deplibs_check_method=pass_all ;; sequent) lt_cv_file_magic_cmd='/bin/file' lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[LM]]SB (shared object|dynamic lib )' ;; sni) lt_cv_file_magic_cmd='/bin/file' lt_cv_deplibs_check_method="file_magic ELF [[0-9]][[0-9]]*-bit [[LM]]SB dynamic lib" lt_cv_file_magic_test_file=/lib/libc.so ;; siemens) lt_cv_deplibs_check_method=pass_all ;; pc) lt_cv_deplibs_check_method=pass_all ;; esac ;; tpf*) lt_cv_deplibs_check_method=pass_all ;; esac ]) file_magic_glob= want_nocaseglob=no if test "$build" = "$host"; then case $host_os in mingw* | pw32*) if ( shopt | grep nocaseglob ) >/dev/null 2>&1; then want_nocaseglob=yes else file_magic_glob=`echo aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ | $SED -e "s/\(..\)/s\/[[\1]]\/[[\1]]\/g;/g"` fi ;; esac fi file_magic_cmd=$lt_cv_file_magic_cmd deplibs_check_method=$lt_cv_deplibs_check_method test -z "$deplibs_check_method" && deplibs_check_method=unknown _LT_DECL([], [deplibs_check_method], [1], [Method to check whether dependent libraries are shared objects]) _LT_DECL([], [file_magic_cmd], [1], [Command to use when deplibs_check_method = "file_magic"]) _LT_DECL([], [file_magic_glob], [1], [How to find potential files when deplibs_check_method = "file_magic"]) _LT_DECL([], [want_nocaseglob], [1], [Find potential files using nocaseglob when deplibs_check_method = "file_magic"]) ])# _LT_CHECK_MAGIC_METHOD # LT_PATH_NM # ---------- # find the pathname to a BSD- or MS-compatible name lister AC_DEFUN([LT_PATH_NM], [AC_REQUIRE([AC_PROG_CC])dnl AC_CACHE_CHECK([for BSD- or MS-compatible name lister (nm)], lt_cv_path_NM, [if test -n "$NM"; then # Let the user override the test. lt_cv_path_NM="$NM" else lt_nm_to_check="${ac_tool_prefix}nm" if test -n "$ac_tool_prefix" && test "$build" = "$host"; then lt_nm_to_check="$lt_nm_to_check nm" fi for lt_tmp_nm in $lt_nm_to_check; do lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR for ac_dir in $PATH /usr/ccs/bin/elf /usr/ccs/bin /usr/ucb /bin; do IFS="$lt_save_ifs" test -z "$ac_dir" && ac_dir=. tmp_nm="$ac_dir/$lt_tmp_nm" if test -f "$tmp_nm" || test -f "$tmp_nm$ac_exeext" ; then # Check to see if the nm accepts a BSD-compat flag. # Adding the `sed 1q' prevents false positives on HP-UX, which says: # nm: unknown option "B" ignored # Tru64's nm complains that /dev/null is an invalid object file case `"$tmp_nm" -B /dev/null 2>&1 | sed '1q'` in */dev/null* | *'Invalid file or object type'*) lt_cv_path_NM="$tmp_nm -B" break ;; *) case `"$tmp_nm" -p /dev/null 2>&1 | sed '1q'` in */dev/null*) lt_cv_path_NM="$tmp_nm -p" break ;; *) lt_cv_path_NM=${lt_cv_path_NM="$tmp_nm"} # keep the first match, but continue # so that we can try to find one that supports BSD flags ;; esac ;; esac fi done IFS="$lt_save_ifs" done : ${lt_cv_path_NM=no} fi]) if test "$lt_cv_path_NM" != "no"; then NM="$lt_cv_path_NM" else # Didn't find any BSD compatible name lister, look for dumpbin. if test -n "$DUMPBIN"; then : # Let the user override the test. else AC_CHECK_TOOLS(DUMPBIN, [dumpbin "link -dump"], :) case `$DUMPBIN -symbols /dev/null 2>&1 | sed '1q'` in *COFF*) DUMPBIN="$DUMPBIN -symbols" ;; *) DUMPBIN=: ;; esac fi AC_SUBST([DUMPBIN]) if test "$DUMPBIN" != ":"; then NM="$DUMPBIN" fi fi test -z "$NM" && NM=nm AC_SUBST([NM]) _LT_DECL([], [NM], [1], [A BSD- or MS-compatible name lister])dnl AC_CACHE_CHECK([the name lister ($NM) interface], [lt_cv_nm_interface], [lt_cv_nm_interface="BSD nm" echo "int some_variable = 0;" > conftest.$ac_ext (eval echo "\"\$as_me:$LINENO: $ac_compile\"" >&AS_MESSAGE_LOG_FD) (eval "$ac_compile" 2>conftest.err) cat conftest.err >&AS_MESSAGE_LOG_FD (eval echo "\"\$as_me:$LINENO: $NM \\\"conftest.$ac_objext\\\"\"" >&AS_MESSAGE_LOG_FD) (eval "$NM \"conftest.$ac_objext\"" 2>conftest.err > conftest.out) cat conftest.err >&AS_MESSAGE_LOG_FD (eval echo "\"\$as_me:$LINENO: output\"" >&AS_MESSAGE_LOG_FD) cat conftest.out >&AS_MESSAGE_LOG_FD if $GREP 'External.*some_variable' conftest.out > /dev/null; then lt_cv_nm_interface="MS dumpbin" fi rm -f conftest*]) ])# LT_PATH_NM # Old names: AU_ALIAS([AM_PROG_NM], [LT_PATH_NM]) AU_ALIAS([AC_PROG_NM], [LT_PATH_NM]) dnl aclocal-1.4 backwards compatibility: dnl AC_DEFUN([AM_PROG_NM], []) dnl AC_DEFUN([AC_PROG_NM], []) # _LT_CHECK_SHAREDLIB_FROM_LINKLIB # -------------------------------- # how to determine the name of the shared library # associated with a specific link library. # -- PORTME fill in with the dynamic library characteristics m4_defun([_LT_CHECK_SHAREDLIB_FROM_LINKLIB], [m4_require([_LT_DECL_EGREP]) m4_require([_LT_DECL_OBJDUMP]) m4_require([_LT_DECL_DLLTOOL]) AC_CACHE_CHECK([how to associate runtime and link libraries], lt_cv_sharedlib_from_linklib_cmd, [lt_cv_sharedlib_from_linklib_cmd='unknown' case $host_os in cygwin* | mingw* | pw32* | cegcc*) # two different shell functions defined in ltmain.sh # decide which to use based on capabilities of $DLLTOOL case `$DLLTOOL --help 2>&1` in *--identify-strict*) lt_cv_sharedlib_from_linklib_cmd=func_cygming_dll_for_implib ;; *) lt_cv_sharedlib_from_linklib_cmd=func_cygming_dll_for_implib_fallback ;; esac ;; *) # fallback: assume linklib IS sharedlib lt_cv_sharedlib_from_linklib_cmd="$ECHO" ;; esac ]) sharedlib_from_linklib_cmd=$lt_cv_sharedlib_from_linklib_cmd test -z "$sharedlib_from_linklib_cmd" && sharedlib_from_linklib_cmd=$ECHO _LT_DECL([], [sharedlib_from_linklib_cmd], [1], [Command to associate shared and link libraries]) ])# _LT_CHECK_SHAREDLIB_FROM_LINKLIB # _LT_PATH_MANIFEST_TOOL # ---------------------- # locate the manifest tool m4_defun([_LT_PATH_MANIFEST_TOOL], [AC_CHECK_TOOL(MANIFEST_TOOL, mt, :) test -z "$MANIFEST_TOOL" && MANIFEST_TOOL=mt AC_CACHE_CHECK([if $MANIFEST_TOOL is a manifest tool], [lt_cv_path_mainfest_tool], [lt_cv_path_mainfest_tool=no echo "$as_me:$LINENO: $MANIFEST_TOOL '-?'" >&AS_MESSAGE_LOG_FD $MANIFEST_TOOL '-?' 2>conftest.err > conftest.out cat conftest.err >&AS_MESSAGE_LOG_FD if $GREP 'Manifest Tool' conftest.out > /dev/null; then lt_cv_path_mainfest_tool=yes fi rm -f conftest*]) if test "x$lt_cv_path_mainfest_tool" != xyes; then MANIFEST_TOOL=: fi _LT_DECL([], [MANIFEST_TOOL], [1], [Manifest tool])dnl ])# _LT_PATH_MANIFEST_TOOL # LT_LIB_M # -------- # check for math library AC_DEFUN([LT_LIB_M], [AC_REQUIRE([AC_CANONICAL_HOST])dnl LIBM= case $host in *-*-beos* | *-*-cegcc* | *-*-cygwin* | *-*-haiku* | *-*-pw32* | *-*-darwin*) # These system don't have libm, or don't need it ;; *-ncr-sysv4.3*) AC_CHECK_LIB(mw, _mwvalidcheckl, LIBM="-lmw") AC_CHECK_LIB(m, cos, LIBM="$LIBM -lm") ;; *) AC_CHECK_LIB(m, cos, LIBM="-lm") ;; esac AC_SUBST([LIBM]) ])# LT_LIB_M # Old name: AU_ALIAS([AC_CHECK_LIBM], [LT_LIB_M]) dnl aclocal-1.4 backwards compatibility: dnl AC_DEFUN([AC_CHECK_LIBM], []) # _LT_COMPILER_NO_RTTI([TAGNAME]) # ------------------------------- m4_defun([_LT_COMPILER_NO_RTTI], [m4_require([_LT_TAG_COMPILER])dnl _LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)= if test "$GCC" = yes; then case $cc_basename in nvcc*) _LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)=' -Xcompiler -fno-builtin' ;; *) _LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)=' -fno-builtin' ;; esac _LT_COMPILER_OPTION([if $compiler supports -fno-rtti -fno-exceptions], lt_cv_prog_compiler_rtti_exceptions, [-fno-rtti -fno-exceptions], [], [_LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)="$_LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1) -fno-rtti -fno-exceptions"]) fi _LT_TAGDECL([no_builtin_flag], [lt_prog_compiler_no_builtin_flag], [1], [Compiler flag to turn off builtin functions]) ])# _LT_COMPILER_NO_RTTI # _LT_CMD_GLOBAL_SYMBOLS # ---------------------- m4_defun([_LT_CMD_GLOBAL_SYMBOLS], [AC_REQUIRE([AC_CANONICAL_HOST])dnl AC_REQUIRE([AC_PROG_CC])dnl AC_REQUIRE([AC_PROG_AWK])dnl AC_REQUIRE([LT_PATH_NM])dnl AC_REQUIRE([LT_PATH_LD])dnl m4_require([_LT_DECL_SED])dnl m4_require([_LT_DECL_EGREP])dnl m4_require([_LT_TAG_COMPILER])dnl # Check for command to grab the raw symbol name followed by C symbol from nm. AC_MSG_CHECKING([command to parse $NM output from $compiler object]) AC_CACHE_VAL([lt_cv_sys_global_symbol_pipe], [ # These are sane defaults that work on at least a few old systems. # [They come from Ultrix. What could be older than Ultrix?!! ;)] # Character class describing NM global symbol codes. symcode='[[BCDEGRST]]' # Regexp to match symbols that can be accessed directly from C. sympat='\([[_A-Za-z]][[_A-Za-z0-9]]*\)' # Define system-specific variables. case $host_os in aix*) symcode='[[BCDT]]' ;; cygwin* | mingw* | pw32* | cegcc*) symcode='[[ABCDGISTW]]' ;; hpux*) if test "$host_cpu" = ia64; then symcode='[[ABCDEGRST]]' fi ;; irix* | nonstopux*) symcode='[[BCDEGRST]]' ;; osf*) symcode='[[BCDEGQRST]]' ;; solaris*) symcode='[[BDRT]]' ;; sco3.2v5*) symcode='[[DT]]' ;; sysv4.2uw2*) symcode='[[DT]]' ;; sysv5* | sco5v6* | unixware* | OpenUNIX*) symcode='[[ABDT]]' ;; sysv4) symcode='[[DFNSTU]]' ;; esac # If we're using GNU nm, then use its standard symbol codes. case `$NM -V 2>&1` in *GNU* | *'with BFD'*) symcode='[[ABCDGIRSTW]]' ;; esac # Transform an extracted symbol line into a proper C declaration. # Some systems (esp. on ia64) link data and code symbols differently, # so use this general approach. lt_cv_sys_global_symbol_to_cdecl="sed -n -e 's/^T .* \(.*\)$/extern int \1();/p' -e 's/^$symcode* .* \(.*\)$/extern char \1;/p'" # Transform an extracted symbol line into symbol name and symbol address lt_cv_sys_global_symbol_to_c_name_address="sed -n -e 's/^: \([[^ ]]*\)[[ ]]*$/ {\\\"\1\\\", (void *) 0},/p' -e 's/^$symcode* \([[^ ]]*\) \([[^ ]]*\)$/ {\"\2\", (void *) \&\2},/p'" lt_cv_sys_global_symbol_to_c_name_address_lib_prefix="sed -n -e 's/^: \([[^ ]]*\)[[ ]]*$/ {\\\"\1\\\", (void *) 0},/p' -e 's/^$symcode* \([[^ ]]*\) \(lib[[^ ]]*\)$/ {\"\2\", (void *) \&\2},/p' -e 's/^$symcode* \([[^ ]]*\) \([[^ ]]*\)$/ {\"lib\2\", (void *) \&\2},/p'" # Handle CRLF in mingw tool chain opt_cr= case $build_os in mingw*) opt_cr=`$ECHO 'x\{0,1\}' | tr x '\015'` # option cr in regexp ;; esac # Try without a prefix underscore, then with it. for ac_symprfx in "" "_"; do # Transform symcode, sympat, and symprfx into a raw symbol and a C symbol. symxfrm="\\1 $ac_symprfx\\2 \\2" # Write the raw and C identifiers. if test "$lt_cv_nm_interface" = "MS dumpbin"; then # Fake it for dumpbin and say T for any non-static function # and D for any global variable. # Also find C++ and __fastcall symbols from MSVC++, # which start with @ or ?. lt_cv_sys_global_symbol_pipe="$AWK ['"\ " {last_section=section; section=\$ 3};"\ " /^COFF SYMBOL TABLE/{for(i in hide) delete hide[i]};"\ " /Section length .*#relocs.*(pick any)/{hide[last_section]=1};"\ " \$ 0!~/External *\|/{next};"\ " / 0+ UNDEF /{next}; / UNDEF \([^|]\)*()/{next};"\ " {if(hide[section]) next};"\ " {f=0}; \$ 0~/\(\).*\|/{f=1}; {printf f ? \"T \" : \"D \"};"\ " {split(\$ 0, a, /\||\r/); split(a[2], s)};"\ " s[1]~/^[@?]/{print s[1], s[1]; next};"\ " s[1]~prfx {split(s[1],t,\"@\"); print t[1], substr(t[1],length(prfx))}"\ " ' prfx=^$ac_symprfx]" else lt_cv_sys_global_symbol_pipe="sed -n -e 's/^.*[[ ]]\($symcode$symcode*\)[[ ]][[ ]]*$ac_symprfx$sympat$opt_cr$/$symxfrm/p'" fi lt_cv_sys_global_symbol_pipe="$lt_cv_sys_global_symbol_pipe | sed '/ __gnu_lto/d'" # Check to see that the pipe works correctly. pipe_works=no rm -f conftest* cat > conftest.$ac_ext <<_LT_EOF #ifdef __cplusplus extern "C" { #endif char nm_test_var; void nm_test_func(void); void nm_test_func(void){} #ifdef __cplusplus } #endif int main(){nm_test_var='a';nm_test_func();return(0);} _LT_EOF if AC_TRY_EVAL(ac_compile); then # Now try to grab the symbols. nlist=conftest.nm if AC_TRY_EVAL(NM conftest.$ac_objext \| "$lt_cv_sys_global_symbol_pipe" \> $nlist) && test -s "$nlist"; then # Try sorting and uniquifying the output. if sort "$nlist" | uniq > "$nlist"T; then mv -f "$nlist"T "$nlist" else rm -f "$nlist"T fi # Make sure that we snagged all the symbols we need. if $GREP ' nm_test_var$' "$nlist" >/dev/null; then if $GREP ' nm_test_func$' "$nlist" >/dev/null; then cat <<_LT_EOF > conftest.$ac_ext /* Keep this code in sync between libtool.m4, ltmain, lt_system.h, and tests. */ #if defined(_WIN32) || defined(__CYGWIN__) || defined(_WIN32_WCE) /* DATA imports from DLLs on WIN32 con't be const, because runtime relocations are performed -- see ld's documentation on pseudo-relocs. */ # define LT@&t@_DLSYM_CONST #elif defined(__osf__) /* This system does not cope well with relocations in const data. */ # define LT@&t@_DLSYM_CONST #else # define LT@&t@_DLSYM_CONST const #endif #ifdef __cplusplus extern "C" { #endif _LT_EOF # Now generate the symbol file. eval "$lt_cv_sys_global_symbol_to_cdecl"' < "$nlist" | $GREP -v main >> conftest.$ac_ext' cat <<_LT_EOF >> conftest.$ac_ext /* The mapping between symbol names and symbols. */ LT@&t@_DLSYM_CONST struct { const char *name; void *address; } lt__PROGRAM__LTX_preloaded_symbols[[]] = { { "@PROGRAM@", (void *) 0 }, _LT_EOF $SED "s/^$symcode$symcode* \(.*\) \(.*\)$/ {\"\2\", (void *) \&\2},/" < "$nlist" | $GREP -v main >> conftest.$ac_ext cat <<\_LT_EOF >> conftest.$ac_ext {0, (void *) 0} }; /* This works around a problem in FreeBSD linker */ #ifdef FREEBSD_WORKAROUND static const void *lt_preloaded_setup() { return lt__PROGRAM__LTX_preloaded_symbols; } #endif #ifdef __cplusplus } #endif _LT_EOF # Now try linking the two files. mv conftest.$ac_objext conftstm.$ac_objext lt_globsym_save_LIBS=$LIBS lt_globsym_save_CFLAGS=$CFLAGS LIBS="conftstm.$ac_objext" CFLAGS="$CFLAGS$_LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)" if AC_TRY_EVAL(ac_link) && test -s conftest${ac_exeext}; then pipe_works=yes fi LIBS=$lt_globsym_save_LIBS CFLAGS=$lt_globsym_save_CFLAGS else echo "cannot find nm_test_func in $nlist" >&AS_MESSAGE_LOG_FD fi else echo "cannot find nm_test_var in $nlist" >&AS_MESSAGE_LOG_FD fi else echo "cannot run $lt_cv_sys_global_symbol_pipe" >&AS_MESSAGE_LOG_FD fi else echo "$progname: failed program was:" >&AS_MESSAGE_LOG_FD cat conftest.$ac_ext >&5 fi rm -rf conftest* conftst* # Do not use the global_symbol_pipe unless it works. if test "$pipe_works" = yes; then break else lt_cv_sys_global_symbol_pipe= fi done ]) if test -z "$lt_cv_sys_global_symbol_pipe"; then lt_cv_sys_global_symbol_to_cdecl= fi if test -z "$lt_cv_sys_global_symbol_pipe$lt_cv_sys_global_symbol_to_cdecl"; then AC_MSG_RESULT(failed) else AC_MSG_RESULT(ok) fi # Response file support. if test "$lt_cv_nm_interface" = "MS dumpbin"; then nm_file_list_spec='@' elif $NM --help 2>/dev/null | grep '[[@]]FILE' >/dev/null; then nm_file_list_spec='@' fi _LT_DECL([global_symbol_pipe], [lt_cv_sys_global_symbol_pipe], [1], [Take the output of nm and produce a listing of raw symbols and C names]) _LT_DECL([global_symbol_to_cdecl], [lt_cv_sys_global_symbol_to_cdecl], [1], [Transform the output of nm in a proper C declaration]) _LT_DECL([global_symbol_to_c_name_address], [lt_cv_sys_global_symbol_to_c_name_address], [1], [Transform the output of nm in a C name address pair]) _LT_DECL([global_symbol_to_c_name_address_lib_prefix], [lt_cv_sys_global_symbol_to_c_name_address_lib_prefix], [1], [Transform the output of nm in a C name address pair when lib prefix is needed]) _LT_DECL([], [nm_file_list_spec], [1], [Specify filename containing input files for $NM]) ]) # _LT_CMD_GLOBAL_SYMBOLS # _LT_COMPILER_PIC([TAGNAME]) # --------------------------- m4_defun([_LT_COMPILER_PIC], [m4_require([_LT_TAG_COMPILER])dnl _LT_TAGVAR(lt_prog_compiler_wl, $1)= _LT_TAGVAR(lt_prog_compiler_pic, $1)= _LT_TAGVAR(lt_prog_compiler_static, $1)= m4_if([$1], [CXX], [ # C++ specific cases for pic, static, wl, etc. if test "$GXX" = yes; then _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' _LT_TAGVAR(lt_prog_compiler_static, $1)='-static' case $host_os in aix*) # All AIX code is PIC. if test "$host_cpu" = ia64; then # AIX 5 now supports IA64 processor _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' fi ;; amigaos*) case $host_cpu in powerpc) # see comment about AmigaOS4 .so support _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC' ;; m68k) # FIXME: we need at least 68020 code to build shared libraries, but # adding the `-m68020' flag to GCC prevents building anything better, # like `-m68040'. _LT_TAGVAR(lt_prog_compiler_pic, $1)='-m68020 -resident32 -malways-restore-a4' ;; esac ;; beos* | irix5* | irix6* | nonstopux* | osf3* | osf4* | osf5*) # PIC is the default for these OSes. ;; mingw* | cygwin* | os2* | pw32* | cegcc*) # This hack is so that the source file can tell whether it is being # built for inclusion in a dll (and should export symbols for example). # Although the cygwin gcc ignores -fPIC, still need this for old-style # (--disable-auto-import) libraries m4_if([$1], [GCJ], [], [_LT_TAGVAR(lt_prog_compiler_pic, $1)='-DDLL_EXPORT']) ;; darwin* | rhapsody*) # PIC is the default on this platform # Common symbols not allowed in MH_DYLIB files _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fno-common' ;; *djgpp*) # DJGPP does not support shared libraries at all _LT_TAGVAR(lt_prog_compiler_pic, $1)= ;; haiku*) # PIC is the default for Haiku. # The "-static" flag exists, but is broken. _LT_TAGVAR(lt_prog_compiler_static, $1)= ;; interix[[3-9]]*) # Interix 3.x gcc -fpic/-fPIC options generate broken code. # Instead, we relocate shared libraries at runtime. ;; sysv4*MP*) if test -d /usr/nec; then _LT_TAGVAR(lt_prog_compiler_pic, $1)=-Kconform_pic fi ;; hpux*) # PIC is the default for 64-bit PA HP-UX, but not for 32-bit # PA HP-UX. On IA64 HP-UX, PIC is the default but the pic flag # sets the default TLS model and affects inlining. case $host_cpu in hppa*64*) ;; *) _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC' ;; esac ;; *qnx* | *nto*) # QNX uses GNU C++, but need to define -shared option too, otherwise # it will coredump. _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC -shared' ;; *) _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC' ;; esac else case $host_os in aix[[4-9]]*) # All AIX code is PIC. if test "$host_cpu" = ia64; then # AIX 5 now supports IA64 processor _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' else _LT_TAGVAR(lt_prog_compiler_static, $1)='-bnso -bI:/lib/syscalls.exp' fi ;; chorus*) case $cc_basename in cxch68*) # Green Hills C++ Compiler # _LT_TAGVAR(lt_prog_compiler_static, $1)="--no_auto_instantiation -u __main -u __premain -u _abort -r $COOL_DIR/lib/libOrb.a $MVME_DIR/lib/CC/libC.a $MVME_DIR/lib/classix/libcx.s.a" ;; esac ;; mingw* | cygwin* | os2* | pw32* | cegcc*) # This hack is so that the source file can tell whether it is being # built for inclusion in a dll (and should export symbols for example). m4_if([$1], [GCJ], [], [_LT_TAGVAR(lt_prog_compiler_pic, $1)='-DDLL_EXPORT']) ;; dgux*) case $cc_basename in ec++*) _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' ;; ghcx*) # Green Hills C++ Compiler _LT_TAGVAR(lt_prog_compiler_pic, $1)='-pic' ;; *) ;; esac ;; freebsd* | dragonfly*) # FreeBSD uses GNU C++ ;; hpux9* | hpux10* | hpux11*) case $cc_basename in CC*) _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' _LT_TAGVAR(lt_prog_compiler_static, $1)='${wl}-a ${wl}archive' if test "$host_cpu" != ia64; then _LT_TAGVAR(lt_prog_compiler_pic, $1)='+Z' fi ;; aCC*) _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' _LT_TAGVAR(lt_prog_compiler_static, $1)='${wl}-a ${wl}archive' case $host_cpu in hppa*64*|ia64*) # +Z the default ;; *) _LT_TAGVAR(lt_prog_compiler_pic, $1)='+Z' ;; esac ;; *) ;; esac ;; interix*) # This is c89, which is MS Visual C++ (no shared libs) # Anyone wants to do a port? ;; irix5* | irix6* | nonstopux*) case $cc_basename in CC*) _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' _LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared' # CC pic flag -KPIC is the default. ;; *) ;; esac ;; linux* | k*bsd*-gnu | kopensolaris*-gnu) case $cc_basename in KCC*) # KAI C++ Compiler _LT_TAGVAR(lt_prog_compiler_wl, $1)='--backend -Wl,' _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC' ;; ecpc* ) # old Intel C++ for x86_64 which still supported -KPIC. _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' _LT_TAGVAR(lt_prog_compiler_static, $1)='-static' ;; icpc* ) # Intel C++, used to be incompatible with GCC. # ICC 10 doesn't accept -KPIC any more. _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC' _LT_TAGVAR(lt_prog_compiler_static, $1)='-static' ;; pgCC* | pgcpp*) # Portland Group C++ compiler _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fpic' _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' ;; cxx*) # Compaq C++ # Make sure the PIC flag is empty. It appears that all Alpha # Linux and Compaq Tru64 Unix objects are PIC. _LT_TAGVAR(lt_prog_compiler_pic, $1)= _LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared' ;; xlc* | xlC* | bgxl[[cC]]* | mpixl[[cC]]*) # IBM XL 8.0, 9.0 on PPC and BlueGene _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' _LT_TAGVAR(lt_prog_compiler_pic, $1)='-qpic' _LT_TAGVAR(lt_prog_compiler_static, $1)='-qstaticlink' ;; *) case `$CC -V 2>&1 | sed 5q` in *Sun\ C*) # Sun C++ 5.9 _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Qoption ld ' ;; esac ;; esac ;; lynxos*) ;; m88k*) ;; mvs*) case $cc_basename in cxx*) _LT_TAGVAR(lt_prog_compiler_pic, $1)='-W c,exportall' ;; *) ;; esac ;; netbsd* | netbsdelf*-gnu) ;; *qnx* | *nto*) # QNX uses GNU C++, but need to define -shared option too, otherwise # it will coredump. _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC -shared' ;; osf3* | osf4* | osf5*) case $cc_basename in KCC*) _LT_TAGVAR(lt_prog_compiler_wl, $1)='--backend -Wl,' ;; RCC*) # Rational C++ 2.4.1 _LT_TAGVAR(lt_prog_compiler_pic, $1)='-pic' ;; cxx*) # Digital/Compaq C++ _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' # Make sure the PIC flag is empty. It appears that all Alpha # Linux and Compaq Tru64 Unix objects are PIC. _LT_TAGVAR(lt_prog_compiler_pic, $1)= _LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared' ;; *) ;; esac ;; psos*) ;; solaris*) case $cc_basename in CC* | sunCC*) # Sun C++ 4.2, 5.x and Centerline C++ _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Qoption ld ' ;; gcx*) # Green Hills C++ Compiler _LT_TAGVAR(lt_prog_compiler_pic, $1)='-PIC' ;; *) ;; esac ;; sunos4*) case $cc_basename in CC*) # Sun C++ 4.x _LT_TAGVAR(lt_prog_compiler_pic, $1)='-pic' _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' ;; lcc*) # Lucid _LT_TAGVAR(lt_prog_compiler_pic, $1)='-pic' ;; *) ;; esac ;; sysv5* | unixware* | sco3.2v5* | sco5v6* | OpenUNIX*) case $cc_basename in CC*) _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' ;; esac ;; tandem*) case $cc_basename in NCC*) # NonStop-UX NCC 3.20 _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' ;; *) ;; esac ;; vxworks*) ;; *) _LT_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no ;; esac fi ], [ if test "$GCC" = yes; then _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' _LT_TAGVAR(lt_prog_compiler_static, $1)='-static' case $host_os in aix*) # All AIX code is PIC. if test "$host_cpu" = ia64; then # AIX 5 now supports IA64 processor _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' fi ;; amigaos*) case $host_cpu in powerpc) # see comment about AmigaOS4 .so support _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC' ;; m68k) # FIXME: we need at least 68020 code to build shared libraries, but # adding the `-m68020' flag to GCC prevents building anything better, # like `-m68040'. _LT_TAGVAR(lt_prog_compiler_pic, $1)='-m68020 -resident32 -malways-restore-a4' ;; esac ;; beos* | irix5* | irix6* | nonstopux* | osf3* | osf4* | osf5*) # PIC is the default for these OSes. ;; mingw* | cygwin* | pw32* | os2* | cegcc*) # This hack is so that the source file can tell whether it is being # built for inclusion in a dll (and should export symbols for example). # Although the cygwin gcc ignores -fPIC, still need this for old-style # (--disable-auto-import) libraries m4_if([$1], [GCJ], [], [_LT_TAGVAR(lt_prog_compiler_pic, $1)='-DDLL_EXPORT']) ;; darwin* | rhapsody*) # PIC is the default on this platform # Common symbols not allowed in MH_DYLIB files _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fno-common' ;; haiku*) # PIC is the default for Haiku. # The "-static" flag exists, but is broken. _LT_TAGVAR(lt_prog_compiler_static, $1)= ;; hpux*) # PIC is the default for 64-bit PA HP-UX, but not for 32-bit # PA HP-UX. On IA64 HP-UX, PIC is the default but the pic flag # sets the default TLS model and affects inlining. case $host_cpu in hppa*64*) # +Z the default ;; *) _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC' ;; esac ;; interix[[3-9]]*) # Interix 3.x gcc -fpic/-fPIC options generate broken code. # Instead, we relocate shared libraries at runtime. ;; msdosdjgpp*) # Just because we use GCC doesn't mean we suddenly get shared libraries # on systems that don't support them. _LT_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no enable_shared=no ;; *nto* | *qnx*) # QNX uses GNU C++, but need to define -shared option too, otherwise # it will coredump. _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC -shared' ;; sysv4*MP*) if test -d /usr/nec; then _LT_TAGVAR(lt_prog_compiler_pic, $1)=-Kconform_pic fi ;; *) _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC' ;; esac case $cc_basename in nvcc*) # Cuda Compiler Driver 2.2 _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Xlinker ' if test -n "$_LT_TAGVAR(lt_prog_compiler_pic, $1)"; then _LT_TAGVAR(lt_prog_compiler_pic, $1)="-Xcompiler $_LT_TAGVAR(lt_prog_compiler_pic, $1)" fi ;; esac else # PORTME Check for flag to pass linker flags through the system compiler. case $host_os in aix*) _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' if test "$host_cpu" = ia64; then # AIX 5 now supports IA64 processor _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' else _LT_TAGVAR(lt_prog_compiler_static, $1)='-bnso -bI:/lib/syscalls.exp' fi ;; mingw* | cygwin* | pw32* | os2* | cegcc*) # This hack is so that the source file can tell whether it is being # built for inclusion in a dll (and should export symbols for example). m4_if([$1], [GCJ], [], [_LT_TAGVAR(lt_prog_compiler_pic, $1)='-DDLL_EXPORT']) ;; hpux9* | hpux10* | hpux11*) _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' # PIC is the default for IA64 HP-UX and 64-bit HP-UX, but # not for PA HP-UX. case $host_cpu in hppa*64*|ia64*) # +Z the default ;; *) _LT_TAGVAR(lt_prog_compiler_pic, $1)='+Z' ;; esac # Is there a better lt_prog_compiler_static that works with the bundled CC? _LT_TAGVAR(lt_prog_compiler_static, $1)='${wl}-a ${wl}archive' ;; irix5* | irix6* | nonstopux*) _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' # PIC (with -KPIC) is the default. _LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared' ;; linux* | k*bsd*-gnu | kopensolaris*-gnu) case $cc_basename in # old Intel for x86_64 which still supported -KPIC. ecc*) _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' _LT_TAGVAR(lt_prog_compiler_static, $1)='-static' ;; # icc used to be incompatible with GCC. # ICC 10 doesn't accept -KPIC any more. icc* | ifort*) _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC' _LT_TAGVAR(lt_prog_compiler_static, $1)='-static' ;; # Lahey Fortran 8.1. lf95*) _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' _LT_TAGVAR(lt_prog_compiler_pic, $1)='--shared' _LT_TAGVAR(lt_prog_compiler_static, $1)='--static' ;; nagfor*) # NAG Fortran compiler _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,-Wl,,' _LT_TAGVAR(lt_prog_compiler_pic, $1)='-PIC' _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' ;; pgcc* | pgf77* | pgf90* | pgf95* | pgfortran*) # Portland Group compilers (*not* the Pentium gcc compiler, # which looks to be a dead project) _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fpic' _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' ;; ccc*) _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' # All Alpha code is PIC. _LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared' ;; xl* | bgxl* | bgf* | mpixl*) # IBM XL C 8.0/Fortran 10.1, 11.1 on PPC and BlueGene _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' _LT_TAGVAR(lt_prog_compiler_pic, $1)='-qpic' _LT_TAGVAR(lt_prog_compiler_static, $1)='-qstaticlink' ;; *) case `$CC -V 2>&1 | sed 5q` in *Sun\ Ceres\ Fortran* | *Sun*Fortran*\ [[1-7]].* | *Sun*Fortran*\ 8.[[0-3]]*) # Sun Fortran 8.3 passes all unrecognized flags to the linker _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' _LT_TAGVAR(lt_prog_compiler_wl, $1)='' ;; *Sun\ F* | *Sun*Fortran*) _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Qoption ld ' ;; *Sun\ C*) # Sun C 5.9 _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' ;; *Intel*\ [[CF]]*Compiler*) _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC' _LT_TAGVAR(lt_prog_compiler_static, $1)='-static' ;; *Portland\ Group*) _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fpic' _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' ;; esac ;; esac ;; newsos6) _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' ;; *nto* | *qnx*) # QNX uses GNU C++, but need to define -shared option too, otherwise # it will coredump. _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC -shared' ;; osf3* | osf4* | osf5*) _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' # All OSF/1 code is PIC. _LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared' ;; rdos*) _LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared' ;; solaris*) _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' case $cc_basename in f77* | f90* | f95* | sunf77* | sunf90* | sunf95*) _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Qoption ld ';; *) _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,';; esac ;; sunos4*) _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Qoption ld ' _LT_TAGVAR(lt_prog_compiler_pic, $1)='-PIC' _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' ;; sysv4 | sysv4.2uw2* | sysv4.3*) _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' ;; sysv4*MP*) if test -d /usr/nec ;then _LT_TAGVAR(lt_prog_compiler_pic, $1)='-Kconform_pic' _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' fi ;; sysv5* | unixware* | sco3.2v5* | sco5v6* | OpenUNIX*) _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' ;; unicos*) _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' _LT_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no ;; uts4*) _LT_TAGVAR(lt_prog_compiler_pic, $1)='-pic' _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' ;; *) _LT_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no ;; esac fi ]) case $host_os in # For platforms which do not support PIC, -DPIC is meaningless: *djgpp*) _LT_TAGVAR(lt_prog_compiler_pic, $1)= ;; *) _LT_TAGVAR(lt_prog_compiler_pic, $1)="$_LT_TAGVAR(lt_prog_compiler_pic, $1)@&t@m4_if([$1],[],[ -DPIC],[m4_if([$1],[CXX],[ -DPIC],[])])" ;; esac AC_CACHE_CHECK([for $compiler option to produce PIC], [_LT_TAGVAR(lt_cv_prog_compiler_pic, $1)], [_LT_TAGVAR(lt_cv_prog_compiler_pic, $1)=$_LT_TAGVAR(lt_prog_compiler_pic, $1)]) _LT_TAGVAR(lt_prog_compiler_pic, $1)=$_LT_TAGVAR(lt_cv_prog_compiler_pic, $1) # # Check to make sure the PIC flag actually works. # if test -n "$_LT_TAGVAR(lt_prog_compiler_pic, $1)"; then _LT_COMPILER_OPTION([if $compiler PIC flag $_LT_TAGVAR(lt_prog_compiler_pic, $1) works], [_LT_TAGVAR(lt_cv_prog_compiler_pic_works, $1)], [$_LT_TAGVAR(lt_prog_compiler_pic, $1)@&t@m4_if([$1],[],[ -DPIC],[m4_if([$1],[CXX],[ -DPIC],[])])], [], [case $_LT_TAGVAR(lt_prog_compiler_pic, $1) in "" | " "*) ;; *) _LT_TAGVAR(lt_prog_compiler_pic, $1)=" $_LT_TAGVAR(lt_prog_compiler_pic, $1)" ;; esac], [_LT_TAGVAR(lt_prog_compiler_pic, $1)= _LT_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no]) fi _LT_TAGDECL([pic_flag], [lt_prog_compiler_pic], [1], [Additional compiler flags for building library objects]) _LT_TAGDECL([wl], [lt_prog_compiler_wl], [1], [How to pass a linker flag through the compiler]) # # Check to make sure the static flag actually works. # wl=$_LT_TAGVAR(lt_prog_compiler_wl, $1) eval lt_tmp_static_flag=\"$_LT_TAGVAR(lt_prog_compiler_static, $1)\" _LT_LINKER_OPTION([if $compiler static flag $lt_tmp_static_flag works], _LT_TAGVAR(lt_cv_prog_compiler_static_works, $1), $lt_tmp_static_flag, [], [_LT_TAGVAR(lt_prog_compiler_static, $1)=]) _LT_TAGDECL([link_static_flag], [lt_prog_compiler_static], [1], [Compiler flag to prevent dynamic linking]) ])# _LT_COMPILER_PIC # _LT_LINKER_SHLIBS([TAGNAME]) # ---------------------------- # See if the linker supports building shared libraries. m4_defun([_LT_LINKER_SHLIBS], [AC_REQUIRE([LT_PATH_LD])dnl AC_REQUIRE([LT_PATH_NM])dnl m4_require([_LT_PATH_MANIFEST_TOOL])dnl m4_require([_LT_FILEUTILS_DEFAULTS])dnl m4_require([_LT_DECL_EGREP])dnl m4_require([_LT_DECL_SED])dnl m4_require([_LT_CMD_GLOBAL_SYMBOLS])dnl m4_require([_LT_TAG_COMPILER])dnl AC_MSG_CHECKING([whether the $compiler linker ($LD) supports shared libraries]) m4_if([$1], [CXX], [ _LT_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols' _LT_TAGVAR(exclude_expsyms, $1)=['_GLOBAL_OFFSET_TABLE_|_GLOBAL__F[ID]_.*'] case $host_os in aix[[4-9]]*) # If we're using GNU nm, then we don't want the "-C" option. # -C means demangle to AIX nm, but means don't demangle with GNU nm # Also, AIX nm treats weak defined symbols like other global defined # symbols, whereas GNU nm marks them as "W". if $NM -V 2>&1 | $GREP 'GNU' > /dev/null; then _LT_TAGVAR(export_symbols_cmds, $1)='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W")) && ([substr](\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols' else _LT_TAGVAR(export_symbols_cmds, $1)='$NM -BCpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B")) && ([substr](\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols' fi ;; pw32*) _LT_TAGVAR(export_symbols_cmds, $1)="$ltdll_cmds" ;; cygwin* | mingw* | cegcc*) case $cc_basename in cl*) _LT_TAGVAR(exclude_expsyms, $1)='_NULL_IMPORT_DESCRIPTOR|_IMPORT_DESCRIPTOR_.*' ;; *) _LT_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[[BCDGRS]][[ ]]/s/.*[[ ]]\([[^ ]]*\)/\1 DATA/;s/^.*[[ ]]__nm__\([[^ ]]*\)[[ ]][[^ ]]*/\1 DATA/;/^I[[ ]]/d;/^[[AITW]][[ ]]/s/.* //'\'' | sort | uniq > $export_symbols' _LT_TAGVAR(exclude_expsyms, $1)=['[_]+GLOBAL_OFFSET_TABLE_|[_]+GLOBAL__[FID]_.*|[_]+head_[A-Za-z0-9_]+_dll|[A-Za-z0-9_]+_dll_iname'] ;; esac ;; linux* | k*bsd*-gnu | gnu*) _LT_TAGVAR(link_all_deplibs, $1)=no ;; *) _LT_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols' ;; esac ], [ runpath_var= _LT_TAGVAR(allow_undefined_flag, $1)= _LT_TAGVAR(always_export_symbols, $1)=no _LT_TAGVAR(archive_cmds, $1)= _LT_TAGVAR(archive_expsym_cmds, $1)= _LT_TAGVAR(compiler_needs_object, $1)=no _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=no _LT_TAGVAR(export_dynamic_flag_spec, $1)= _LT_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols' _LT_TAGVAR(hardcode_automatic, $1)=no _LT_TAGVAR(hardcode_direct, $1)=no _LT_TAGVAR(hardcode_direct_absolute, $1)=no _LT_TAGVAR(hardcode_libdir_flag_spec, $1)= _LT_TAGVAR(hardcode_libdir_separator, $1)= _LT_TAGVAR(hardcode_minus_L, $1)=no _LT_TAGVAR(hardcode_shlibpath_var, $1)=unsupported _LT_TAGVAR(inherit_rpath, $1)=no _LT_TAGVAR(link_all_deplibs, $1)=unknown _LT_TAGVAR(module_cmds, $1)= _LT_TAGVAR(module_expsym_cmds, $1)= _LT_TAGVAR(old_archive_from_new_cmds, $1)= _LT_TAGVAR(old_archive_from_expsyms_cmds, $1)= _LT_TAGVAR(thread_safe_flag_spec, $1)= _LT_TAGVAR(whole_archive_flag_spec, $1)= # include_expsyms should be a list of space-separated symbols to be *always* # included in the symbol list _LT_TAGVAR(include_expsyms, $1)= # exclude_expsyms can be an extended regexp of symbols to exclude # it will be wrapped by ` (' and `)$', so one must not match beginning or # end of line. Example: `a|bc|.*d.*' will exclude the symbols `a' and `bc', # as well as any symbol that contains `d'. _LT_TAGVAR(exclude_expsyms, $1)=['_GLOBAL_OFFSET_TABLE_|_GLOBAL__F[ID]_.*'] # Although _GLOBAL_OFFSET_TABLE_ is a valid symbol C name, most a.out # platforms (ab)use it in PIC code, but their linkers get confused if # the symbol is explicitly referenced. Since portable code cannot # rely on this symbol name, it's probably fine to never include it in # preloaded symbol tables. # Exclude shared library initialization/finalization symbols. dnl Note also adjust exclude_expsyms for C++ above. extract_expsyms_cmds= case $host_os in cygwin* | mingw* | pw32* | cegcc*) # FIXME: the MSVC++ port hasn't been tested in a loooong time # When not using gcc, we currently assume that we are using # Microsoft Visual C++. if test "$GCC" != yes; then with_gnu_ld=no fi ;; interix*) # we just hope/assume this is gcc and not c89 (= MSVC++) with_gnu_ld=yes ;; openbsd*) with_gnu_ld=no ;; linux* | k*bsd*-gnu | gnu*) _LT_TAGVAR(link_all_deplibs, $1)=no ;; esac _LT_TAGVAR(ld_shlibs, $1)=yes # On some targets, GNU ld is compatible enough with the native linker # that we're better off using the native interface for both. lt_use_gnu_ld_interface=no if test "$with_gnu_ld" = yes; then case $host_os in aix*) # The AIX port of GNU ld has always aspired to compatibility # with the native linker. However, as the warning in the GNU ld # block says, versions before 2.19.5* couldn't really create working # shared libraries, regardless of the interface used. case `$LD -v 2>&1` in *\ \(GNU\ Binutils\)\ 2.19.5*) ;; *\ \(GNU\ Binutils\)\ 2.[[2-9]]*) ;; *\ \(GNU\ Binutils\)\ [[3-9]]*) ;; *) lt_use_gnu_ld_interface=yes ;; esac ;; *) lt_use_gnu_ld_interface=yes ;; esac fi if test "$lt_use_gnu_ld_interface" = yes; then # If archive_cmds runs LD, not CC, wlarc should be empty wlarc='${wl}' # Set some defaults for GNU ld with shared library support. These # are reset later if shared libraries are not supported. Putting them # here allows them to be overridden if necessary. runpath_var=LD_RUN_PATH _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir' _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic' # ancient GNU ld didn't support --whole-archive et. al. if $LD --help 2>&1 | $GREP 'no-whole-archive' > /dev/null; then _LT_TAGVAR(whole_archive_flag_spec, $1)="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive' else _LT_TAGVAR(whole_archive_flag_spec, $1)= fi supports_anon_versioning=no case `$LD -v 2>&1` in *GNU\ gold*) supports_anon_versioning=yes ;; *\ [[01]].* | *\ 2.[[0-9]].* | *\ 2.10.*) ;; # catch versions < 2.11 *\ 2.11.93.0.2\ *) supports_anon_versioning=yes ;; # RH7.3 ... *\ 2.11.92.0.12\ *) supports_anon_versioning=yes ;; # Mandrake 8.2 ... *\ 2.11.*) ;; # other 2.11 versions *) supports_anon_versioning=yes ;; esac # See if GNU ld supports shared libraries. case $host_os in aix[[3-9]]*) # On AIX/PPC, the GNU linker is very broken if test "$host_cpu" != ia64; then _LT_TAGVAR(ld_shlibs, $1)=no cat <<_LT_EOF 1>&2 *** Warning: the GNU linker, at least up to release 2.19, is reported *** to be unable to reliably create shared libraries on AIX. *** Therefore, libtool is disabling shared libraries support. If you *** really care for shared libraries, you may want to install binutils *** 2.20 or above, or modify your PATH so that a non-GNU linker is found. *** You will then need to restart the configuration process. _LT_EOF fi ;; amigaos*) case $host_cpu in powerpc) # see comment about AmigaOS4 .so support _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' _LT_TAGVAR(archive_expsym_cmds, $1)='' ;; m68k) _LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/a2ixlibrary.data~$ECHO "#define NAME $libname" > $output_objdir/a2ixlibrary.data~$ECHO "#define LIBRARY_ID 1" >> $output_objdir/a2ixlibrary.data~$ECHO "#define VERSION $major" >> $output_objdir/a2ixlibrary.data~$ECHO "#define REVISION $revision" >> $output_objdir/a2ixlibrary.data~$AR $AR_FLAGS $lib $libobjs~$RANLIB $lib~(cd $output_objdir && a2ixlibrary -32)' _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' _LT_TAGVAR(hardcode_minus_L, $1)=yes ;; esac ;; beos*) if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then _LT_TAGVAR(allow_undefined_flag, $1)=unsupported # Joseph Beckenbach says some releases of gcc # support --undefined. This deserves some investigation. FIXME _LT_TAGVAR(archive_cmds, $1)='$CC -nostart $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' else _LT_TAGVAR(ld_shlibs, $1)=no fi ;; cygwin* | mingw* | pw32* | cegcc*) # _LT_TAGVAR(hardcode_libdir_flag_spec, $1) is actually meaningless, # as there is no search path for DLLs. _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-all-symbols' _LT_TAGVAR(allow_undefined_flag, $1)=unsupported _LT_TAGVAR(always_export_symbols, $1)=no _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes _LT_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[[BCDGRS]][[ ]]/s/.*[[ ]]\([[^ ]]*\)/\1 DATA/;s/^.*[[ ]]__nm__\([[^ ]]*\)[[ ]][[^ ]]*/\1 DATA/;/^I[[ ]]/d;/^[[AITW]][[ ]]/s/.* //'\'' | sort | uniq > $export_symbols' _LT_TAGVAR(exclude_expsyms, $1)=['[_]+GLOBAL_OFFSET_TABLE_|[_]+GLOBAL__[FID]_.*|[_]+head_[A-Za-z0-9_]+_dll|[A-Za-z0-9_]+_dll_iname'] if $LD --help 2>&1 | $GREP 'auto-import' > /dev/null; then _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib' # If the export-symbols file already is a .def file (1st line # is EXPORTS), use it as is; otherwise, prepend... _LT_TAGVAR(archive_expsym_cmds, $1)='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then cp $export_symbols $output_objdir/$soname.def; else echo EXPORTS > $output_objdir/$soname.def; cat $export_symbols >> $output_objdir/$soname.def; fi~ $CC -shared $output_objdir/$soname.def $libobjs $deplibs $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib' else _LT_TAGVAR(ld_shlibs, $1)=no fi ;; haiku*) _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' _LT_TAGVAR(link_all_deplibs, $1)=yes ;; interix[[3-9]]*) _LT_TAGVAR(hardcode_direct, $1)=no _LT_TAGVAR(hardcode_shlibpath_var, $1)=no _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir' _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E' # Hack: On Interix 3.x, we cannot compile PIC because of a broken gcc. # Instead, shared libraries are loaded at an image base (0x10000000 by # default) and relocated if they conflict, which is a slow very memory # consuming and fragmenting process. To avoid this, we pick a random, # 256 KiB-aligned image base between 0x50000000 and 0x6FFC0000 at link # time. Moving up from 0x10000000 also allows more sbrk(2) space. _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib' _LT_TAGVAR(archive_expsym_cmds, $1)='sed "s,^,_," $export_symbols >$output_objdir/$soname.expsym~$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--retain-symbols-file,$output_objdir/$soname.expsym ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib' ;; gnu* | linux* | tpf* | k*bsd*-gnu | kopensolaris*-gnu) tmp_diet=no if test "$host_os" = linux-dietlibc; then case $cc_basename in diet\ *) tmp_diet=yes;; # linux-dietlibc with static linking (!diet-dyn) esac fi if $LD --help 2>&1 | $EGREP ': supported targets:.* elf' > /dev/null \ && test "$tmp_diet" = no then tmp_addflag=' $pic_flag' tmp_sharedflag='-shared' case $cc_basename,$host_cpu in pgcc*) # Portland Group C compiler _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive' tmp_addflag=' $pic_flag' ;; pgf77* | pgf90* | pgf95* | pgfortran*) # Portland Group f77 and f90 compilers _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive' tmp_addflag=' $pic_flag -Mnomain' ;; ecc*,ia64* | icc*,ia64*) # Intel C compiler on ia64 tmp_addflag=' -i_dynamic' ;; efc*,ia64* | ifort*,ia64*) # Intel Fortran compiler on ia64 tmp_addflag=' -i_dynamic -nofor_main' ;; ifc* | ifort*) # Intel Fortran compiler tmp_addflag=' -nofor_main' ;; lf95*) # Lahey Fortran 8.1 _LT_TAGVAR(whole_archive_flag_spec, $1)= tmp_sharedflag='--shared' ;; xl[[cC]]* | bgxl[[cC]]* | mpixl[[cC]]*) # IBM XL C 8.0 on PPC (deal with xlf below) tmp_sharedflag='-qmkshrobj' tmp_addflag= ;; nvcc*) # Cuda Compiler Driver 2.2 _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive' _LT_TAGVAR(compiler_needs_object, $1)=yes ;; esac case `$CC -V 2>&1 | sed 5q` in *Sun\ C*) # Sun C 5.9 _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive`new_convenience=; for conv in $convenience\"\"; do test -z \"$conv\" || new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive' _LT_TAGVAR(compiler_needs_object, $1)=yes tmp_sharedflag='-G' ;; *Sun\ F*) # Sun Fortran 8.3 tmp_sharedflag='-G' ;; esac _LT_TAGVAR(archive_cmds, $1)='$CC '"$tmp_sharedflag""$tmp_addflag"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' if test "x$supports_anon_versioning" = xyes; then _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $output_objdir/$libname.ver~ cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~ echo "local: *; };" >> $output_objdir/$libname.ver~ $CC '"$tmp_sharedflag""$tmp_addflag"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-version-script ${wl}$output_objdir/$libname.ver -o $lib' fi case $cc_basename in xlf* | bgf* | bgxlf* | mpixlf*) # IBM XL Fortran 10.1 on PPC cannot create shared libs itself _LT_TAGVAR(whole_archive_flag_spec, $1)='--whole-archive$convenience --no-whole-archive' _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir' _LT_TAGVAR(archive_cmds, $1)='$LD -shared $libobjs $deplibs $linker_flags -soname $soname -o $lib' if test "x$supports_anon_versioning" = xyes; then _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $output_objdir/$libname.ver~ cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~ echo "local: *; };" >> $output_objdir/$libname.ver~ $LD -shared $libobjs $deplibs $linker_flags -soname $soname -version-script $output_objdir/$libname.ver -o $lib' fi ;; esac else _LT_TAGVAR(ld_shlibs, $1)=no fi ;; netbsd* | netbsdelf*-gnu) if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then _LT_TAGVAR(archive_cmds, $1)='$LD -Bshareable $libobjs $deplibs $linker_flags -o $lib' wlarc= else _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' fi ;; solaris*) if $LD -v 2>&1 | $GREP 'BFD 2\.8' > /dev/null; then _LT_TAGVAR(ld_shlibs, $1)=no cat <<_LT_EOF 1>&2 *** Warning: The releases 2.8.* of the GNU linker cannot reliably *** create shared libraries on Solaris systems. Therefore, libtool *** is disabling shared libraries support. We urge you to upgrade GNU *** binutils to release 2.9.1 or newer. Another option is to modify *** your PATH or compiler configuration so that the native linker is *** used, and then restart. _LT_EOF elif $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' else _LT_TAGVAR(ld_shlibs, $1)=no fi ;; sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX*) case `$LD -v 2>&1` in *\ [[01]].* | *\ 2.[[0-9]].* | *\ 2.1[[0-5]].*) _LT_TAGVAR(ld_shlibs, $1)=no cat <<_LT_EOF 1>&2 *** Warning: Releases of the GNU linker prior to 2.16.91.0.3 can not *** reliably create shared libraries on SCO systems. Therefore, libtool *** is disabling shared libraries support. We urge you to upgrade GNU *** binutils to release 2.16.91.0.3 or newer. Another option is to modify *** your PATH or compiler configuration so that the native linker is *** used, and then restart. _LT_EOF ;; *) # For security reasons, it is highly recommended that you always # use absolute paths for naming shared libraries, and exclude the # DT_RUNPATH tag from executables and libraries. But doing so # requires that you compile everything twice, which is a pain. if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir' _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' else _LT_TAGVAR(ld_shlibs, $1)=no fi ;; esac ;; sunos4*) _LT_TAGVAR(archive_cmds, $1)='$LD -assert pure-text -Bshareable -o $lib $libobjs $deplibs $linker_flags' wlarc= _LT_TAGVAR(hardcode_direct, $1)=yes _LT_TAGVAR(hardcode_shlibpath_var, $1)=no ;; *) if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' else _LT_TAGVAR(ld_shlibs, $1)=no fi ;; esac if test "$_LT_TAGVAR(ld_shlibs, $1)" = no; then runpath_var= _LT_TAGVAR(hardcode_libdir_flag_spec, $1)= _LT_TAGVAR(export_dynamic_flag_spec, $1)= _LT_TAGVAR(whole_archive_flag_spec, $1)= fi else # PORTME fill in a description of your system's linker (not GNU ld) case $host_os in aix3*) _LT_TAGVAR(allow_undefined_flag, $1)=unsupported _LT_TAGVAR(always_export_symbols, $1)=yes _LT_TAGVAR(archive_expsym_cmds, $1)='$LD -o $output_objdir/$soname $libobjs $deplibs $linker_flags -bE:$export_symbols -T512 -H512 -bM:SRE~$AR $AR_FLAGS $lib $output_objdir/$soname' # Note: this linker hardcodes the directories in LIBPATH if there # are no directories specified by -L. _LT_TAGVAR(hardcode_minus_L, $1)=yes if test "$GCC" = yes && test -z "$lt_prog_compiler_static"; then # Neither direct hardcoding nor static linking is supported with a # broken collect2. _LT_TAGVAR(hardcode_direct, $1)=unsupported fi ;; aix[[4-9]]*) if test "$host_cpu" = ia64; then # On IA64, the linker does run time linking by default, so we don't # have to do anything special. aix_use_runtimelinking=no exp_sym_flag='-Bexport' no_entry_flag="" else # If we're using GNU nm, then we don't want the "-C" option. # -C means demangle to AIX nm, but means don't demangle with GNU nm # Also, AIX nm treats weak defined symbols like other global # defined symbols, whereas GNU nm marks them as "W". if $NM -V 2>&1 | $GREP 'GNU' > /dev/null; then _LT_TAGVAR(export_symbols_cmds, $1)='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W")) && ([substr](\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols' else _LT_TAGVAR(export_symbols_cmds, $1)='$NM -BCpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B")) && ([substr](\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols' fi aix_use_runtimelinking=no # Test if we are trying to use run time linking or normal # AIX style linking. If -brtl is somewhere in LDFLAGS, we # need to do runtime linking. case $host_os in aix4.[[23]]|aix4.[[23]].*|aix[[5-9]]*) for ld_flag in $LDFLAGS; do if (test $ld_flag = "-brtl" || test $ld_flag = "-Wl,-brtl"); then aix_use_runtimelinking=yes break fi done ;; esac exp_sym_flag='-bexport' no_entry_flag='-bnoentry' fi # When large executables or shared objects are built, AIX ld can # have problems creating the table of contents. If linking a library # or program results in "error TOC overflow" add -mminimal-toc to # CXXFLAGS/CFLAGS for g++/gcc. In the cases where that is not # enough to fix the problem, add -Wl,-bbigtoc to LDFLAGS. _LT_TAGVAR(archive_cmds, $1)='' _LT_TAGVAR(hardcode_direct, $1)=yes _LT_TAGVAR(hardcode_direct_absolute, $1)=yes _LT_TAGVAR(hardcode_libdir_separator, $1)=':' _LT_TAGVAR(link_all_deplibs, $1)=yes _LT_TAGVAR(file_list_spec, $1)='${wl}-f,' if test "$GCC" = yes; then case $host_os in aix4.[[012]]|aix4.[[012]].*) # We only want to do this on AIX 4.2 and lower, the check # below for broken collect2 doesn't work under 4.3+ collect2name=`${CC} -print-prog-name=collect2` if test -f "$collect2name" && strings "$collect2name" | $GREP resolve_lib_name >/dev/null then # We have reworked collect2 : else # We have old collect2 _LT_TAGVAR(hardcode_direct, $1)=unsupported # It fails to find uninstalled libraries when the uninstalled # path is not listed in the libpath. Setting hardcode_minus_L # to unsupported forces relinking _LT_TAGVAR(hardcode_minus_L, $1)=yes _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' _LT_TAGVAR(hardcode_libdir_separator, $1)= fi ;; esac shared_flag='-shared' if test "$aix_use_runtimelinking" = yes; then shared_flag="$shared_flag "'${wl}-G' fi _LT_TAGVAR(link_all_deplibs, $1)=no else # not using gcc if test "$host_cpu" = ia64; then # VisualAge C++, Version 5.5 for AIX 5L for IA-64, Beta 3 Release # chokes on -Wl,-G. The following line is correct: shared_flag='-G' else if test "$aix_use_runtimelinking" = yes; then shared_flag='${wl}-G' else shared_flag='${wl}-bM:SRE' fi fi fi _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-bexpall' # It seems that -bexpall does not export symbols beginning with # underscore (_), so it is better to generate a list of symbols to export. _LT_TAGVAR(always_export_symbols, $1)=yes if test "$aix_use_runtimelinking" = yes; then # Warning - without using the other runtime loading flags (-brtl), # -berok will link without error, but may produce a broken library. _LT_TAGVAR(allow_undefined_flag, $1)='-berok' # Determine the default libpath from the value encoded in an # empty executable. _LT_SYS_MODULE_PATH_AIX([$1]) _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-blibpath:$libdir:'"$aix_libpath" _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags `if test "x${allow_undefined_flag}" != "x"; then func_echo_all "${wl}${allow_undefined_flag}"; else :; fi` '"\${wl}$exp_sym_flag:\$export_symbols $shared_flag" else if test "$host_cpu" = ia64; then _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-R $libdir:/usr/lib:/lib' _LT_TAGVAR(allow_undefined_flag, $1)="-z nodefs" _LT_TAGVAR(archive_expsym_cmds, $1)="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags ${wl}${allow_undefined_flag} '"\${wl}$exp_sym_flag:\$export_symbols" else # Determine the default libpath from the value encoded in an # empty executable. _LT_SYS_MODULE_PATH_AIX([$1]) _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-blibpath:$libdir:'"$aix_libpath" # Warning - without using the other run time loading flags, # -berok will link without error, but may produce a broken library. _LT_TAGVAR(no_undefined_flag, $1)=' ${wl}-bernotok' _LT_TAGVAR(allow_undefined_flag, $1)=' ${wl}-berok' if test "$with_gnu_ld" = yes; then # We only use this code for GNU lds that support --whole-archive. _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive$convenience ${wl}--no-whole-archive' else # Exported symbols can be pulled into shared objects from archives _LT_TAGVAR(whole_archive_flag_spec, $1)='$convenience' fi _LT_TAGVAR(archive_cmds_need_lc, $1)=yes # This is similar to how AIX traditionally builds its shared libraries. _LT_TAGVAR(archive_expsym_cmds, $1)="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs ${wl}-bnoentry $compiler_flags ${wl}-bE:$export_symbols${allow_undefined_flag}~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$soname' fi fi ;; amigaos*) case $host_cpu in powerpc) # see comment about AmigaOS4 .so support _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' _LT_TAGVAR(archive_expsym_cmds, $1)='' ;; m68k) _LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/a2ixlibrary.data~$ECHO "#define NAME $libname" > $output_objdir/a2ixlibrary.data~$ECHO "#define LIBRARY_ID 1" >> $output_objdir/a2ixlibrary.data~$ECHO "#define VERSION $major" >> $output_objdir/a2ixlibrary.data~$ECHO "#define REVISION $revision" >> $output_objdir/a2ixlibrary.data~$AR $AR_FLAGS $lib $libobjs~$RANLIB $lib~(cd $output_objdir && a2ixlibrary -32)' _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' _LT_TAGVAR(hardcode_minus_L, $1)=yes ;; esac ;; bsdi[[45]]*) _LT_TAGVAR(export_dynamic_flag_spec, $1)=-rdynamic ;; cygwin* | mingw* | pw32* | cegcc*) # When not using gcc, we currently assume that we are using # Microsoft Visual C++. # hardcode_libdir_flag_spec is actually meaningless, as there is # no search path for DLLs. case $cc_basename in cl*) # Native MSVC _LT_TAGVAR(hardcode_libdir_flag_spec, $1)=' ' _LT_TAGVAR(allow_undefined_flag, $1)=unsupported _LT_TAGVAR(always_export_symbols, $1)=yes _LT_TAGVAR(file_list_spec, $1)='@' # Tell ltmain to make .lib files, not .a files. libext=lib # Tell ltmain to make .dll files, not .so files. shrext_cmds=".dll" # FIXME: Setting linknames here is a bad hack. _LT_TAGVAR(archive_cmds, $1)='$CC -o $output_objdir/$soname $libobjs $compiler_flags $deplibs -Wl,-dll~linknames=' _LT_TAGVAR(archive_expsym_cmds, $1)='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then sed -n -e 's/\\\\\\\(.*\\\\\\\)/-link\\\ -EXPORT:\\\\\\\1/' -e '1\\\!p' < $export_symbols > $output_objdir/$soname.exp; else sed -e 's/\\\\\\\(.*\\\\\\\)/-link\\\ -EXPORT:\\\\\\\1/' < $export_symbols > $output_objdir/$soname.exp; fi~ $CC -o $tool_output_objdir$soname $libobjs $compiler_flags $deplibs "@$tool_output_objdir$soname.exp" -Wl,-DLL,-IMPLIB:"$tool_output_objdir$libname.dll.lib"~ linknames=' # The linker will not automatically build a static lib if we build a DLL. # _LT_TAGVAR(old_archive_from_new_cmds, $1)='true' _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes _LT_TAGVAR(exclude_expsyms, $1)='_NULL_IMPORT_DESCRIPTOR|_IMPORT_DESCRIPTOR_.*' _LT_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[[BCDGRS]][[ ]]/s/.*[[ ]]\([[^ ]]*\)/\1,DATA/'\'' | $SED -e '\''/^[[AITW]][[ ]]/s/.*[[ ]]//'\'' | sort | uniq > $export_symbols' # Don't use ranlib _LT_TAGVAR(old_postinstall_cmds, $1)='chmod 644 $oldlib' _LT_TAGVAR(postlink_cmds, $1)='lt_outputfile="@OUTPUT@"~ lt_tool_outputfile="@TOOL_OUTPUT@"~ case $lt_outputfile in *.exe|*.EXE) ;; *) lt_outputfile="$lt_outputfile.exe" lt_tool_outputfile="$lt_tool_outputfile.exe" ;; esac~ if test "$MANIFEST_TOOL" != ":" && test -f "$lt_outputfile.manifest"; then $MANIFEST_TOOL -manifest "$lt_tool_outputfile.manifest" -outputresource:"$lt_tool_outputfile" || exit 1; $RM "$lt_outputfile.manifest"; fi' ;; *) # Assume MSVC wrapper _LT_TAGVAR(hardcode_libdir_flag_spec, $1)=' ' _LT_TAGVAR(allow_undefined_flag, $1)=unsupported # Tell ltmain to make .lib files, not .a files. libext=lib # Tell ltmain to make .dll files, not .so files. shrext_cmds=".dll" # FIXME: Setting linknames here is a bad hack. _LT_TAGVAR(archive_cmds, $1)='$CC -o $lib $libobjs $compiler_flags `func_echo_all "$deplibs" | $SED '\''s/ -lc$//'\''` -link -dll~linknames=' # The linker will automatically build a .lib file if we build a DLL. _LT_TAGVAR(old_archive_from_new_cmds, $1)='true' # FIXME: Should let the user specify the lib program. _LT_TAGVAR(old_archive_cmds, $1)='lib -OUT:$oldlib$oldobjs$old_deplibs' _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes ;; esac ;; darwin* | rhapsody*) _LT_DARWIN_LINKER_FEATURES($1) ;; dgux*) _LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' _LT_TAGVAR(hardcode_shlibpath_var, $1)=no ;; # FreeBSD 2.2.[012] allows us to include c++rt0.o to get C++ constructor # support. Future versions do this automatically, but an explicit c++rt0.o # does not break anything, and helps significantly (at the cost of a little # extra space). freebsd2.2*) _LT_TAGVAR(archive_cmds, $1)='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags /usr/lib/c++rt0.o' _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir' _LT_TAGVAR(hardcode_direct, $1)=yes _LT_TAGVAR(hardcode_shlibpath_var, $1)=no ;; # Unfortunately, older versions of FreeBSD 2 do not have this feature. freebsd2.*) _LT_TAGVAR(archive_cmds, $1)='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags' _LT_TAGVAR(hardcode_direct, $1)=yes _LT_TAGVAR(hardcode_minus_L, $1)=yes _LT_TAGVAR(hardcode_shlibpath_var, $1)=no ;; # FreeBSD 3 and greater uses gcc -shared to do shared libraries. freebsd* | dragonfly*) _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags' _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir' _LT_TAGVAR(hardcode_direct, $1)=yes _LT_TAGVAR(hardcode_shlibpath_var, $1)=no ;; hpux9*) if test "$GCC" = yes; then _LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/$soname~$CC -shared $pic_flag ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $libobjs $deplibs $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib' else _LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/$soname~$LD -b +b $install_libdir -o $output_objdir/$soname $libobjs $deplibs $linker_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib' fi _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir' _LT_TAGVAR(hardcode_libdir_separator, $1)=: _LT_TAGVAR(hardcode_direct, $1)=yes # hardcode_minus_L: Not really in the search PATH, # but as the default location of the library. _LT_TAGVAR(hardcode_minus_L, $1)=yes _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E' ;; hpux10*) if test "$GCC" = yes && test "$with_gnu_ld" = no; then _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags' else _LT_TAGVAR(archive_cmds, $1)='$LD -b +h $soname +b $install_libdir -o $lib $libobjs $deplibs $linker_flags' fi if test "$with_gnu_ld" = no; then _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir' _LT_TAGVAR(hardcode_libdir_separator, $1)=: _LT_TAGVAR(hardcode_direct, $1)=yes _LT_TAGVAR(hardcode_direct_absolute, $1)=yes _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E' # hardcode_minus_L: Not really in the search PATH, # but as the default location of the library. _LT_TAGVAR(hardcode_minus_L, $1)=yes fi ;; hpux11*) if test "$GCC" = yes && test "$with_gnu_ld" = no; then case $host_cpu in hppa*64*) _LT_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}+h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags' ;; ia64*) _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $libobjs $deplibs $compiler_flags' ;; *) _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags' ;; esac else case $host_cpu in hppa*64*) _LT_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags' ;; ia64*) _LT_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $libobjs $deplibs $compiler_flags' ;; *) m4_if($1, [], [ # Older versions of the 11.00 compiler do not understand -b yet # (HP92453-01 A.11.01.20 doesn't, HP92453-01 B.11.X.35175-35176.GP does) _LT_LINKER_OPTION([if $CC understands -b], _LT_TAGVAR(lt_cv_prog_compiler__b, $1), [-b], [_LT_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags'], [_LT_TAGVAR(archive_cmds, $1)='$LD -b +h $soname +b $install_libdir -o $lib $libobjs $deplibs $linker_flags'])], [_LT_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags']) ;; esac fi if test "$with_gnu_ld" = no; then _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir' _LT_TAGVAR(hardcode_libdir_separator, $1)=: case $host_cpu in hppa*64*|ia64*) _LT_TAGVAR(hardcode_direct, $1)=no _LT_TAGVAR(hardcode_shlibpath_var, $1)=no ;; *) _LT_TAGVAR(hardcode_direct, $1)=yes _LT_TAGVAR(hardcode_direct_absolute, $1)=yes _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E' # hardcode_minus_L: Not really in the search PATH, # but as the default location of the library. _LT_TAGVAR(hardcode_minus_L, $1)=yes ;; esac fi ;; irix5* | irix6* | nonstopux*) if test "$GCC" = yes; then _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib' # Try to use the -exported_symbol ld option, if it does not # work, assume that -exports_file does not work either and # implicitly export all symbols. # This should be the same for all languages, so no per-tag cache variable. AC_CACHE_CHECK([whether the $host_os linker accepts -exported_symbol], [lt_cv_irix_exported_symbol], [save_LDFLAGS="$LDFLAGS" LDFLAGS="$LDFLAGS -shared ${wl}-exported_symbol ${wl}foo ${wl}-update_registry ${wl}/dev/null" AC_LINK_IFELSE( [AC_LANG_SOURCE( [AC_LANG_CASE([C], [[int foo (void) { return 0; }]], [C++], [[int foo (void) { return 0; }]], [Fortran 77], [[ subroutine foo end]], [Fortran], [[ subroutine foo end]])])], [lt_cv_irix_exported_symbol=yes], [lt_cv_irix_exported_symbol=no]) LDFLAGS="$save_LDFLAGS"]) if test "$lt_cv_irix_exported_symbol" = yes; then _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations ${wl}-exports_file ${wl}$export_symbols -o $lib' fi else _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib' _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -exports_file $export_symbols -o $lib' fi _LT_TAGVAR(archive_cmds_need_lc, $1)='no' _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir' _LT_TAGVAR(hardcode_libdir_separator, $1)=: _LT_TAGVAR(inherit_rpath, $1)=yes _LT_TAGVAR(link_all_deplibs, $1)=yes ;; netbsd* | netbsdelf*-gnu) if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then _LT_TAGVAR(archive_cmds, $1)='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags' # a.out else _LT_TAGVAR(archive_cmds, $1)='$LD -shared -o $lib $libobjs $deplibs $linker_flags' # ELF fi _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir' _LT_TAGVAR(hardcode_direct, $1)=yes _LT_TAGVAR(hardcode_shlibpath_var, $1)=no ;; newsos6) _LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' _LT_TAGVAR(hardcode_direct, $1)=yes _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir' _LT_TAGVAR(hardcode_libdir_separator, $1)=: _LT_TAGVAR(hardcode_shlibpath_var, $1)=no ;; *nto* | *qnx*) ;; openbsd*) if test -f /usr/libexec/ld.so; then _LT_TAGVAR(hardcode_direct, $1)=yes _LT_TAGVAR(hardcode_shlibpath_var, $1)=no _LT_TAGVAR(hardcode_direct_absolute, $1)=yes if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags' _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags ${wl}-retain-symbols-file,$export_symbols' _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir' _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E' else case $host_os in openbsd[[01]].* | openbsd2.[[0-7]] | openbsd2.[[0-7]].*) _LT_TAGVAR(archive_cmds, $1)='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags' _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir' ;; *) _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags' _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir' ;; esac fi else _LT_TAGVAR(ld_shlibs, $1)=no fi ;; os2*) _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' _LT_TAGVAR(hardcode_minus_L, $1)=yes _LT_TAGVAR(allow_undefined_flag, $1)=unsupported _LT_TAGVAR(archive_cmds, $1)='$ECHO "LIBRARY $libname INITINSTANCE" > $output_objdir/$libname.def~$ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~echo DATA >> $output_objdir/$libname.def~echo " SINGLE NONSHARED" >> $output_objdir/$libname.def~echo EXPORTS >> $output_objdir/$libname.def~emxexp $libobjs >> $output_objdir/$libname.def~$CC -Zdll -Zcrtdll -o $lib $libobjs $deplibs $compiler_flags $output_objdir/$libname.def' _LT_TAGVAR(old_archive_from_new_cmds, $1)='emximp -o $output_objdir/$libname.a $output_objdir/$libname.def' ;; osf3*) if test "$GCC" = yes; then _LT_TAGVAR(allow_undefined_flag, $1)=' ${wl}-expect_unresolved ${wl}\*' _LT_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib' else _LT_TAGVAR(allow_undefined_flag, $1)=' -expect_unresolved \*' _LT_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib' fi _LT_TAGVAR(archive_cmds_need_lc, $1)='no' _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir' _LT_TAGVAR(hardcode_libdir_separator, $1)=: ;; osf4* | osf5*) # as osf3* with the addition of -msym flag if test "$GCC" = yes; then _LT_TAGVAR(allow_undefined_flag, $1)=' ${wl}-expect_unresolved ${wl}\*' _LT_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $pic_flag $libobjs $deplibs $compiler_flags ${wl}-msym ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib' _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir' else _LT_TAGVAR(allow_undefined_flag, $1)=' -expect_unresolved \*' _LT_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags -msym -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib' _LT_TAGVAR(archive_expsym_cmds, $1)='for i in `cat $export_symbols`; do printf "%s %s\\n" -exported_symbol "\$i" >> $lib.exp; done; printf "%s\\n" "-hidden">> $lib.exp~ $CC -shared${allow_undefined_flag} ${wl}-input ${wl}$lib.exp $compiler_flags $libobjs $deplibs -soname $soname `test -n "$verstring" && $ECHO "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib~$RM $lib.exp' # Both c and cxx compiler support -rpath directly _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-rpath $libdir' fi _LT_TAGVAR(archive_cmds_need_lc, $1)='no' _LT_TAGVAR(hardcode_libdir_separator, $1)=: ;; solaris*) _LT_TAGVAR(no_undefined_flag, $1)=' -z defs' if test "$GCC" = yes; then wlarc='${wl}' _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag ${wl}-z ${wl}text ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags' _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~ $CC -shared $pic_flag ${wl}-z ${wl}text ${wl}-M ${wl}$lib.exp ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags~$RM $lib.exp' else case `$CC -V 2>&1` in *"Compilers 5.0"*) wlarc='' _LT_TAGVAR(archive_cmds, $1)='$LD -G${allow_undefined_flag} -h $soname -o $lib $libobjs $deplibs $linker_flags' _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~ $LD -G${allow_undefined_flag} -M $lib.exp -h $soname -o $lib $libobjs $deplibs $linker_flags~$RM $lib.exp' ;; *) wlarc='${wl}' _LT_TAGVAR(archive_cmds, $1)='$CC -G${allow_undefined_flag} -h $soname -o $lib $libobjs $deplibs $compiler_flags' _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~ $CC -G${allow_undefined_flag} -M $lib.exp -h $soname -o $lib $libobjs $deplibs $compiler_flags~$RM $lib.exp' ;; esac fi _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir' _LT_TAGVAR(hardcode_shlibpath_var, $1)=no case $host_os in solaris2.[[0-5]] | solaris2.[[0-5]].*) ;; *) # The compiler driver will combine and reorder linker options, # but understands `-z linker_flag'. GCC discards it without `$wl', # but is careful enough not to reorder. # Supported since Solaris 2.6 (maybe 2.5.1?) if test "$GCC" = yes; then _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}-z ${wl}allextract$convenience ${wl}-z ${wl}defaultextract' else _LT_TAGVAR(whole_archive_flag_spec, $1)='-z allextract$convenience -z defaultextract' fi ;; esac _LT_TAGVAR(link_all_deplibs, $1)=yes ;; sunos4*) if test "x$host_vendor" = xsequent; then # Use $CC to link under sequent, because it throws in some extra .o # files that make .init and .fini sections work. _LT_TAGVAR(archive_cmds, $1)='$CC -G ${wl}-h $soname -o $lib $libobjs $deplibs $compiler_flags' else _LT_TAGVAR(archive_cmds, $1)='$LD -assert pure-text -Bstatic -o $lib $libobjs $deplibs $linker_flags' fi _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' _LT_TAGVAR(hardcode_direct, $1)=yes _LT_TAGVAR(hardcode_minus_L, $1)=yes _LT_TAGVAR(hardcode_shlibpath_var, $1)=no ;; sysv4) case $host_vendor in sni) _LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' _LT_TAGVAR(hardcode_direct, $1)=yes # is this really true??? ;; siemens) ## LD is ld it makes a PLAMLIB ## CC just makes a GrossModule. _LT_TAGVAR(archive_cmds, $1)='$LD -G -o $lib $libobjs $deplibs $linker_flags' _LT_TAGVAR(reload_cmds, $1)='$CC -r -o $output$reload_objs' _LT_TAGVAR(hardcode_direct, $1)=no ;; motorola) _LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' _LT_TAGVAR(hardcode_direct, $1)=no #Motorola manual says yes, but my tests say they lie ;; esac runpath_var='LD_RUN_PATH' _LT_TAGVAR(hardcode_shlibpath_var, $1)=no ;; sysv4.3*) _LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' _LT_TAGVAR(hardcode_shlibpath_var, $1)=no _LT_TAGVAR(export_dynamic_flag_spec, $1)='-Bexport' ;; sysv4*MP*) if test -d /usr/nec; then _LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' _LT_TAGVAR(hardcode_shlibpath_var, $1)=no runpath_var=LD_RUN_PATH hardcode_runpath_var=yes _LT_TAGVAR(ld_shlibs, $1)=yes fi ;; sysv4*uw2* | sysv5OpenUNIX* | sysv5UnixWare7.[[01]].[[10]]* | unixware7* | sco3.2v5.0.[[024]]*) _LT_TAGVAR(no_undefined_flag, $1)='${wl}-z,text' _LT_TAGVAR(archive_cmds_need_lc, $1)=no _LT_TAGVAR(hardcode_shlibpath_var, $1)=no runpath_var='LD_RUN_PATH' if test "$GCC" = yes; then _LT_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' else _LT_TAGVAR(archive_cmds, $1)='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' fi ;; sysv5* | sco3.2v5* | sco5v6*) # Note: We can NOT use -z defs as we might desire, because we do not # link with -lc, and that would cause any symbols used from libc to # always be unresolved, which means just about no library would # ever link correctly. If we're not using GNU ld we use -z text # though, which does catch some bad symbols but isn't as heavy-handed # as -z defs. _LT_TAGVAR(no_undefined_flag, $1)='${wl}-z,text' _LT_TAGVAR(allow_undefined_flag, $1)='${wl}-z,nodefs' _LT_TAGVAR(archive_cmds_need_lc, $1)=no _LT_TAGVAR(hardcode_shlibpath_var, $1)=no _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-R,$libdir' _LT_TAGVAR(hardcode_libdir_separator, $1)=':' _LT_TAGVAR(link_all_deplibs, $1)=yes _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-Bexport' runpath_var='LD_RUN_PATH' if test "$GCC" = yes; then _LT_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' else _LT_TAGVAR(archive_cmds, $1)='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' fi ;; uts4*) _LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' _LT_TAGVAR(hardcode_shlibpath_var, $1)=no ;; *) _LT_TAGVAR(ld_shlibs, $1)=no ;; esac if test x$host_vendor = xsni; then case $host in sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*) _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-Blargedynsym' ;; esac fi fi ]) AC_MSG_RESULT([$_LT_TAGVAR(ld_shlibs, $1)]) test "$_LT_TAGVAR(ld_shlibs, $1)" = no && can_build_shared=no _LT_TAGVAR(with_gnu_ld, $1)=$with_gnu_ld _LT_DECL([], [libext], [0], [Old archive suffix (normally "a")])dnl _LT_DECL([], [shrext_cmds], [1], [Shared library suffix (normally ".so")])dnl _LT_DECL([], [extract_expsyms_cmds], [2], [The commands to extract the exported symbol list from a shared archive]) # # Do we need to explicitly link libc? # case "x$_LT_TAGVAR(archive_cmds_need_lc, $1)" in x|xyes) # Assume -lc should be added _LT_TAGVAR(archive_cmds_need_lc, $1)=yes if test "$enable_shared" = yes && test "$GCC" = yes; then case $_LT_TAGVAR(archive_cmds, $1) in *'~'*) # FIXME: we may have to deal with multi-command sequences. ;; '$CC '*) # Test whether the compiler implicitly links with -lc since on some # systems, -lgcc has to come before -lc. If gcc already passes -lc # to ld, don't add -lc before -lgcc. AC_CACHE_CHECK([whether -lc should be explicitly linked in], [lt_cv_]_LT_TAGVAR(archive_cmds_need_lc, $1), [$RM conftest* echo "$lt_simple_compile_test_code" > conftest.$ac_ext if AC_TRY_EVAL(ac_compile) 2>conftest.err; then soname=conftest lib=conftest libobjs=conftest.$ac_objext deplibs= wl=$_LT_TAGVAR(lt_prog_compiler_wl, $1) pic_flag=$_LT_TAGVAR(lt_prog_compiler_pic, $1) compiler_flags=-v linker_flags=-v verstring= output_objdir=. libname=conftest lt_save_allow_undefined_flag=$_LT_TAGVAR(allow_undefined_flag, $1) _LT_TAGVAR(allow_undefined_flag, $1)= if AC_TRY_EVAL(_LT_TAGVAR(archive_cmds, $1) 2\>\&1 \| $GREP \" -lc \" \>/dev/null 2\>\&1) then lt_cv_[]_LT_TAGVAR(archive_cmds_need_lc, $1)=no else lt_cv_[]_LT_TAGVAR(archive_cmds_need_lc, $1)=yes fi _LT_TAGVAR(allow_undefined_flag, $1)=$lt_save_allow_undefined_flag else cat conftest.err 1>&5 fi $RM conftest* ]) _LT_TAGVAR(archive_cmds_need_lc, $1)=$lt_cv_[]_LT_TAGVAR(archive_cmds_need_lc, $1) ;; esac fi ;; esac _LT_TAGDECL([build_libtool_need_lc], [archive_cmds_need_lc], [0], [Whether or not to add -lc for building shared libraries]) _LT_TAGDECL([allow_libtool_libs_with_static_runtimes], [enable_shared_with_static_runtimes], [0], [Whether or not to disallow shared libs when runtime libs are static]) _LT_TAGDECL([], [export_dynamic_flag_spec], [1], [Compiler flag to allow reflexive dlopens]) _LT_TAGDECL([], [whole_archive_flag_spec], [1], [Compiler flag to generate shared objects directly from archives]) _LT_TAGDECL([], [compiler_needs_object], [1], [Whether the compiler copes with passing no objects directly]) _LT_TAGDECL([], [old_archive_from_new_cmds], [2], [Create an old-style archive from a shared archive]) _LT_TAGDECL([], [old_archive_from_expsyms_cmds], [2], [Create a temporary old-style archive to link instead of a shared archive]) _LT_TAGDECL([], [archive_cmds], [2], [Commands used to build a shared archive]) _LT_TAGDECL([], [archive_expsym_cmds], [2]) _LT_TAGDECL([], [module_cmds], [2], [Commands used to build a loadable module if different from building a shared archive.]) _LT_TAGDECL([], [module_expsym_cmds], [2]) _LT_TAGDECL([], [with_gnu_ld], [1], [Whether we are building with GNU ld or not]) _LT_TAGDECL([], [allow_undefined_flag], [1], [Flag that allows shared libraries with undefined symbols to be built]) _LT_TAGDECL([], [no_undefined_flag], [1], [Flag that enforces no undefined symbols]) _LT_TAGDECL([], [hardcode_libdir_flag_spec], [1], [Flag to hardcode $libdir into a binary during linking. This must work even if $libdir does not exist]) _LT_TAGDECL([], [hardcode_libdir_separator], [1], [Whether we need a single "-rpath" flag with a separated argument]) _LT_TAGDECL([], [hardcode_direct], [0], [Set to "yes" if using DIR/libNAME${shared_ext} during linking hardcodes DIR into the resulting binary]) _LT_TAGDECL([], [hardcode_direct_absolute], [0], [Set to "yes" if using DIR/libNAME${shared_ext} during linking hardcodes DIR into the resulting binary and the resulting library dependency is "absolute", i.e impossible to change by setting ${shlibpath_var} if the library is relocated]) _LT_TAGDECL([], [hardcode_minus_L], [0], [Set to "yes" if using the -LDIR flag during linking hardcodes DIR into the resulting binary]) _LT_TAGDECL([], [hardcode_shlibpath_var], [0], [Set to "yes" if using SHLIBPATH_VAR=DIR during linking hardcodes DIR into the resulting binary]) _LT_TAGDECL([], [hardcode_automatic], [0], [Set to "yes" if building a shared library automatically hardcodes DIR into the library and all subsequent libraries and executables linked against it]) _LT_TAGDECL([], [inherit_rpath], [0], [Set to yes if linker adds runtime paths of dependent libraries to runtime path list]) _LT_TAGDECL([], [link_all_deplibs], [0], [Whether libtool must link a program against all its dependency libraries]) _LT_TAGDECL([], [always_export_symbols], [0], [Set to "yes" if exported symbols are required]) _LT_TAGDECL([], [export_symbols_cmds], [2], [The commands to list exported symbols]) _LT_TAGDECL([], [exclude_expsyms], [1], [Symbols that should not be listed in the preloaded symbols]) _LT_TAGDECL([], [include_expsyms], [1], [Symbols that must always be exported]) _LT_TAGDECL([], [prelink_cmds], [2], [Commands necessary for linking programs (against libraries) with templates]) _LT_TAGDECL([], [postlink_cmds], [2], [Commands necessary for finishing linking programs]) _LT_TAGDECL([], [file_list_spec], [1], [Specify filename containing input files]) dnl FIXME: Not yet implemented dnl _LT_TAGDECL([], [thread_safe_flag_spec], [1], dnl [Compiler flag to generate thread safe objects]) ])# _LT_LINKER_SHLIBS # _LT_LANG_C_CONFIG([TAG]) # ------------------------ # Ensure that the configuration variables for a C compiler are suitably # defined. These variables are subsequently used by _LT_CONFIG to write # the compiler configuration to `libtool'. m4_defun([_LT_LANG_C_CONFIG], [m4_require([_LT_DECL_EGREP])dnl lt_save_CC="$CC" AC_LANG_PUSH(C) # Source file extension for C test sources. ac_ext=c # Object file extension for compiled C test sources. objext=o _LT_TAGVAR(objext, $1)=$objext # Code to be used in simple compile tests lt_simple_compile_test_code="int some_variable = 0;" # Code to be used in simple link tests lt_simple_link_test_code='int main(){return(0);}' _LT_TAG_COMPILER # Save the default compiler, since it gets overwritten when the other # tags are being tested, and _LT_TAGVAR(compiler, []) is a NOP. compiler_DEFAULT=$CC # save warnings/boilerplate of simple test code _LT_COMPILER_BOILERPLATE _LT_LINKER_BOILERPLATE if test -n "$compiler"; then _LT_COMPILER_NO_RTTI($1) _LT_COMPILER_PIC($1) _LT_COMPILER_C_O($1) _LT_COMPILER_FILE_LOCKS($1) _LT_LINKER_SHLIBS($1) _LT_SYS_DYNAMIC_LINKER($1) _LT_LINKER_HARDCODE_LIBPATH($1) LT_SYS_DLOPEN_SELF _LT_CMD_STRIPLIB # Report which library types will actually be built AC_MSG_CHECKING([if libtool supports shared libraries]) AC_MSG_RESULT([$can_build_shared]) AC_MSG_CHECKING([whether to build shared libraries]) test "$can_build_shared" = "no" && enable_shared=no # On AIX, shared libraries and static libraries use the same namespace, and # are all built from PIC. case $host_os in aix3*) test "$enable_shared" = yes && enable_static=no if test -n "$RANLIB"; then archive_cmds="$archive_cmds~\$RANLIB \$lib" postinstall_cmds='$RANLIB $lib' fi ;; aix[[4-9]]*) if test "$host_cpu" != ia64 && test "$aix_use_runtimelinking" = no ; then test "$enable_shared" = yes && enable_static=no fi ;; esac AC_MSG_RESULT([$enable_shared]) AC_MSG_CHECKING([whether to build static libraries]) # Make sure either enable_shared or enable_static is yes. test "$enable_shared" = yes || enable_static=yes AC_MSG_RESULT([$enable_static]) _LT_CONFIG($1) fi AC_LANG_POP CC="$lt_save_CC" ])# _LT_LANG_C_CONFIG # _LT_LANG_CXX_CONFIG([TAG]) # -------------------------- # Ensure that the configuration variables for a C++ compiler are suitably # defined. These variables are subsequently used by _LT_CONFIG to write # the compiler configuration to `libtool'. m4_defun([_LT_LANG_CXX_CONFIG], [m4_require([_LT_FILEUTILS_DEFAULTS])dnl m4_require([_LT_DECL_EGREP])dnl m4_require([_LT_PATH_MANIFEST_TOOL])dnl if test -n "$CXX" && ( test "X$CXX" != "Xno" && ( (test "X$CXX" = "Xg++" && `g++ -v >/dev/null 2>&1` ) || (test "X$CXX" != "Xg++"))) ; then AC_PROG_CXXCPP else _lt_caught_CXX_error=yes fi AC_LANG_PUSH(C++) _LT_TAGVAR(archive_cmds_need_lc, $1)=no _LT_TAGVAR(allow_undefined_flag, $1)= _LT_TAGVAR(always_export_symbols, $1)=no _LT_TAGVAR(archive_expsym_cmds, $1)= _LT_TAGVAR(compiler_needs_object, $1)=no _LT_TAGVAR(export_dynamic_flag_spec, $1)= _LT_TAGVAR(hardcode_direct, $1)=no _LT_TAGVAR(hardcode_direct_absolute, $1)=no _LT_TAGVAR(hardcode_libdir_flag_spec, $1)= _LT_TAGVAR(hardcode_libdir_separator, $1)= _LT_TAGVAR(hardcode_minus_L, $1)=no _LT_TAGVAR(hardcode_shlibpath_var, $1)=unsupported _LT_TAGVAR(hardcode_automatic, $1)=no _LT_TAGVAR(inherit_rpath, $1)=no _LT_TAGVAR(module_cmds, $1)= _LT_TAGVAR(module_expsym_cmds, $1)= _LT_TAGVAR(link_all_deplibs, $1)=unknown _LT_TAGVAR(old_archive_cmds, $1)=$old_archive_cmds _LT_TAGVAR(reload_flag, $1)=$reload_flag _LT_TAGVAR(reload_cmds, $1)=$reload_cmds _LT_TAGVAR(no_undefined_flag, $1)= _LT_TAGVAR(whole_archive_flag_spec, $1)= _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=no # Source file extension for C++ test sources. ac_ext=cpp # Object file extension for compiled C++ test sources. objext=o _LT_TAGVAR(objext, $1)=$objext # No sense in running all these tests if we already determined that # the CXX compiler isn't working. Some variables (like enable_shared) # are currently assumed to apply to all compilers on this platform, # and will be corrupted by setting them based on a non-working compiler. if test "$_lt_caught_CXX_error" != yes; then # Code to be used in simple compile tests lt_simple_compile_test_code="int some_variable = 0;" # Code to be used in simple link tests lt_simple_link_test_code='int main(int, char *[[]]) { return(0); }' # ltmain only uses $CC for tagged configurations so make sure $CC is set. _LT_TAG_COMPILER # save warnings/boilerplate of simple test code _LT_COMPILER_BOILERPLATE _LT_LINKER_BOILERPLATE # Allow CC to be a program name with arguments. lt_save_CC=$CC lt_save_CFLAGS=$CFLAGS lt_save_LD=$LD lt_save_GCC=$GCC GCC=$GXX lt_save_with_gnu_ld=$with_gnu_ld lt_save_path_LD=$lt_cv_path_LD if test -n "${lt_cv_prog_gnu_ldcxx+set}"; then lt_cv_prog_gnu_ld=$lt_cv_prog_gnu_ldcxx else $as_unset lt_cv_prog_gnu_ld fi if test -n "${lt_cv_path_LDCXX+set}"; then lt_cv_path_LD=$lt_cv_path_LDCXX else $as_unset lt_cv_path_LD fi test -z "${LDCXX+set}" || LD=$LDCXX CC=${CXX-"c++"} CFLAGS=$CXXFLAGS compiler=$CC _LT_TAGVAR(compiler, $1)=$CC _LT_CC_BASENAME([$compiler]) if test -n "$compiler"; then # We don't want -fno-exception when compiling C++ code, so set the # no_builtin_flag separately if test "$GXX" = yes; then _LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)=' -fno-builtin' else _LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)= fi if test "$GXX" = yes; then # Set up default GNU C++ configuration LT_PATH_LD # Check if GNU C++ uses GNU ld as the underlying linker, since the # archiving commands below assume that GNU ld is being used. if test "$with_gnu_ld" = yes; then _LT_TAGVAR(archive_cmds, $1)='$CC $pic_flag -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib' _LT_TAGVAR(archive_expsym_cmds, $1)='$CC $pic_flag -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir' _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic' # If archive_cmds runs LD, not CC, wlarc should be empty # XXX I think wlarc can be eliminated in ltcf-cxx, but I need to # investigate it a little bit more. (MM) wlarc='${wl}' # ancient GNU ld didn't support --whole-archive et. al. if eval "`$CC -print-prog-name=ld` --help 2>&1" | $GREP 'no-whole-archive' > /dev/null; then _LT_TAGVAR(whole_archive_flag_spec, $1)="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive' else _LT_TAGVAR(whole_archive_flag_spec, $1)= fi else with_gnu_ld=no wlarc= # A generic and very simple default shared library creation # command for GNU C++ for the case where it uses the native # linker, instead of GNU ld. If possible, this setting should # overridden to take advantage of the native linker features on # the platform it is being used on. _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $lib' fi # Commands to make compiler produce verbose output that lists # what "hidden" libraries, object files and flags are used when # linking a shared library. output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP "\-L"' else GXX=no with_gnu_ld=no wlarc= fi # PORTME: fill in a description of your system's C++ link characteristics AC_MSG_CHECKING([whether the $compiler linker ($LD) supports shared libraries]) _LT_TAGVAR(ld_shlibs, $1)=yes case $host_os in aix3*) # FIXME: insert proper C++ library support _LT_TAGVAR(ld_shlibs, $1)=no ;; aix[[4-9]]*) if test "$host_cpu" = ia64; then # On IA64, the linker does run time linking by default, so we don't # have to do anything special. aix_use_runtimelinking=no exp_sym_flag='-Bexport' no_entry_flag="" else aix_use_runtimelinking=no # Test if we are trying to use run time linking or normal # AIX style linking. If -brtl is somewhere in LDFLAGS, we # need to do runtime linking. case $host_os in aix4.[[23]]|aix4.[[23]].*|aix[[5-9]]*) for ld_flag in $LDFLAGS; do case $ld_flag in *-brtl*) aix_use_runtimelinking=yes break ;; esac done ;; esac exp_sym_flag='-bexport' no_entry_flag='-bnoentry' fi # When large executables or shared objects are built, AIX ld can # have problems creating the table of contents. If linking a library # or program results in "error TOC overflow" add -mminimal-toc to # CXXFLAGS/CFLAGS for g++/gcc. In the cases where that is not # enough to fix the problem, add -Wl,-bbigtoc to LDFLAGS. _LT_TAGVAR(archive_cmds, $1)='' _LT_TAGVAR(hardcode_direct, $1)=yes _LT_TAGVAR(hardcode_direct_absolute, $1)=yes _LT_TAGVAR(hardcode_libdir_separator, $1)=':' _LT_TAGVAR(link_all_deplibs, $1)=yes _LT_TAGVAR(file_list_spec, $1)='${wl}-f,' if test "$GXX" = yes; then case $host_os in aix4.[[012]]|aix4.[[012]].*) # We only want to do this on AIX 4.2 and lower, the check # below for broken collect2 doesn't work under 4.3+ collect2name=`${CC} -print-prog-name=collect2` if test -f "$collect2name" && strings "$collect2name" | $GREP resolve_lib_name >/dev/null then # We have reworked collect2 : else # We have old collect2 _LT_TAGVAR(hardcode_direct, $1)=unsupported # It fails to find uninstalled libraries when the uninstalled # path is not listed in the libpath. Setting hardcode_minus_L # to unsupported forces relinking _LT_TAGVAR(hardcode_minus_L, $1)=yes _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' _LT_TAGVAR(hardcode_libdir_separator, $1)= fi esac shared_flag='-shared' if test "$aix_use_runtimelinking" = yes; then shared_flag="$shared_flag "'${wl}-G' fi else # not using gcc if test "$host_cpu" = ia64; then # VisualAge C++, Version 5.5 for AIX 5L for IA-64, Beta 3 Release # chokes on -Wl,-G. The following line is correct: shared_flag='-G' else if test "$aix_use_runtimelinking" = yes; then shared_flag='${wl}-G' else shared_flag='${wl}-bM:SRE' fi fi fi _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-bexpall' # It seems that -bexpall does not export symbols beginning with # underscore (_), so it is better to generate a list of symbols to # export. _LT_TAGVAR(always_export_symbols, $1)=yes if test "$aix_use_runtimelinking" = yes; then # Warning - without using the other runtime loading flags (-brtl), # -berok will link without error, but may produce a broken library. _LT_TAGVAR(allow_undefined_flag, $1)='-berok' # Determine the default libpath from the value encoded in an empty # executable. _LT_SYS_MODULE_PATH_AIX([$1]) _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-blibpath:$libdir:'"$aix_libpath" _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags `if test "x${allow_undefined_flag}" != "x"; then func_echo_all "${wl}${allow_undefined_flag}"; else :; fi` '"\${wl}$exp_sym_flag:\$export_symbols $shared_flag" else if test "$host_cpu" = ia64; then _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-R $libdir:/usr/lib:/lib' _LT_TAGVAR(allow_undefined_flag, $1)="-z nodefs" _LT_TAGVAR(archive_expsym_cmds, $1)="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags ${wl}${allow_undefined_flag} '"\${wl}$exp_sym_flag:\$export_symbols" else # Determine the default libpath from the value encoded in an # empty executable. _LT_SYS_MODULE_PATH_AIX([$1]) _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-blibpath:$libdir:'"$aix_libpath" # Warning - without using the other run time loading flags, # -berok will link without error, but may produce a broken library. _LT_TAGVAR(no_undefined_flag, $1)=' ${wl}-bernotok' _LT_TAGVAR(allow_undefined_flag, $1)=' ${wl}-berok' if test "$with_gnu_ld" = yes; then # We only use this code for GNU lds that support --whole-archive. _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive$convenience ${wl}--no-whole-archive' else # Exported symbols can be pulled into shared objects from archives _LT_TAGVAR(whole_archive_flag_spec, $1)='$convenience' fi _LT_TAGVAR(archive_cmds_need_lc, $1)=yes # This is similar to how AIX traditionally builds its shared # libraries. _LT_TAGVAR(archive_expsym_cmds, $1)="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs ${wl}-bnoentry $compiler_flags ${wl}-bE:$export_symbols${allow_undefined_flag}~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$soname' fi fi ;; beos*) if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then _LT_TAGVAR(allow_undefined_flag, $1)=unsupported # Joseph Beckenbach says some releases of gcc # support --undefined. This deserves some investigation. FIXME _LT_TAGVAR(archive_cmds, $1)='$CC -nostart $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' else _LT_TAGVAR(ld_shlibs, $1)=no fi ;; chorus*) case $cc_basename in *) # FIXME: insert proper C++ library support _LT_TAGVAR(ld_shlibs, $1)=no ;; esac ;; cygwin* | mingw* | pw32* | cegcc*) case $GXX,$cc_basename in ,cl* | no,cl*) # Native MSVC # hardcode_libdir_flag_spec is actually meaningless, as there is # no search path for DLLs. _LT_TAGVAR(hardcode_libdir_flag_spec, $1)=' ' _LT_TAGVAR(allow_undefined_flag, $1)=unsupported _LT_TAGVAR(always_export_symbols, $1)=yes _LT_TAGVAR(file_list_spec, $1)='@' # Tell ltmain to make .lib files, not .a files. libext=lib # Tell ltmain to make .dll files, not .so files. shrext_cmds=".dll" # FIXME: Setting linknames here is a bad hack. _LT_TAGVAR(archive_cmds, $1)='$CC -o $output_objdir/$soname $libobjs $compiler_flags $deplibs -Wl,-dll~linknames=' _LT_TAGVAR(archive_expsym_cmds, $1)='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then $SED -n -e 's/\\\\\\\(.*\\\\\\\)/-link\\\ -EXPORT:\\\\\\\1/' -e '1\\\!p' < $export_symbols > $output_objdir/$soname.exp; else $SED -e 's/\\\\\\\(.*\\\\\\\)/-link\\\ -EXPORT:\\\\\\\1/' < $export_symbols > $output_objdir/$soname.exp; fi~ $CC -o $tool_output_objdir$soname $libobjs $compiler_flags $deplibs "@$tool_output_objdir$soname.exp" -Wl,-DLL,-IMPLIB:"$tool_output_objdir$libname.dll.lib"~ linknames=' # The linker will not automatically build a static lib if we build a DLL. # _LT_TAGVAR(old_archive_from_new_cmds, $1)='true' _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes # Don't use ranlib _LT_TAGVAR(old_postinstall_cmds, $1)='chmod 644 $oldlib' _LT_TAGVAR(postlink_cmds, $1)='lt_outputfile="@OUTPUT@"~ lt_tool_outputfile="@TOOL_OUTPUT@"~ case $lt_outputfile in *.exe|*.EXE) ;; *) lt_outputfile="$lt_outputfile.exe" lt_tool_outputfile="$lt_tool_outputfile.exe" ;; esac~ func_to_tool_file "$lt_outputfile"~ if test "$MANIFEST_TOOL" != ":" && test -f "$lt_outputfile.manifest"; then $MANIFEST_TOOL -manifest "$lt_tool_outputfile.manifest" -outputresource:"$lt_tool_outputfile" || exit 1; $RM "$lt_outputfile.manifest"; fi' ;; *) # g++ # _LT_TAGVAR(hardcode_libdir_flag_spec, $1) is actually meaningless, # as there is no search path for DLLs. _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-all-symbols' _LT_TAGVAR(allow_undefined_flag, $1)=unsupported _LT_TAGVAR(always_export_symbols, $1)=no _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes if $LD --help 2>&1 | $GREP 'auto-import' > /dev/null; then _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib' # If the export-symbols file already is a .def file (1st line # is EXPORTS), use it as is; otherwise, prepend... _LT_TAGVAR(archive_expsym_cmds, $1)='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then cp $export_symbols $output_objdir/$soname.def; else echo EXPORTS > $output_objdir/$soname.def; cat $export_symbols >> $output_objdir/$soname.def; fi~ $CC -shared -nostdlib $output_objdir/$soname.def $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib' else _LT_TAGVAR(ld_shlibs, $1)=no fi ;; esac ;; darwin* | rhapsody*) _LT_DARWIN_LINKER_FEATURES($1) ;; dgux*) case $cc_basename in ec++*) # FIXME: insert proper C++ library support _LT_TAGVAR(ld_shlibs, $1)=no ;; ghcx*) # Green Hills C++ Compiler # FIXME: insert proper C++ library support _LT_TAGVAR(ld_shlibs, $1)=no ;; *) # FIXME: insert proper C++ library support _LT_TAGVAR(ld_shlibs, $1)=no ;; esac ;; freebsd2.*) # C++ shared libraries reported to be fairly broken before # switch to ELF _LT_TAGVAR(ld_shlibs, $1)=no ;; freebsd-elf*) _LT_TAGVAR(archive_cmds_need_lc, $1)=no ;; freebsd* | dragonfly*) # FreeBSD 3 and later use GNU C++ and GNU ld with standard ELF # conventions _LT_TAGVAR(ld_shlibs, $1)=yes ;; gnu*) ;; haiku*) _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' _LT_TAGVAR(link_all_deplibs, $1)=yes ;; hpux9*) _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir' _LT_TAGVAR(hardcode_libdir_separator, $1)=: _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E' _LT_TAGVAR(hardcode_direct, $1)=yes _LT_TAGVAR(hardcode_minus_L, $1)=yes # Not in the search PATH, # but as the default # location of the library. case $cc_basename in CC*) # FIXME: insert proper C++ library support _LT_TAGVAR(ld_shlibs, $1)=no ;; aCC*) _LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/$soname~$CC -b ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib' # Commands to make compiler produce verbose output that lists # what "hidden" libraries, object files and flags are used when # linking a shared library. # # There doesn't appear to be a way to prevent this compiler from # explicitly linking system object files so we need to strip them # from the output so that they don't get included in the library # dependencies. output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | $EGREP "\-L"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"' ;; *) if test "$GXX" = yes; then _LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/$soname~$CC -shared -nostdlib $pic_flag ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib' else # FIXME: insert proper C++ library support _LT_TAGVAR(ld_shlibs, $1)=no fi ;; esac ;; hpux10*|hpux11*) if test $with_gnu_ld = no; then _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir' _LT_TAGVAR(hardcode_libdir_separator, $1)=: case $host_cpu in hppa*64*|ia64*) ;; *) _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E' ;; esac fi case $host_cpu in hppa*64*|ia64*) _LT_TAGVAR(hardcode_direct, $1)=no _LT_TAGVAR(hardcode_shlibpath_var, $1)=no ;; *) _LT_TAGVAR(hardcode_direct, $1)=yes _LT_TAGVAR(hardcode_direct_absolute, $1)=yes _LT_TAGVAR(hardcode_minus_L, $1)=yes # Not in the search PATH, # but as the default # location of the library. ;; esac case $cc_basename in CC*) # FIXME: insert proper C++ library support _LT_TAGVAR(ld_shlibs, $1)=no ;; aCC*) case $host_cpu in hppa*64*) _LT_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' ;; ia64*) _LT_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' ;; *) _LT_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' ;; esac # Commands to make compiler produce verbose output that lists # what "hidden" libraries, object files and flags are used when # linking a shared library. # # There doesn't appear to be a way to prevent this compiler from # explicitly linking system object files so we need to strip them # from the output so that they don't get included in the library # dependencies. output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | $GREP "\-L"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"' ;; *) if test "$GXX" = yes; then if test $with_gnu_ld = no; then case $host_cpu in hppa*64*) _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib -fPIC ${wl}+h ${wl}$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' ;; ia64*) _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $pic_flag ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' ;; *) _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $pic_flag ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' ;; esac fi else # FIXME: insert proper C++ library support _LT_TAGVAR(ld_shlibs, $1)=no fi ;; esac ;; interix[[3-9]]*) _LT_TAGVAR(hardcode_direct, $1)=no _LT_TAGVAR(hardcode_shlibpath_var, $1)=no _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir' _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E' # Hack: On Interix 3.x, we cannot compile PIC because of a broken gcc. # Instead, shared libraries are loaded at an image base (0x10000000 by # default) and relocated if they conflict, which is a slow very memory # consuming and fragmenting process. To avoid this, we pick a random, # 256 KiB-aligned image base between 0x50000000 and 0x6FFC0000 at link # time. Moving up from 0x10000000 also allows more sbrk(2) space. _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib' _LT_TAGVAR(archive_expsym_cmds, $1)='sed "s,^,_," $export_symbols >$output_objdir/$soname.expsym~$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--retain-symbols-file,$output_objdir/$soname.expsym ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib' ;; irix5* | irix6*) case $cc_basename in CC*) # SGI C++ _LT_TAGVAR(archive_cmds, $1)='$CC -shared -all -multigot $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib' # Archives containing C++ object files must be created using # "CC -ar", where "CC" is the IRIX C++ compiler. This is # necessary to make sure instantiated templates are included # in the archive. _LT_TAGVAR(old_archive_cmds, $1)='$CC -ar -WR,-u -o $oldlib $oldobjs' ;; *) if test "$GXX" = yes; then if test "$with_gnu_ld" = no; then _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib' else _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` -o $lib' fi fi _LT_TAGVAR(link_all_deplibs, $1)=yes ;; esac _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir' _LT_TAGVAR(hardcode_libdir_separator, $1)=: _LT_TAGVAR(inherit_rpath, $1)=yes ;; linux* | k*bsd*-gnu | kopensolaris*-gnu) case $cc_basename in KCC*) # Kuck and Associates, Inc. (KAI) C++ Compiler # KCC will only create a shared library if the output file # ends with ".so" (or ".sl" for HP-UX), so rename the library # to its proper name (with version) after linking. _LT_TAGVAR(archive_cmds, $1)='tempext=`echo $shared_ext | $SED -e '\''s/\([[^()0-9A-Za-z{}]]\)/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib; mv \$templib $lib' _LT_TAGVAR(archive_expsym_cmds, $1)='tempext=`echo $shared_ext | $SED -e '\''s/\([[^()0-9A-Za-z{}]]\)/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib ${wl}-retain-symbols-file,$export_symbols; mv \$templib $lib' # Commands to make compiler produce verbose output that lists # what "hidden" libraries, object files and flags are used when # linking a shared library. # # There doesn't appear to be a way to prevent this compiler from # explicitly linking system object files so we need to strip them # from the output so that they don't get included in the library # dependencies. output_verbose_link_cmd='templist=`$CC $CFLAGS -v conftest.$objext -o libconftest$shared_ext 2>&1 | $GREP "ld"`; rm -f libconftest$shared_ext; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"' _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir' _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic' # Archives containing C++ object files must be created using # "CC -Bstatic", where "CC" is the KAI C++ compiler. _LT_TAGVAR(old_archive_cmds, $1)='$CC -Bstatic -o $oldlib $oldobjs' ;; icpc* | ecpc* ) # Intel C++ with_gnu_ld=yes # version 8.0 and above of icpc choke on multiply defined symbols # if we add $predep_objects and $postdep_objects, however 7.1 and # earlier do not add the objects themselves. case `$CC -V 2>&1` in *"Version 7."*) _LT_TAGVAR(archive_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib' _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' ;; *) # Version 8.0 or newer tmp_idyn= case $host_cpu in ia64*) tmp_idyn=' -i_dynamic';; esac _LT_TAGVAR(archive_cmds, $1)='$CC -shared'"$tmp_idyn"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared'"$tmp_idyn"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' ;; esac _LT_TAGVAR(archive_cmds_need_lc, $1)=no _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir' _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic' _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive$convenience ${wl}--no-whole-archive' ;; pgCC* | pgcpp*) # Portland Group C++ compiler case `$CC -V` in *pgCC\ [[1-5]].* | *pgcpp\ [[1-5]].*) _LT_TAGVAR(prelink_cmds, $1)='tpldir=Template.dir~ rm -rf $tpldir~ $CC --prelink_objects --instantiation_dir $tpldir $objs $libobjs $compile_deplibs~ compile_command="$compile_command `find $tpldir -name \*.o | sort | $NL2SP`"' _LT_TAGVAR(old_archive_cmds, $1)='tpldir=Template.dir~ rm -rf $tpldir~ $CC --prelink_objects --instantiation_dir $tpldir $oldobjs$old_deplibs~ $AR $AR_FLAGS $oldlib$oldobjs$old_deplibs `find $tpldir -name \*.o | sort | $NL2SP`~ $RANLIB $oldlib' _LT_TAGVAR(archive_cmds, $1)='tpldir=Template.dir~ rm -rf $tpldir~ $CC --prelink_objects --instantiation_dir $tpldir $predep_objects $libobjs $deplibs $convenience $postdep_objects~ $CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | sort | $NL2SP` $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname -o $lib' _LT_TAGVAR(archive_expsym_cmds, $1)='tpldir=Template.dir~ rm -rf $tpldir~ $CC --prelink_objects --instantiation_dir $tpldir $predep_objects $libobjs $deplibs $convenience $postdep_objects~ $CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | sort | $NL2SP` $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname ${wl}-retain-symbols-file ${wl}$export_symbols -o $lib' ;; *) # Version 6 and above use weak symbols _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname -o $lib' _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname ${wl}-retain-symbols-file ${wl}$export_symbols -o $lib' ;; esac _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}--rpath ${wl}$libdir' _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic' _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive' ;; cxx*) # Compaq C++ _LT_TAGVAR(archive_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib' _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib ${wl}-retain-symbols-file $wl$export_symbols' runpath_var=LD_RUN_PATH _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-rpath $libdir' _LT_TAGVAR(hardcode_libdir_separator, $1)=: # Commands to make compiler produce verbose output that lists # what "hidden" libraries, object files and flags are used when # linking a shared library. # # There doesn't appear to be a way to prevent this compiler from # explicitly linking system object files so we need to strip them # from the output so that they don't get included in the library # dependencies. output_verbose_link_cmd='templist=`$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP "ld"`; templist=`func_echo_all "$templist" | $SED "s/\(^.*ld.*\)\( .*ld .*$\)/\1/"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "X$list" | $Xsed' ;; xl* | mpixl* | bgxl*) # IBM XL 8.0 on PPC, with GNU ld _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir' _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic' _LT_TAGVAR(archive_cmds, $1)='$CC -qmkshrobj $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' if test "x$supports_anon_versioning" = xyes; then _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $output_objdir/$libname.ver~ cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~ echo "local: *; };" >> $output_objdir/$libname.ver~ $CC -qmkshrobj $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-version-script ${wl}$output_objdir/$libname.ver -o $lib' fi ;; *) case `$CC -V 2>&1 | sed 5q` in *Sun\ C*) # Sun C++ 5.9 _LT_TAGVAR(no_undefined_flag, $1)=' -zdefs' _LT_TAGVAR(archive_cmds, $1)='$CC -G${allow_undefined_flag} -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -G${allow_undefined_flag} -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-retain-symbols-file ${wl}$export_symbols' _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir' _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive`new_convenience=; for conv in $convenience\"\"; do test -z \"$conv\" || new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive' _LT_TAGVAR(compiler_needs_object, $1)=yes # Not sure whether something based on # $CC $CFLAGS -v conftest.$objext -o libconftest$shared_ext 2>&1 # would be better. output_verbose_link_cmd='func_echo_all' # Archives containing C++ object files must be created using # "CC -xar", where "CC" is the Sun C++ compiler. This is # necessary to make sure instantiated templates are included # in the archive. _LT_TAGVAR(old_archive_cmds, $1)='$CC -xar -o $oldlib $oldobjs' ;; esac ;; esac ;; lynxos*) # FIXME: insert proper C++ library support _LT_TAGVAR(ld_shlibs, $1)=no ;; m88k*) # FIXME: insert proper C++ library support _LT_TAGVAR(ld_shlibs, $1)=no ;; mvs*) case $cc_basename in cxx*) # FIXME: insert proper C++ library support _LT_TAGVAR(ld_shlibs, $1)=no ;; *) # FIXME: insert proper C++ library support _LT_TAGVAR(ld_shlibs, $1)=no ;; esac ;; netbsd*) if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then _LT_TAGVAR(archive_cmds, $1)='$LD -Bshareable -o $lib $predep_objects $libobjs $deplibs $postdep_objects $linker_flags' wlarc= _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir' _LT_TAGVAR(hardcode_direct, $1)=yes _LT_TAGVAR(hardcode_shlibpath_var, $1)=no fi # Workaround some broken pre-1.5 toolchains output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP conftest.$objext | $SED -e "s:-lgcc -lc -lgcc::"' ;; *nto* | *qnx*) _LT_TAGVAR(ld_shlibs, $1)=yes ;; openbsd2*) # C++ shared libraries are fairly broken _LT_TAGVAR(ld_shlibs, $1)=no ;; openbsd*) if test -f /usr/libexec/ld.so; then _LT_TAGVAR(hardcode_direct, $1)=yes _LT_TAGVAR(hardcode_shlibpath_var, $1)=no _LT_TAGVAR(hardcode_direct_absolute, $1)=yes _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $lib' _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir' if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-retain-symbols-file,$export_symbols -o $lib' _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E' _LT_TAGVAR(whole_archive_flag_spec, $1)="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive' fi output_verbose_link_cmd=func_echo_all else _LT_TAGVAR(ld_shlibs, $1)=no fi ;; osf3* | osf4* | osf5*) case $cc_basename in KCC*) # Kuck and Associates, Inc. (KAI) C++ Compiler # KCC will only create a shared library if the output file # ends with ".so" (or ".sl" for HP-UX), so rename the library # to its proper name (with version) after linking. _LT_TAGVAR(archive_cmds, $1)='tempext=`echo $shared_ext | $SED -e '\''s/\([[^()0-9A-Za-z{}]]\)/\\\\\1/g'\''`; templib=`echo "$lib" | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib; mv \$templib $lib' _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir' _LT_TAGVAR(hardcode_libdir_separator, $1)=: # Archives containing C++ object files must be created using # the KAI C++ compiler. case $host in osf3*) _LT_TAGVAR(old_archive_cmds, $1)='$CC -Bstatic -o $oldlib $oldobjs' ;; *) _LT_TAGVAR(old_archive_cmds, $1)='$CC -o $oldlib $oldobjs' ;; esac ;; RCC*) # Rational C++ 2.4.1 # FIXME: insert proper C++ library support _LT_TAGVAR(ld_shlibs, $1)=no ;; cxx*) case $host in osf3*) _LT_TAGVAR(allow_undefined_flag, $1)=' ${wl}-expect_unresolved ${wl}\*' _LT_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $soname `test -n "$verstring" && func_echo_all "${wl}-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib' _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir' ;; *) _LT_TAGVAR(allow_undefined_flag, $1)=' -expect_unresolved \*' _LT_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -msym -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib' _LT_TAGVAR(archive_expsym_cmds, $1)='for i in `cat $export_symbols`; do printf "%s %s\\n" -exported_symbol "\$i" >> $lib.exp; done~ echo "-hidden">> $lib.exp~ $CC -shared$allow_undefined_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -msym -soname $soname ${wl}-input ${wl}$lib.exp `test -n "$verstring" && $ECHO "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib~ $RM $lib.exp' _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-rpath $libdir' ;; esac _LT_TAGVAR(hardcode_libdir_separator, $1)=: # Commands to make compiler produce verbose output that lists # what "hidden" libraries, object files and flags are used when # linking a shared library. # # There doesn't appear to be a way to prevent this compiler from # explicitly linking system object files so we need to strip them # from the output so that they don't get included in the library # dependencies. output_verbose_link_cmd='templist=`$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP "ld" | $GREP -v "ld:"`; templist=`func_echo_all "$templist" | $SED "s/\(^.*ld.*\)\( .*ld.*$\)/\1/"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"' ;; *) if test "$GXX" = yes && test "$with_gnu_ld" = no; then _LT_TAGVAR(allow_undefined_flag, $1)=' ${wl}-expect_unresolved ${wl}\*' case $host in osf3*) _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib ${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib' ;; *) _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -nostdlib ${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-msym ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib' ;; esac _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir' _LT_TAGVAR(hardcode_libdir_separator, $1)=: # Commands to make compiler produce verbose output that lists # what "hidden" libraries, object files and flags are used when # linking a shared library. output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP "\-L"' else # FIXME: insert proper C++ library support _LT_TAGVAR(ld_shlibs, $1)=no fi ;; esac ;; psos*) # FIXME: insert proper C++ library support _LT_TAGVAR(ld_shlibs, $1)=no ;; sunos4*) case $cc_basename in CC*) # Sun C++ 4.x # FIXME: insert proper C++ library support _LT_TAGVAR(ld_shlibs, $1)=no ;; lcc*) # Lucid # FIXME: insert proper C++ library support _LT_TAGVAR(ld_shlibs, $1)=no ;; *) # FIXME: insert proper C++ library support _LT_TAGVAR(ld_shlibs, $1)=no ;; esac ;; solaris*) case $cc_basename in CC* | sunCC*) # Sun C++ 4.2, 5.x and Centerline C++ _LT_TAGVAR(archive_cmds_need_lc,$1)=yes _LT_TAGVAR(no_undefined_flag, $1)=' -zdefs' _LT_TAGVAR(archive_cmds, $1)='$CC -G${allow_undefined_flag} -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~ $CC -G${allow_undefined_flag} ${wl}-M ${wl}$lib.exp -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$RM $lib.exp' _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir' _LT_TAGVAR(hardcode_shlibpath_var, $1)=no case $host_os in solaris2.[[0-5]] | solaris2.[[0-5]].*) ;; *) # The compiler driver will combine and reorder linker options, # but understands `-z linker_flag'. # Supported since Solaris 2.6 (maybe 2.5.1?) _LT_TAGVAR(whole_archive_flag_spec, $1)='-z allextract$convenience -z defaultextract' ;; esac _LT_TAGVAR(link_all_deplibs, $1)=yes output_verbose_link_cmd='func_echo_all' # Archives containing C++ object files must be created using # "CC -xar", where "CC" is the Sun C++ compiler. This is # necessary to make sure instantiated templates are included # in the archive. _LT_TAGVAR(old_archive_cmds, $1)='$CC -xar -o $oldlib $oldobjs' ;; gcx*) # Green Hills C++ Compiler _LT_TAGVAR(archive_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-h $wl$soname -o $lib' # The C++ compiler must be used to create the archive. _LT_TAGVAR(old_archive_cmds, $1)='$CC $LDFLAGS -archive -o $oldlib $oldobjs' ;; *) # GNU C++ compiler with Solaris linker if test "$GXX" = yes && test "$with_gnu_ld" = no; then _LT_TAGVAR(no_undefined_flag, $1)=' ${wl}-z ${wl}defs' if $CC --version | $GREP -v '^2\.7' > /dev/null; then _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -nostdlib $LDFLAGS $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-h $wl$soname -o $lib' _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~ $CC -shared $pic_flag -nostdlib ${wl}-M $wl$lib.exp -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$RM $lib.exp' # Commands to make compiler produce verbose output that lists # what "hidden" libraries, object files and flags are used when # linking a shared library. output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP "\-L"' else # g++ 2.7 appears to require `-G' NOT `-shared' on this # platform. _LT_TAGVAR(archive_cmds, $1)='$CC -G -nostdlib $LDFLAGS $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-h $wl$soname -o $lib' _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~ $CC -G -nostdlib ${wl}-M $wl$lib.exp -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$RM $lib.exp' # Commands to make compiler produce verbose output that lists # what "hidden" libraries, object files and flags are used when # linking a shared library. output_verbose_link_cmd='$CC -G $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP "\-L"' fi _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-R $wl$libdir' case $host_os in solaris2.[[0-5]] | solaris2.[[0-5]].*) ;; *) _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}-z ${wl}allextract$convenience ${wl}-z ${wl}defaultextract' ;; esac fi ;; esac ;; sysv4*uw2* | sysv5OpenUNIX* | sysv5UnixWare7.[[01]].[[10]]* | unixware7* | sco3.2v5.0.[[024]]*) _LT_TAGVAR(no_undefined_flag, $1)='${wl}-z,text' _LT_TAGVAR(archive_cmds_need_lc, $1)=no _LT_TAGVAR(hardcode_shlibpath_var, $1)=no runpath_var='LD_RUN_PATH' case $cc_basename in CC*) _LT_TAGVAR(archive_cmds, $1)='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' ;; *) _LT_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' ;; esac ;; sysv5* | sco3.2v5* | sco5v6*) # Note: We can NOT use -z defs as we might desire, because we do not # link with -lc, and that would cause any symbols used from libc to # always be unresolved, which means just about no library would # ever link correctly. If we're not using GNU ld we use -z text # though, which does catch some bad symbols but isn't as heavy-handed # as -z defs. _LT_TAGVAR(no_undefined_flag, $1)='${wl}-z,text' _LT_TAGVAR(allow_undefined_flag, $1)='${wl}-z,nodefs' _LT_TAGVAR(archive_cmds_need_lc, $1)=no _LT_TAGVAR(hardcode_shlibpath_var, $1)=no _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-R,$libdir' _LT_TAGVAR(hardcode_libdir_separator, $1)=':' _LT_TAGVAR(link_all_deplibs, $1)=yes _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-Bexport' runpath_var='LD_RUN_PATH' case $cc_basename in CC*) _LT_TAGVAR(archive_cmds, $1)='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' _LT_TAGVAR(old_archive_cmds, $1)='$CC -Tprelink_objects $oldobjs~ '"$_LT_TAGVAR(old_archive_cmds, $1)" _LT_TAGVAR(reload_cmds, $1)='$CC -Tprelink_objects $reload_objs~ '"$_LT_TAGVAR(reload_cmds, $1)" ;; *) _LT_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' ;; esac ;; tandem*) case $cc_basename in NCC*) # NonStop-UX NCC 3.20 # FIXME: insert proper C++ library support _LT_TAGVAR(ld_shlibs, $1)=no ;; *) # FIXME: insert proper C++ library support _LT_TAGVAR(ld_shlibs, $1)=no ;; esac ;; vxworks*) # FIXME: insert proper C++ library support _LT_TAGVAR(ld_shlibs, $1)=no ;; *) # FIXME: insert proper C++ library support _LT_TAGVAR(ld_shlibs, $1)=no ;; esac AC_MSG_RESULT([$_LT_TAGVAR(ld_shlibs, $1)]) test "$_LT_TAGVAR(ld_shlibs, $1)" = no && can_build_shared=no _LT_TAGVAR(GCC, $1)="$GXX" _LT_TAGVAR(LD, $1)="$LD" ## CAVEAT EMPTOR: ## There is no encapsulation within the following macros, do not change ## the running order or otherwise move them around unless you know exactly ## what you are doing... _LT_SYS_HIDDEN_LIBDEPS($1) _LT_COMPILER_PIC($1) _LT_COMPILER_C_O($1) _LT_COMPILER_FILE_LOCKS($1) _LT_LINKER_SHLIBS($1) _LT_SYS_DYNAMIC_LINKER($1) _LT_LINKER_HARDCODE_LIBPATH($1) _LT_CONFIG($1) fi # test -n "$compiler" CC=$lt_save_CC CFLAGS=$lt_save_CFLAGS LDCXX=$LD LD=$lt_save_LD GCC=$lt_save_GCC with_gnu_ld=$lt_save_with_gnu_ld lt_cv_path_LDCXX=$lt_cv_path_LD lt_cv_path_LD=$lt_save_path_LD lt_cv_prog_gnu_ldcxx=$lt_cv_prog_gnu_ld lt_cv_prog_gnu_ld=$lt_save_with_gnu_ld fi # test "$_lt_caught_CXX_error" != yes AC_LANG_POP ])# _LT_LANG_CXX_CONFIG # _LT_FUNC_STRIPNAME_CNF # ---------------------- # func_stripname_cnf prefix suffix name # strip PREFIX and SUFFIX off of NAME. # PREFIX and SUFFIX must not contain globbing or regex special # characters, hashes, percent signs, but SUFFIX may contain a leading # dot (in which case that matches only a dot). # # This function is identical to the (non-XSI) version of func_stripname, # except this one can be used by m4 code that may be executed by configure, # rather than the libtool script. m4_defun([_LT_FUNC_STRIPNAME_CNF],[dnl AC_REQUIRE([_LT_DECL_SED]) AC_REQUIRE([_LT_PROG_ECHO_BACKSLASH]) func_stripname_cnf () { case ${2} in .*) func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%\\\\${2}\$%%"`;; *) func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%${2}\$%%"`;; esac } # func_stripname_cnf ])# _LT_FUNC_STRIPNAME_CNF # _LT_SYS_HIDDEN_LIBDEPS([TAGNAME]) # --------------------------------- # Figure out "hidden" library dependencies from verbose # compiler output when linking a shared library. # Parse the compiler output and extract the necessary # objects, libraries and library flags. m4_defun([_LT_SYS_HIDDEN_LIBDEPS], [m4_require([_LT_FILEUTILS_DEFAULTS])dnl AC_REQUIRE([_LT_FUNC_STRIPNAME_CNF])dnl # Dependencies to place before and after the object being linked: _LT_TAGVAR(predep_objects, $1)= _LT_TAGVAR(postdep_objects, $1)= _LT_TAGVAR(predeps, $1)= _LT_TAGVAR(postdeps, $1)= _LT_TAGVAR(compiler_lib_search_path, $1)= dnl we can't use the lt_simple_compile_test_code here, dnl because it contains code intended for an executable, dnl not a library. It's possible we should let each dnl tag define a new lt_????_link_test_code variable, dnl but it's only used here... m4_if([$1], [], [cat > conftest.$ac_ext <<_LT_EOF int a; void foo (void) { a = 0; } _LT_EOF ], [$1], [CXX], [cat > conftest.$ac_ext <<_LT_EOF class Foo { public: Foo (void) { a = 0; } private: int a; }; _LT_EOF ], [$1], [F77], [cat > conftest.$ac_ext <<_LT_EOF subroutine foo implicit none integer*4 a a=0 return end _LT_EOF ], [$1], [FC], [cat > conftest.$ac_ext <<_LT_EOF subroutine foo implicit none integer a a=0 return end _LT_EOF ], [$1], [GCJ], [cat > conftest.$ac_ext <<_LT_EOF public class foo { private int a; public void bar (void) { a = 0; } }; _LT_EOF ], [$1], [GO], [cat > conftest.$ac_ext <<_LT_EOF package foo func foo() { } _LT_EOF ]) _lt_libdeps_save_CFLAGS=$CFLAGS case "$CC $CFLAGS " in #( *\ -flto*\ *) CFLAGS="$CFLAGS -fno-lto" ;; *\ -fwhopr*\ *) CFLAGS="$CFLAGS -fno-whopr" ;; *\ -fuse-linker-plugin*\ *) CFLAGS="$CFLAGS -fno-use-linker-plugin" ;; esac dnl Parse the compiler output and extract the necessary dnl objects, libraries and library flags. if AC_TRY_EVAL(ac_compile); then # Parse the compiler output and extract the necessary # objects, libraries and library flags. # Sentinel used to keep track of whether or not we are before # the conftest object file. pre_test_object_deps_done=no for p in `eval "$output_verbose_link_cmd"`; do case ${prev}${p} in -L* | -R* | -l*) # Some compilers place space between "-{L,R}" and the path. # Remove the space. if test $p = "-L" || test $p = "-R"; then prev=$p continue fi # Expand the sysroot to ease extracting the directories later. if test -z "$prev"; then case $p in -L*) func_stripname_cnf '-L' '' "$p"; prev=-L; p=$func_stripname_result ;; -R*) func_stripname_cnf '-R' '' "$p"; prev=-R; p=$func_stripname_result ;; -l*) func_stripname_cnf '-l' '' "$p"; prev=-l; p=$func_stripname_result ;; esac fi case $p in =*) func_stripname_cnf '=' '' "$p"; p=$lt_sysroot$func_stripname_result ;; esac if test "$pre_test_object_deps_done" = no; then case ${prev} in -L | -R) # Internal compiler library paths should come after those # provided the user. The postdeps already come after the # user supplied libs so there is no need to process them. if test -z "$_LT_TAGVAR(compiler_lib_search_path, $1)"; then _LT_TAGVAR(compiler_lib_search_path, $1)="${prev}${p}" else _LT_TAGVAR(compiler_lib_search_path, $1)="${_LT_TAGVAR(compiler_lib_search_path, $1)} ${prev}${p}" fi ;; # The "-l" case would never come before the object being # linked, so don't bother handling this case. esac else if test -z "$_LT_TAGVAR(postdeps, $1)"; then _LT_TAGVAR(postdeps, $1)="${prev}${p}" else _LT_TAGVAR(postdeps, $1)="${_LT_TAGVAR(postdeps, $1)} ${prev}${p}" fi fi prev= ;; *.lto.$objext) ;; # Ignore GCC LTO objects *.$objext) # This assumes that the test object file only shows up # once in the compiler output. if test "$p" = "conftest.$objext"; then pre_test_object_deps_done=yes continue fi if test "$pre_test_object_deps_done" = no; then if test -z "$_LT_TAGVAR(predep_objects, $1)"; then _LT_TAGVAR(predep_objects, $1)="$p" else _LT_TAGVAR(predep_objects, $1)="$_LT_TAGVAR(predep_objects, $1) $p" fi else if test -z "$_LT_TAGVAR(postdep_objects, $1)"; then _LT_TAGVAR(postdep_objects, $1)="$p" else _LT_TAGVAR(postdep_objects, $1)="$_LT_TAGVAR(postdep_objects, $1) $p" fi fi ;; *) ;; # Ignore the rest. esac done # Clean up. rm -f a.out a.exe else echo "libtool.m4: error: problem compiling $1 test program" fi $RM -f confest.$objext CFLAGS=$_lt_libdeps_save_CFLAGS # PORTME: override above test on systems where it is broken m4_if([$1], [CXX], [case $host_os in interix[[3-9]]*) # Interix 3.5 installs completely hosed .la files for C++, so rather than # hack all around it, let's just trust "g++" to DTRT. _LT_TAGVAR(predep_objects,$1)= _LT_TAGVAR(postdep_objects,$1)= _LT_TAGVAR(postdeps,$1)= ;; linux*) case `$CC -V 2>&1 | sed 5q` in *Sun\ C*) # Sun C++ 5.9 # The more standards-conforming stlport4 library is # incompatible with the Cstd library. Avoid specifying # it if it's in CXXFLAGS. Ignore libCrun as # -library=stlport4 depends on it. case " $CXX $CXXFLAGS " in *" -library=stlport4 "*) solaris_use_stlport4=yes ;; esac if test "$solaris_use_stlport4" != yes; then _LT_TAGVAR(postdeps,$1)='-library=Cstd -library=Crun' fi ;; esac ;; solaris*) case $cc_basename in CC* | sunCC*) # The more standards-conforming stlport4 library is # incompatible with the Cstd library. Avoid specifying # it if it's in CXXFLAGS. Ignore libCrun as # -library=stlport4 depends on it. case " $CXX $CXXFLAGS " in *" -library=stlport4 "*) solaris_use_stlport4=yes ;; esac # Adding this requires a known-good setup of shared libraries for # Sun compiler versions before 5.6, else PIC objects from an old # archive will be linked into the output, leading to subtle bugs. if test "$solaris_use_stlport4" != yes; then _LT_TAGVAR(postdeps,$1)='-library=Cstd -library=Crun' fi ;; esac ;; esac ]) case " $_LT_TAGVAR(postdeps, $1) " in *" -lc "*) _LT_TAGVAR(archive_cmds_need_lc, $1)=no ;; esac _LT_TAGVAR(compiler_lib_search_dirs, $1)= if test -n "${_LT_TAGVAR(compiler_lib_search_path, $1)}"; then _LT_TAGVAR(compiler_lib_search_dirs, $1)=`echo " ${_LT_TAGVAR(compiler_lib_search_path, $1)}" | ${SED} -e 's! -L! !g' -e 's!^ !!'` fi _LT_TAGDECL([], [compiler_lib_search_dirs], [1], [The directories searched by this compiler when creating a shared library]) _LT_TAGDECL([], [predep_objects], [1], [Dependencies to place before and after the objects being linked to create a shared library]) _LT_TAGDECL([], [postdep_objects], [1]) _LT_TAGDECL([], [predeps], [1]) _LT_TAGDECL([], [postdeps], [1]) _LT_TAGDECL([], [compiler_lib_search_path], [1], [The library search path used internally by the compiler when linking a shared library]) ])# _LT_SYS_HIDDEN_LIBDEPS # _LT_LANG_F77_CONFIG([TAG]) # -------------------------- # Ensure that the configuration variables for a Fortran 77 compiler are # suitably defined. These variables are subsequently used by _LT_CONFIG # to write the compiler configuration to `libtool'. m4_defun([_LT_LANG_F77_CONFIG], [AC_LANG_PUSH(Fortran 77) if test -z "$F77" || test "X$F77" = "Xno"; then _lt_disable_F77=yes fi _LT_TAGVAR(archive_cmds_need_lc, $1)=no _LT_TAGVAR(allow_undefined_flag, $1)= _LT_TAGVAR(always_export_symbols, $1)=no _LT_TAGVAR(archive_expsym_cmds, $1)= _LT_TAGVAR(export_dynamic_flag_spec, $1)= _LT_TAGVAR(hardcode_direct, $1)=no _LT_TAGVAR(hardcode_direct_absolute, $1)=no _LT_TAGVAR(hardcode_libdir_flag_spec, $1)= _LT_TAGVAR(hardcode_libdir_separator, $1)= _LT_TAGVAR(hardcode_minus_L, $1)=no _LT_TAGVAR(hardcode_automatic, $1)=no _LT_TAGVAR(inherit_rpath, $1)=no _LT_TAGVAR(module_cmds, $1)= _LT_TAGVAR(module_expsym_cmds, $1)= _LT_TAGVAR(link_all_deplibs, $1)=unknown _LT_TAGVAR(old_archive_cmds, $1)=$old_archive_cmds _LT_TAGVAR(reload_flag, $1)=$reload_flag _LT_TAGVAR(reload_cmds, $1)=$reload_cmds _LT_TAGVAR(no_undefined_flag, $1)= _LT_TAGVAR(whole_archive_flag_spec, $1)= _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=no # Source file extension for f77 test sources. ac_ext=f # Object file extension for compiled f77 test sources. objext=o _LT_TAGVAR(objext, $1)=$objext # No sense in running all these tests if we already determined that # the F77 compiler isn't working. Some variables (like enable_shared) # are currently assumed to apply to all compilers on this platform, # and will be corrupted by setting them based on a non-working compiler. if test "$_lt_disable_F77" != yes; then # Code to be used in simple compile tests lt_simple_compile_test_code="\ subroutine t return end " # Code to be used in simple link tests lt_simple_link_test_code="\ program t end " # ltmain only uses $CC for tagged configurations so make sure $CC is set. _LT_TAG_COMPILER # save warnings/boilerplate of simple test code _LT_COMPILER_BOILERPLATE _LT_LINKER_BOILERPLATE # Allow CC to be a program name with arguments. lt_save_CC="$CC" lt_save_GCC=$GCC lt_save_CFLAGS=$CFLAGS CC=${F77-"f77"} CFLAGS=$FFLAGS compiler=$CC _LT_TAGVAR(compiler, $1)=$CC _LT_CC_BASENAME([$compiler]) GCC=$G77 if test -n "$compiler"; then AC_MSG_CHECKING([if libtool supports shared libraries]) AC_MSG_RESULT([$can_build_shared]) AC_MSG_CHECKING([whether to build shared libraries]) test "$can_build_shared" = "no" && enable_shared=no # On AIX, shared libraries and static libraries use the same namespace, and # are all built from PIC. case $host_os in aix3*) test "$enable_shared" = yes && enable_static=no if test -n "$RANLIB"; then archive_cmds="$archive_cmds~\$RANLIB \$lib" postinstall_cmds='$RANLIB $lib' fi ;; aix[[4-9]]*) if test "$host_cpu" != ia64 && test "$aix_use_runtimelinking" = no ; then test "$enable_shared" = yes && enable_static=no fi ;; esac AC_MSG_RESULT([$enable_shared]) AC_MSG_CHECKING([whether to build static libraries]) # Make sure either enable_shared or enable_static is yes. test "$enable_shared" = yes || enable_static=yes AC_MSG_RESULT([$enable_static]) _LT_TAGVAR(GCC, $1)="$G77" _LT_TAGVAR(LD, $1)="$LD" ## CAVEAT EMPTOR: ## There is no encapsulation within the following macros, do not change ## the running order or otherwise move them around unless you know exactly ## what you are doing... _LT_COMPILER_PIC($1) _LT_COMPILER_C_O($1) _LT_COMPILER_FILE_LOCKS($1) _LT_LINKER_SHLIBS($1) _LT_SYS_DYNAMIC_LINKER($1) _LT_LINKER_HARDCODE_LIBPATH($1) _LT_CONFIG($1) fi # test -n "$compiler" GCC=$lt_save_GCC CC="$lt_save_CC" CFLAGS="$lt_save_CFLAGS" fi # test "$_lt_disable_F77" != yes AC_LANG_POP ])# _LT_LANG_F77_CONFIG # _LT_LANG_FC_CONFIG([TAG]) # ------------------------- # Ensure that the configuration variables for a Fortran compiler are # suitably defined. These variables are subsequently used by _LT_CONFIG # to write the compiler configuration to `libtool'. m4_defun([_LT_LANG_FC_CONFIG], [AC_LANG_PUSH(Fortran) if test -z "$FC" || test "X$FC" = "Xno"; then _lt_disable_FC=yes fi _LT_TAGVAR(archive_cmds_need_lc, $1)=no _LT_TAGVAR(allow_undefined_flag, $1)= _LT_TAGVAR(always_export_symbols, $1)=no _LT_TAGVAR(archive_expsym_cmds, $1)= _LT_TAGVAR(export_dynamic_flag_spec, $1)= _LT_TAGVAR(hardcode_direct, $1)=no _LT_TAGVAR(hardcode_direct_absolute, $1)=no _LT_TAGVAR(hardcode_libdir_flag_spec, $1)= _LT_TAGVAR(hardcode_libdir_separator, $1)= _LT_TAGVAR(hardcode_minus_L, $1)=no _LT_TAGVAR(hardcode_automatic, $1)=no _LT_TAGVAR(inherit_rpath, $1)=no _LT_TAGVAR(module_cmds, $1)= _LT_TAGVAR(module_expsym_cmds, $1)= _LT_TAGVAR(link_all_deplibs, $1)=unknown _LT_TAGVAR(old_archive_cmds, $1)=$old_archive_cmds _LT_TAGVAR(reload_flag, $1)=$reload_flag _LT_TAGVAR(reload_cmds, $1)=$reload_cmds _LT_TAGVAR(no_undefined_flag, $1)= _LT_TAGVAR(whole_archive_flag_spec, $1)= _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=no # Source file extension for fc test sources. ac_ext=${ac_fc_srcext-f} # Object file extension for compiled fc test sources. objext=o _LT_TAGVAR(objext, $1)=$objext # No sense in running all these tests if we already determined that # the FC compiler isn't working. Some variables (like enable_shared) # are currently assumed to apply to all compilers on this platform, # and will be corrupted by setting them based on a non-working compiler. if test "$_lt_disable_FC" != yes; then # Code to be used in simple compile tests lt_simple_compile_test_code="\ subroutine t return end " # Code to be used in simple link tests lt_simple_link_test_code="\ program t end " # ltmain only uses $CC for tagged configurations so make sure $CC is set. _LT_TAG_COMPILER # save warnings/boilerplate of simple test code _LT_COMPILER_BOILERPLATE _LT_LINKER_BOILERPLATE # Allow CC to be a program name with arguments. lt_save_CC="$CC" lt_save_GCC=$GCC lt_save_CFLAGS=$CFLAGS CC=${FC-"f95"} CFLAGS=$FCFLAGS compiler=$CC GCC=$ac_cv_fc_compiler_gnu _LT_TAGVAR(compiler, $1)=$CC _LT_CC_BASENAME([$compiler]) if test -n "$compiler"; then AC_MSG_CHECKING([if libtool supports shared libraries]) AC_MSG_RESULT([$can_build_shared]) AC_MSG_CHECKING([whether to build shared libraries]) test "$can_build_shared" = "no" && enable_shared=no # On AIX, shared libraries and static libraries use the same namespace, and # are all built from PIC. case $host_os in aix3*) test "$enable_shared" = yes && enable_static=no if test -n "$RANLIB"; then archive_cmds="$archive_cmds~\$RANLIB \$lib" postinstall_cmds='$RANLIB $lib' fi ;; aix[[4-9]]*) if test "$host_cpu" != ia64 && test "$aix_use_runtimelinking" = no ; then test "$enable_shared" = yes && enable_static=no fi ;; esac AC_MSG_RESULT([$enable_shared]) AC_MSG_CHECKING([whether to build static libraries]) # Make sure either enable_shared or enable_static is yes. test "$enable_shared" = yes || enable_static=yes AC_MSG_RESULT([$enable_static]) _LT_TAGVAR(GCC, $1)="$ac_cv_fc_compiler_gnu" _LT_TAGVAR(LD, $1)="$LD" ## CAVEAT EMPTOR: ## There is no encapsulation within the following macros, do not change ## the running order or otherwise move them around unless you know exactly ## what you are doing... _LT_SYS_HIDDEN_LIBDEPS($1) _LT_COMPILER_PIC($1) _LT_COMPILER_C_O($1) _LT_COMPILER_FILE_LOCKS($1) _LT_LINKER_SHLIBS($1) _LT_SYS_DYNAMIC_LINKER($1) _LT_LINKER_HARDCODE_LIBPATH($1) _LT_CONFIG($1) fi # test -n "$compiler" GCC=$lt_save_GCC CC=$lt_save_CC CFLAGS=$lt_save_CFLAGS fi # test "$_lt_disable_FC" != yes AC_LANG_POP ])# _LT_LANG_FC_CONFIG # _LT_LANG_GCJ_CONFIG([TAG]) # -------------------------- # Ensure that the configuration variables for the GNU Java Compiler compiler # are suitably defined. These variables are subsequently used by _LT_CONFIG # to write the compiler configuration to `libtool'. m4_defun([_LT_LANG_GCJ_CONFIG], [AC_REQUIRE([LT_PROG_GCJ])dnl AC_LANG_SAVE # Source file extension for Java test sources. ac_ext=java # Object file extension for compiled Java test sources. objext=o _LT_TAGVAR(objext, $1)=$objext # Code to be used in simple compile tests lt_simple_compile_test_code="class foo {}" # Code to be used in simple link tests lt_simple_link_test_code='public class conftest { public static void main(String[[]] argv) {}; }' # ltmain only uses $CC for tagged configurations so make sure $CC is set. _LT_TAG_COMPILER # save warnings/boilerplate of simple test code _LT_COMPILER_BOILERPLATE _LT_LINKER_BOILERPLATE # Allow CC to be a program name with arguments. lt_save_CC=$CC lt_save_CFLAGS=$CFLAGS lt_save_GCC=$GCC GCC=yes CC=${GCJ-"gcj"} CFLAGS=$GCJFLAGS compiler=$CC _LT_TAGVAR(compiler, $1)=$CC _LT_TAGVAR(LD, $1)="$LD" _LT_CC_BASENAME([$compiler]) # GCJ did not exist at the time GCC didn't implicitly link libc in. _LT_TAGVAR(archive_cmds_need_lc, $1)=no _LT_TAGVAR(old_archive_cmds, $1)=$old_archive_cmds _LT_TAGVAR(reload_flag, $1)=$reload_flag _LT_TAGVAR(reload_cmds, $1)=$reload_cmds if test -n "$compiler"; then _LT_COMPILER_NO_RTTI($1) _LT_COMPILER_PIC($1) _LT_COMPILER_C_O($1) _LT_COMPILER_FILE_LOCKS($1) _LT_LINKER_SHLIBS($1) _LT_LINKER_HARDCODE_LIBPATH($1) _LT_CONFIG($1) fi AC_LANG_RESTORE GCC=$lt_save_GCC CC=$lt_save_CC CFLAGS=$lt_save_CFLAGS ])# _LT_LANG_GCJ_CONFIG # _LT_LANG_GO_CONFIG([TAG]) # -------------------------- # Ensure that the configuration variables for the GNU Go compiler # are suitably defined. These variables are subsequently used by _LT_CONFIG # to write the compiler configuration to `libtool'. m4_defun([_LT_LANG_GO_CONFIG], [AC_REQUIRE([LT_PROG_GO])dnl AC_LANG_SAVE # Source file extension for Go test sources. ac_ext=go # Object file extension for compiled Go test sources. objext=o _LT_TAGVAR(objext, $1)=$objext # Code to be used in simple compile tests lt_simple_compile_test_code="package main; func main() { }" # Code to be used in simple link tests lt_simple_link_test_code='package main; func main() { }' # ltmain only uses $CC for tagged configurations so make sure $CC is set. _LT_TAG_COMPILER # save warnings/boilerplate of simple test code _LT_COMPILER_BOILERPLATE _LT_LINKER_BOILERPLATE # Allow CC to be a program name with arguments. lt_save_CC=$CC lt_save_CFLAGS=$CFLAGS lt_save_GCC=$GCC GCC=yes CC=${GOC-"gccgo"} CFLAGS=$GOFLAGS compiler=$CC _LT_TAGVAR(compiler, $1)=$CC _LT_TAGVAR(LD, $1)="$LD" _LT_CC_BASENAME([$compiler]) # Go did not exist at the time GCC didn't implicitly link libc in. _LT_TAGVAR(archive_cmds_need_lc, $1)=no _LT_TAGVAR(old_archive_cmds, $1)=$old_archive_cmds _LT_TAGVAR(reload_flag, $1)=$reload_flag _LT_TAGVAR(reload_cmds, $1)=$reload_cmds if test -n "$compiler"; then _LT_COMPILER_NO_RTTI($1) _LT_COMPILER_PIC($1) _LT_COMPILER_C_O($1) _LT_COMPILER_FILE_LOCKS($1) _LT_LINKER_SHLIBS($1) _LT_LINKER_HARDCODE_LIBPATH($1) _LT_CONFIG($1) fi AC_LANG_RESTORE GCC=$lt_save_GCC CC=$lt_save_CC CFLAGS=$lt_save_CFLAGS ])# _LT_LANG_GO_CONFIG # _LT_LANG_RC_CONFIG([TAG]) # ------------------------- # Ensure that the configuration variables for the Windows resource compiler # are suitably defined. These variables are subsequently used by _LT_CONFIG # to write the compiler configuration to `libtool'. m4_defun([_LT_LANG_RC_CONFIG], [AC_REQUIRE([LT_PROG_RC])dnl AC_LANG_SAVE # Source file extension for RC test sources. ac_ext=rc # Object file extension for compiled RC test sources. objext=o _LT_TAGVAR(objext, $1)=$objext # Code to be used in simple compile tests lt_simple_compile_test_code='sample MENU { MENUITEM "&Soup", 100, CHECKED }' # Code to be used in simple link tests lt_simple_link_test_code="$lt_simple_compile_test_code" # ltmain only uses $CC for tagged configurations so make sure $CC is set. _LT_TAG_COMPILER # save warnings/boilerplate of simple test code _LT_COMPILER_BOILERPLATE _LT_LINKER_BOILERPLATE # Allow CC to be a program name with arguments. lt_save_CC="$CC" lt_save_CFLAGS=$CFLAGS lt_save_GCC=$GCC GCC= CC=${RC-"windres"} CFLAGS= compiler=$CC _LT_TAGVAR(compiler, $1)=$CC _LT_CC_BASENAME([$compiler]) _LT_TAGVAR(lt_cv_prog_compiler_c_o, $1)=yes if test -n "$compiler"; then : _LT_CONFIG($1) fi GCC=$lt_save_GCC AC_LANG_RESTORE CC=$lt_save_CC CFLAGS=$lt_save_CFLAGS ])# _LT_LANG_RC_CONFIG # LT_PROG_GCJ # ----------- AC_DEFUN([LT_PROG_GCJ], [m4_ifdef([AC_PROG_GCJ], [AC_PROG_GCJ], [m4_ifdef([A][M_PROG_GCJ], [A][M_PROG_GCJ], [AC_CHECK_TOOL(GCJ, gcj,) test "x${GCJFLAGS+set}" = xset || GCJFLAGS="-g -O2" AC_SUBST(GCJFLAGS)])])[]dnl ]) # Old name: AU_ALIAS([LT_AC_PROG_GCJ], [LT_PROG_GCJ]) dnl aclocal-1.4 backwards compatibility: dnl AC_DEFUN([LT_AC_PROG_GCJ], []) # LT_PROG_GO # ---------- AC_DEFUN([LT_PROG_GO], [AC_CHECK_TOOL(GOC, gccgo,) ]) # LT_PROG_RC # ---------- AC_DEFUN([LT_PROG_RC], [AC_CHECK_TOOL(RC, windres,) ]) # Old name: AU_ALIAS([LT_AC_PROG_RC], [LT_PROG_RC]) dnl aclocal-1.4 backwards compatibility: dnl AC_DEFUN([LT_AC_PROG_RC], []) # _LT_DECL_EGREP # -------------- # If we don't have a new enough Autoconf to choose the best grep # available, choose the one first in the user's PATH. m4_defun([_LT_DECL_EGREP], [AC_REQUIRE([AC_PROG_EGREP])dnl AC_REQUIRE([AC_PROG_FGREP])dnl test -z "$GREP" && GREP=grep _LT_DECL([], [GREP], [1], [A grep program that handles long lines]) _LT_DECL([], [EGREP], [1], [An ERE matcher]) _LT_DECL([], [FGREP], [1], [A literal string matcher]) dnl Non-bleeding-edge autoconf doesn't subst GREP, so do it here too AC_SUBST([GREP]) ]) # _LT_DECL_OBJDUMP # -------------- # If we don't have a new enough Autoconf to choose the best objdump # available, choose the one first in the user's PATH. m4_defun([_LT_DECL_OBJDUMP], [AC_CHECK_TOOL(OBJDUMP, objdump, false) test -z "$OBJDUMP" && OBJDUMP=objdump _LT_DECL([], [OBJDUMP], [1], [An object symbol dumper]) AC_SUBST([OBJDUMP]) ]) # _LT_DECL_DLLTOOL # ---------------- # Ensure DLLTOOL variable is set. m4_defun([_LT_DECL_DLLTOOL], [AC_CHECK_TOOL(DLLTOOL, dlltool, false) test -z "$DLLTOOL" && DLLTOOL=dlltool _LT_DECL([], [DLLTOOL], [1], [DLL creation program]) AC_SUBST([DLLTOOL]) ]) # _LT_DECL_SED # ------------ # Check for a fully-functional sed program, that truncates # as few characters as possible. Prefer GNU sed if found. m4_defun([_LT_DECL_SED], [AC_PROG_SED test -z "$SED" && SED=sed Xsed="$SED -e 1s/^X//" _LT_DECL([], [SED], [1], [A sed program that does not truncate output]) _LT_DECL([], [Xsed], ["\$SED -e 1s/^X//"], [Sed that helps us avoid accidentally triggering echo(1) options like -n]) ])# _LT_DECL_SED m4_ifndef([AC_PROG_SED], [ # NOTE: This macro has been submitted for inclusion into # # GNU Autoconf as AC_PROG_SED. When it is available in # # a released version of Autoconf we should remove this # # macro and use it instead. # m4_defun([AC_PROG_SED], [AC_MSG_CHECKING([for a sed that does not truncate output]) AC_CACHE_VAL(lt_cv_path_SED, [# Loop through the user's path and test for sed and gsed. # Then use that list of sed's as ones to test for truncation. as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for lt_ac_prog in sed gsed; do for ac_exec_ext in '' $ac_executable_extensions; do if $as_executable_p "$as_dir/$lt_ac_prog$ac_exec_ext"; then lt_ac_sed_list="$lt_ac_sed_list $as_dir/$lt_ac_prog$ac_exec_ext" fi done done done IFS=$as_save_IFS lt_ac_max=0 lt_ac_count=0 # Add /usr/xpg4/bin/sed as it is typically found on Solaris # along with /bin/sed that truncates output. for lt_ac_sed in $lt_ac_sed_list /usr/xpg4/bin/sed; do test ! -f $lt_ac_sed && continue cat /dev/null > conftest.in lt_ac_count=0 echo $ECHO_N "0123456789$ECHO_C" >conftest.in # Check for GNU sed and select it if it is found. if "$lt_ac_sed" --version 2>&1 < /dev/null | grep 'GNU' > /dev/null; then lt_cv_path_SED=$lt_ac_sed break fi while true; do cat conftest.in conftest.in >conftest.tmp mv conftest.tmp conftest.in cp conftest.in conftest.nl echo >>conftest.nl $lt_ac_sed -e 's/a$//' < conftest.nl >conftest.out || break cmp -s conftest.out conftest.nl || break # 10000 chars as input seems more than enough test $lt_ac_count -gt 10 && break lt_ac_count=`expr $lt_ac_count + 1` if test $lt_ac_count -gt $lt_ac_max; then lt_ac_max=$lt_ac_count lt_cv_path_SED=$lt_ac_sed fi done done ]) SED=$lt_cv_path_SED AC_SUBST([SED]) AC_MSG_RESULT([$SED]) ])#AC_PROG_SED ])#m4_ifndef # Old name: AU_ALIAS([LT_AC_PROG_SED], [AC_PROG_SED]) dnl aclocal-1.4 backwards compatibility: dnl AC_DEFUN([LT_AC_PROG_SED], []) # _LT_CHECK_SHELL_FEATURES # ------------------------ # Find out whether the shell is Bourne or XSI compatible, # or has some other useful features. m4_defun([_LT_CHECK_SHELL_FEATURES], [AC_MSG_CHECKING([whether the shell understands some XSI constructs]) # Try some XSI features xsi_shell=no ( _lt_dummy="a/b/c" test "${_lt_dummy##*/},${_lt_dummy%/*},${_lt_dummy#??}"${_lt_dummy%"$_lt_dummy"}, \ = c,a/b,b/c, \ && eval 'test $(( 1 + 1 )) -eq 2 \ && test "${#_lt_dummy}" -eq 5' ) >/dev/null 2>&1 \ && xsi_shell=yes AC_MSG_RESULT([$xsi_shell]) _LT_CONFIG_LIBTOOL_INIT([xsi_shell='$xsi_shell']) AC_MSG_CHECKING([whether the shell understands "+="]) lt_shell_append=no ( foo=bar; set foo baz; eval "$[1]+=\$[2]" && test "$foo" = barbaz ) \ >/dev/null 2>&1 \ && lt_shell_append=yes AC_MSG_RESULT([$lt_shell_append]) _LT_CONFIG_LIBTOOL_INIT([lt_shell_append='$lt_shell_append']) if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then lt_unset=unset else lt_unset=false fi _LT_DECL([], [lt_unset], [0], [whether the shell understands "unset"])dnl # test EBCDIC or ASCII case `echo X|tr X '\101'` in A) # ASCII based system # \n is not interpreted correctly by Solaris 8 /usr/ucb/tr lt_SP2NL='tr \040 \012' lt_NL2SP='tr \015\012 \040\040' ;; *) # EBCDIC based system lt_SP2NL='tr \100 \n' lt_NL2SP='tr \r\n \100\100' ;; esac _LT_DECL([SP2NL], [lt_SP2NL], [1], [turn spaces into newlines])dnl _LT_DECL([NL2SP], [lt_NL2SP], [1], [turn newlines into spaces])dnl ])# _LT_CHECK_SHELL_FEATURES # _LT_PROG_FUNCTION_REPLACE (FUNCNAME, REPLACEMENT-BODY) # ------------------------------------------------------ # In `$cfgfile', look for function FUNCNAME delimited by `^FUNCNAME ()$' and # '^} FUNCNAME ', and replace its body with REPLACEMENT-BODY. m4_defun([_LT_PROG_FUNCTION_REPLACE], [dnl { sed -e '/^$1 ()$/,/^} # $1 /c\ $1 ()\ {\ m4_bpatsubsts([$2], [$], [\\], [^\([ ]\)], [\\\1]) } # Extended-shell $1 implementation' "$cfgfile" > $cfgfile.tmp \ && mv -f "$cfgfile.tmp" "$cfgfile" \ || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") test 0 -eq $? || _lt_function_replace_fail=: ]) # _LT_PROG_REPLACE_SHELLFNS # ------------------------- # Replace existing portable implementations of several shell functions with # equivalent extended shell implementations where those features are available.. m4_defun([_LT_PROG_REPLACE_SHELLFNS], [if test x"$xsi_shell" = xyes; then _LT_PROG_FUNCTION_REPLACE([func_dirname], [dnl case ${1} in */*) func_dirname_result="${1%/*}${2}" ;; * ) func_dirname_result="${3}" ;; esac]) _LT_PROG_FUNCTION_REPLACE([func_basename], [dnl func_basename_result="${1##*/}"]) _LT_PROG_FUNCTION_REPLACE([func_dirname_and_basename], [dnl case ${1} in */*) func_dirname_result="${1%/*}${2}" ;; * ) func_dirname_result="${3}" ;; esac func_basename_result="${1##*/}"]) _LT_PROG_FUNCTION_REPLACE([func_stripname], [dnl # pdksh 5.2.14 does not do ${X%$Y} correctly if both X and Y are # positional parameters, so assign one to ordinary parameter first. func_stripname_result=${3} func_stripname_result=${func_stripname_result#"${1}"} func_stripname_result=${func_stripname_result%"${2}"}]) _LT_PROG_FUNCTION_REPLACE([func_split_long_opt], [dnl func_split_long_opt_name=${1%%=*} func_split_long_opt_arg=${1#*=}]) _LT_PROG_FUNCTION_REPLACE([func_split_short_opt], [dnl func_split_short_opt_arg=${1#??} func_split_short_opt_name=${1%"$func_split_short_opt_arg"}]) _LT_PROG_FUNCTION_REPLACE([func_lo2o], [dnl case ${1} in *.lo) func_lo2o_result=${1%.lo}.${objext} ;; *) func_lo2o_result=${1} ;; esac]) _LT_PROG_FUNCTION_REPLACE([func_xform], [ func_xform_result=${1%.*}.lo]) _LT_PROG_FUNCTION_REPLACE([func_arith], [ func_arith_result=$(( $[*] ))]) _LT_PROG_FUNCTION_REPLACE([func_len], [ func_len_result=${#1}]) fi if test x"$lt_shell_append" = xyes; then _LT_PROG_FUNCTION_REPLACE([func_append], [ eval "${1}+=\\${2}"]) _LT_PROG_FUNCTION_REPLACE([func_append_quoted], [dnl func_quote_for_eval "${2}" dnl m4 expansion turns \\\\ into \\, and then the shell eval turns that into \ eval "${1}+=\\\\ \\$func_quote_for_eval_result"]) # Save a `func_append' function call where possible by direct use of '+=' sed -e 's%func_append \([[a-zA-Z_]]\{1,\}\) "%\1+="%g' $cfgfile > $cfgfile.tmp \ && mv -f "$cfgfile.tmp" "$cfgfile" \ || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") test 0 -eq $? || _lt_function_replace_fail=: else # Save a `func_append' function call even when '+=' is not available sed -e 's%func_append \([[a-zA-Z_]]\{1,\}\) "%\1="$\1%g' $cfgfile > $cfgfile.tmp \ && mv -f "$cfgfile.tmp" "$cfgfile" \ || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") test 0 -eq $? || _lt_function_replace_fail=: fi if test x"$_lt_function_replace_fail" = x":"; then AC_MSG_WARN([Unable to substitute extended shell functions in $ofile]) fi ]) # _LT_PATH_CONVERSION_FUNCTIONS # ----------------------------- # Determine which file name conversion functions should be used by # func_to_host_file (and, implicitly, by func_to_host_path). These are needed # for certain cross-compile configurations and native mingw. m4_defun([_LT_PATH_CONVERSION_FUNCTIONS], [AC_REQUIRE([AC_CANONICAL_HOST])dnl AC_REQUIRE([AC_CANONICAL_BUILD])dnl AC_MSG_CHECKING([how to convert $build file names to $host format]) AC_CACHE_VAL(lt_cv_to_host_file_cmd, [case $host in *-*-mingw* ) case $build in *-*-mingw* ) # actually msys lt_cv_to_host_file_cmd=func_convert_file_msys_to_w32 ;; *-*-cygwin* ) lt_cv_to_host_file_cmd=func_convert_file_cygwin_to_w32 ;; * ) # otherwise, assume *nix lt_cv_to_host_file_cmd=func_convert_file_nix_to_w32 ;; esac ;; *-*-cygwin* ) case $build in *-*-mingw* ) # actually msys lt_cv_to_host_file_cmd=func_convert_file_msys_to_cygwin ;; *-*-cygwin* ) lt_cv_to_host_file_cmd=func_convert_file_noop ;; * ) # otherwise, assume *nix lt_cv_to_host_file_cmd=func_convert_file_nix_to_cygwin ;; esac ;; * ) # unhandled hosts (and "normal" native builds) lt_cv_to_host_file_cmd=func_convert_file_noop ;; esac ]) to_host_file_cmd=$lt_cv_to_host_file_cmd AC_MSG_RESULT([$lt_cv_to_host_file_cmd]) _LT_DECL([to_host_file_cmd], [lt_cv_to_host_file_cmd], [0], [convert $build file names to $host format])dnl AC_MSG_CHECKING([how to convert $build file names to toolchain format]) AC_CACHE_VAL(lt_cv_to_tool_file_cmd, [#assume ordinary cross tools, or native build. lt_cv_to_tool_file_cmd=func_convert_file_noop case $host in *-*-mingw* ) case $build in *-*-mingw* ) # actually msys lt_cv_to_tool_file_cmd=func_convert_file_msys_to_w32 ;; esac ;; esac ]) to_tool_file_cmd=$lt_cv_to_tool_file_cmd AC_MSG_RESULT([$lt_cv_to_tool_file_cmd]) _LT_DECL([to_tool_file_cmd], [lt_cv_to_tool_file_cmd], [0], [convert $build files to toolchain format])dnl ])# _LT_PATH_CONVERSION_FUNCTIONS # Helper functions for option handling. -*- Autoconf -*- # # Copyright (C) 2004, 2005, 2007, 2008, 2009 Free Software Foundation, # Inc. # Written by Gary V. Vaughan, 2004 # # This file is free software; the Free Software Foundation gives # unlimited permission to copy and/or distribute it, with or without # modifications, as long as this notice is preserved. # serial 7 ltoptions.m4 # This is to help aclocal find these macros, as it can't see m4_define. AC_DEFUN([LTOPTIONS_VERSION], [m4_if([1])]) # _LT_MANGLE_OPTION(MACRO-NAME, OPTION-NAME) # ------------------------------------------ m4_define([_LT_MANGLE_OPTION], [[_LT_OPTION_]m4_bpatsubst($1__$2, [[^a-zA-Z0-9_]], [_])]) # _LT_SET_OPTION(MACRO-NAME, OPTION-NAME) # --------------------------------------- # Set option OPTION-NAME for macro MACRO-NAME, and if there is a # matching handler defined, dispatch to it. Other OPTION-NAMEs are # saved as a flag. m4_define([_LT_SET_OPTION], [m4_define(_LT_MANGLE_OPTION([$1], [$2]))dnl m4_ifdef(_LT_MANGLE_DEFUN([$1], [$2]), _LT_MANGLE_DEFUN([$1], [$2]), [m4_warning([Unknown $1 option `$2'])])[]dnl ]) # _LT_IF_OPTION(MACRO-NAME, OPTION-NAME, IF-SET, [IF-NOT-SET]) # ------------------------------------------------------------ # Execute IF-SET if OPTION is set, IF-NOT-SET otherwise. m4_define([_LT_IF_OPTION], [m4_ifdef(_LT_MANGLE_OPTION([$1], [$2]), [$3], [$4])]) # _LT_UNLESS_OPTIONS(MACRO-NAME, OPTION-LIST, IF-NOT-SET) # ------------------------------------------------------- # Execute IF-NOT-SET unless all options in OPTION-LIST for MACRO-NAME # are set. m4_define([_LT_UNLESS_OPTIONS], [m4_foreach([_LT_Option], m4_split(m4_normalize([$2])), [m4_ifdef(_LT_MANGLE_OPTION([$1], _LT_Option), [m4_define([$0_found])])])[]dnl m4_ifdef([$0_found], [m4_undefine([$0_found])], [$3 ])[]dnl ]) # _LT_SET_OPTIONS(MACRO-NAME, OPTION-LIST) # ---------------------------------------- # OPTION-LIST is a space-separated list of Libtool options associated # with MACRO-NAME. If any OPTION has a matching handler declared with # LT_OPTION_DEFINE, dispatch to that macro; otherwise complain about # the unknown option and exit. m4_defun([_LT_SET_OPTIONS], [# Set options m4_foreach([_LT_Option], m4_split(m4_normalize([$2])), [_LT_SET_OPTION([$1], _LT_Option)]) m4_if([$1],[LT_INIT],[ dnl dnl Simply set some default values (i.e off) if boolean options were not dnl specified: _LT_UNLESS_OPTIONS([LT_INIT], [dlopen], [enable_dlopen=no ]) _LT_UNLESS_OPTIONS([LT_INIT], [win32-dll], [enable_win32_dll=no ]) dnl dnl If no reference was made to various pairs of opposing options, then dnl we run the default mode handler for the pair. For example, if neither dnl `shared' nor `disable-shared' was passed, we enable building of shared dnl archives by default: _LT_UNLESS_OPTIONS([LT_INIT], [shared disable-shared], [_LT_ENABLE_SHARED]) _LT_UNLESS_OPTIONS([LT_INIT], [static disable-static], [_LT_ENABLE_STATIC]) _LT_UNLESS_OPTIONS([LT_INIT], [pic-only no-pic], [_LT_WITH_PIC]) _LT_UNLESS_OPTIONS([LT_INIT], [fast-install disable-fast-install], [_LT_ENABLE_FAST_INSTALL]) ]) ])# _LT_SET_OPTIONS # _LT_MANGLE_DEFUN(MACRO-NAME, OPTION-NAME) # ----------------------------------------- m4_define([_LT_MANGLE_DEFUN], [[_LT_OPTION_DEFUN_]m4_bpatsubst(m4_toupper([$1__$2]), [[^A-Z0-9_]], [_])]) # LT_OPTION_DEFINE(MACRO-NAME, OPTION-NAME, CODE) # ----------------------------------------------- m4_define([LT_OPTION_DEFINE], [m4_define(_LT_MANGLE_DEFUN([$1], [$2]), [$3])[]dnl ])# LT_OPTION_DEFINE # dlopen # ------ LT_OPTION_DEFINE([LT_INIT], [dlopen], [enable_dlopen=yes ]) AU_DEFUN([AC_LIBTOOL_DLOPEN], [_LT_SET_OPTION([LT_INIT], [dlopen]) AC_DIAGNOSE([obsolete], [$0: Remove this warning and the call to _LT_SET_OPTION when you put the `dlopen' option into LT_INIT's first parameter.]) ]) dnl aclocal-1.4 backwards compatibility: dnl AC_DEFUN([AC_LIBTOOL_DLOPEN], []) # win32-dll # --------- # Declare package support for building win32 dll's. LT_OPTION_DEFINE([LT_INIT], [win32-dll], [enable_win32_dll=yes case $host in *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-cegcc*) AC_CHECK_TOOL(AS, as, false) AC_CHECK_TOOL(DLLTOOL, dlltool, false) AC_CHECK_TOOL(OBJDUMP, objdump, false) ;; esac test -z "$AS" && AS=as _LT_DECL([], [AS], [1], [Assembler program])dnl test -z "$DLLTOOL" && DLLTOOL=dlltool _LT_DECL([], [DLLTOOL], [1], [DLL creation program])dnl test -z "$OBJDUMP" && OBJDUMP=objdump _LT_DECL([], [OBJDUMP], [1], [Object dumper program])dnl ])# win32-dll AU_DEFUN([AC_LIBTOOL_WIN32_DLL], [AC_REQUIRE([AC_CANONICAL_HOST])dnl _LT_SET_OPTION([LT_INIT], [win32-dll]) AC_DIAGNOSE([obsolete], [$0: Remove this warning and the call to _LT_SET_OPTION when you put the `win32-dll' option into LT_INIT's first parameter.]) ]) dnl aclocal-1.4 backwards compatibility: dnl AC_DEFUN([AC_LIBTOOL_WIN32_DLL], []) # _LT_ENABLE_SHARED([DEFAULT]) # ---------------------------- # implement the --enable-shared flag, and supports the `shared' and # `disable-shared' LT_INIT options. # DEFAULT is either `yes' or `no'. If omitted, it defaults to `yes'. m4_define([_LT_ENABLE_SHARED], [m4_define([_LT_ENABLE_SHARED_DEFAULT], [m4_if($1, no, no, yes)])dnl AC_ARG_ENABLE([shared], [AS_HELP_STRING([--enable-shared@<:@=PKGS@:>@], [build shared libraries @<:@default=]_LT_ENABLE_SHARED_DEFAULT[@:>@])], [p=${PACKAGE-default} case $enableval in yes) enable_shared=yes ;; no) enable_shared=no ;; *) enable_shared=no # Look at the argument we got. We use all the common list separators. lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR," for pkg in $enableval; do IFS="$lt_save_ifs" if test "X$pkg" = "X$p"; then enable_shared=yes fi done IFS="$lt_save_ifs" ;; esac], [enable_shared=]_LT_ENABLE_SHARED_DEFAULT) _LT_DECL([build_libtool_libs], [enable_shared], [0], [Whether or not to build shared libraries]) ])# _LT_ENABLE_SHARED LT_OPTION_DEFINE([LT_INIT], [shared], [_LT_ENABLE_SHARED([yes])]) LT_OPTION_DEFINE([LT_INIT], [disable-shared], [_LT_ENABLE_SHARED([no])]) # Old names: AC_DEFUN([AC_ENABLE_SHARED], [_LT_SET_OPTION([LT_INIT], m4_if([$1], [no], [disable-])[shared]) ]) AC_DEFUN([AC_DISABLE_SHARED], [_LT_SET_OPTION([LT_INIT], [disable-shared]) ]) AU_DEFUN([AM_ENABLE_SHARED], [AC_ENABLE_SHARED($@)]) AU_DEFUN([AM_DISABLE_SHARED], [AC_DISABLE_SHARED($@)]) dnl aclocal-1.4 backwards compatibility: dnl AC_DEFUN([AM_ENABLE_SHARED], []) dnl AC_DEFUN([AM_DISABLE_SHARED], []) # _LT_ENABLE_STATIC([DEFAULT]) # ---------------------------- # implement the --enable-static flag, and support the `static' and # `disable-static' LT_INIT options. # DEFAULT is either `yes' or `no'. If omitted, it defaults to `yes'. m4_define([_LT_ENABLE_STATIC], [m4_define([_LT_ENABLE_STATIC_DEFAULT], [m4_if($1, no, no, yes)])dnl AC_ARG_ENABLE([static], [AS_HELP_STRING([--enable-static@<:@=PKGS@:>@], [build static libraries @<:@default=]_LT_ENABLE_STATIC_DEFAULT[@:>@])], [p=${PACKAGE-default} case $enableval in yes) enable_static=yes ;; no) enable_static=no ;; *) enable_static=no # Look at the argument we got. We use all the common list separators. lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR," for pkg in $enableval; do IFS="$lt_save_ifs" if test "X$pkg" = "X$p"; then enable_static=yes fi done IFS="$lt_save_ifs" ;; esac], [enable_static=]_LT_ENABLE_STATIC_DEFAULT) _LT_DECL([build_old_libs], [enable_static], [0], [Whether or not to build static libraries]) ])# _LT_ENABLE_STATIC LT_OPTION_DEFINE([LT_INIT], [static], [_LT_ENABLE_STATIC([yes])]) LT_OPTION_DEFINE([LT_INIT], [disable-static], [_LT_ENABLE_STATIC([no])]) # Old names: AC_DEFUN([AC_ENABLE_STATIC], [_LT_SET_OPTION([LT_INIT], m4_if([$1], [no], [disable-])[static]) ]) AC_DEFUN([AC_DISABLE_STATIC], [_LT_SET_OPTION([LT_INIT], [disable-static]) ]) AU_DEFUN([AM_ENABLE_STATIC], [AC_ENABLE_STATIC($@)]) AU_DEFUN([AM_DISABLE_STATIC], [AC_DISABLE_STATIC($@)]) dnl aclocal-1.4 backwards compatibility: dnl AC_DEFUN([AM_ENABLE_STATIC], []) dnl AC_DEFUN([AM_DISABLE_STATIC], []) # _LT_ENABLE_FAST_INSTALL([DEFAULT]) # ---------------------------------- # implement the --enable-fast-install flag, and support the `fast-install' # and `disable-fast-install' LT_INIT options. # DEFAULT is either `yes' or `no'. If omitted, it defaults to `yes'. m4_define([_LT_ENABLE_FAST_INSTALL], [m4_define([_LT_ENABLE_FAST_INSTALL_DEFAULT], [m4_if($1, no, no, yes)])dnl AC_ARG_ENABLE([fast-install], [AS_HELP_STRING([--enable-fast-install@<:@=PKGS@:>@], [optimize for fast installation @<:@default=]_LT_ENABLE_FAST_INSTALL_DEFAULT[@:>@])], [p=${PACKAGE-default} case $enableval in yes) enable_fast_install=yes ;; no) enable_fast_install=no ;; *) enable_fast_install=no # Look at the argument we got. We use all the common list separators. lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR," for pkg in $enableval; do IFS="$lt_save_ifs" if test "X$pkg" = "X$p"; then enable_fast_install=yes fi done IFS="$lt_save_ifs" ;; esac], [enable_fast_install=]_LT_ENABLE_FAST_INSTALL_DEFAULT) _LT_DECL([fast_install], [enable_fast_install], [0], [Whether or not to optimize for fast installation])dnl ])# _LT_ENABLE_FAST_INSTALL LT_OPTION_DEFINE([LT_INIT], [fast-install], [_LT_ENABLE_FAST_INSTALL([yes])]) LT_OPTION_DEFINE([LT_INIT], [disable-fast-install], [_LT_ENABLE_FAST_INSTALL([no])]) # Old names: AU_DEFUN([AC_ENABLE_FAST_INSTALL], [_LT_SET_OPTION([LT_INIT], m4_if([$1], [no], [disable-])[fast-install]) AC_DIAGNOSE([obsolete], [$0: Remove this warning and the call to _LT_SET_OPTION when you put the `fast-install' option into LT_INIT's first parameter.]) ]) AU_DEFUN([AC_DISABLE_FAST_INSTALL], [_LT_SET_OPTION([LT_INIT], [disable-fast-install]) AC_DIAGNOSE([obsolete], [$0: Remove this warning and the call to _LT_SET_OPTION when you put the `disable-fast-install' option into LT_INIT's first parameter.]) ]) dnl aclocal-1.4 backwards compatibility: dnl AC_DEFUN([AC_ENABLE_FAST_INSTALL], []) dnl AC_DEFUN([AM_DISABLE_FAST_INSTALL], []) # _LT_WITH_PIC([MODE]) # -------------------- # implement the --with-pic flag, and support the `pic-only' and `no-pic' # LT_INIT options. # MODE is either `yes' or `no'. If omitted, it defaults to `both'. m4_define([_LT_WITH_PIC], [AC_ARG_WITH([pic], [AS_HELP_STRING([--with-pic@<:@=PKGS@:>@], [try to use only PIC/non-PIC objects @<:@default=use both@:>@])], [lt_p=${PACKAGE-default} case $withval in yes|no) pic_mode=$withval ;; *) pic_mode=default # Look at the argument we got. We use all the common list separators. lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR," for lt_pkg in $withval; do IFS="$lt_save_ifs" if test "X$lt_pkg" = "X$lt_p"; then pic_mode=yes fi done IFS="$lt_save_ifs" ;; esac], [pic_mode=default]) test -z "$pic_mode" && pic_mode=m4_default([$1], [default]) _LT_DECL([], [pic_mode], [0], [What type of objects to build])dnl ])# _LT_WITH_PIC LT_OPTION_DEFINE([LT_INIT], [pic-only], [_LT_WITH_PIC([yes])]) LT_OPTION_DEFINE([LT_INIT], [no-pic], [_LT_WITH_PIC([no])]) # Old name: AU_DEFUN([AC_LIBTOOL_PICMODE], [_LT_SET_OPTION([LT_INIT], [pic-only]) AC_DIAGNOSE([obsolete], [$0: Remove this warning and the call to _LT_SET_OPTION when you put the `pic-only' option into LT_INIT's first parameter.]) ]) dnl aclocal-1.4 backwards compatibility: dnl AC_DEFUN([AC_LIBTOOL_PICMODE], []) m4_define([_LTDL_MODE], []) LT_OPTION_DEFINE([LTDL_INIT], [nonrecursive], [m4_define([_LTDL_MODE], [nonrecursive])]) LT_OPTION_DEFINE([LTDL_INIT], [recursive], [m4_define([_LTDL_MODE], [recursive])]) LT_OPTION_DEFINE([LTDL_INIT], [subproject], [m4_define([_LTDL_MODE], [subproject])]) m4_define([_LTDL_TYPE], []) LT_OPTION_DEFINE([LTDL_INIT], [installable], [m4_define([_LTDL_TYPE], [installable])]) LT_OPTION_DEFINE([LTDL_INIT], [convenience], [m4_define([_LTDL_TYPE], [convenience])]) # ltsugar.m4 -- libtool m4 base layer. -*-Autoconf-*- # # Copyright (C) 2004, 2005, 2007, 2008 Free Software Foundation, Inc. # Written by Gary V. Vaughan, 2004 # # This file is free software; the Free Software Foundation gives # unlimited permission to copy and/or distribute it, with or without # modifications, as long as this notice is preserved. # serial 6 ltsugar.m4 # This is to help aclocal find these macros, as it can't see m4_define. AC_DEFUN([LTSUGAR_VERSION], [m4_if([0.1])]) # lt_join(SEP, ARG1, [ARG2...]) # ----------------------------- # Produce ARG1SEPARG2...SEPARGn, omitting [] arguments and their # associated separator. # Needed until we can rely on m4_join from Autoconf 2.62, since all earlier # versions in m4sugar had bugs. m4_define([lt_join], [m4_if([$#], [1], [], [$#], [2], [[$2]], [m4_if([$2], [], [], [[$2]_])$0([$1], m4_shift(m4_shift($@)))])]) m4_define([_lt_join], [m4_if([$#$2], [2], [], [m4_if([$2], [], [], [[$1$2]])$0([$1], m4_shift(m4_shift($@)))])]) # lt_car(LIST) # lt_cdr(LIST) # ------------ # Manipulate m4 lists. # These macros are necessary as long as will still need to support # Autoconf-2.59 which quotes differently. m4_define([lt_car], [[$1]]) m4_define([lt_cdr], [m4_if([$#], 0, [m4_fatal([$0: cannot be called without arguments])], [$#], 1, [], [m4_dquote(m4_shift($@))])]) m4_define([lt_unquote], $1) # lt_append(MACRO-NAME, STRING, [SEPARATOR]) # ------------------------------------------ # Redefine MACRO-NAME to hold its former content plus `SEPARATOR'`STRING'. # Note that neither SEPARATOR nor STRING are expanded; they are appended # to MACRO-NAME as is (leaving the expansion for when MACRO-NAME is invoked). # No SEPARATOR is output if MACRO-NAME was previously undefined (different # than defined and empty). # # This macro is needed until we can rely on Autoconf 2.62, since earlier # versions of m4sugar mistakenly expanded SEPARATOR but not STRING. m4_define([lt_append], [m4_define([$1], m4_ifdef([$1], [m4_defn([$1])[$3]])[$2])]) # lt_combine(SEP, PREFIX-LIST, INFIX, SUFFIX1, [SUFFIX2...]) # ---------------------------------------------------------- # Produce a SEP delimited list of all paired combinations of elements of # PREFIX-LIST with SUFFIX1 through SUFFIXn. Each element of the list # has the form PREFIXmINFIXSUFFIXn. # Needed until we can rely on m4_combine added in Autoconf 2.62. m4_define([lt_combine], [m4_if(m4_eval([$# > 3]), [1], [m4_pushdef([_Lt_sep], [m4_define([_Lt_sep], m4_defn([lt_car]))])]]dnl [[m4_foreach([_Lt_prefix], [$2], [m4_foreach([_Lt_suffix], ]m4_dquote(m4_dquote(m4_shift(m4_shift(m4_shift($@)))))[, [_Lt_sep([$1])[]m4_defn([_Lt_prefix])[$3]m4_defn([_Lt_suffix])])])])]) # lt_if_append_uniq(MACRO-NAME, VARNAME, [SEPARATOR], [UNIQ], [NOT-UNIQ]) # ----------------------------------------------------------------------- # Iff MACRO-NAME does not yet contain VARNAME, then append it (delimited # by SEPARATOR if supplied) and expand UNIQ, else NOT-UNIQ. m4_define([lt_if_append_uniq], [m4_ifdef([$1], [m4_if(m4_index([$3]m4_defn([$1])[$3], [$3$2$3]), [-1], [lt_append([$1], [$2], [$3])$4], [$5])], [lt_append([$1], [$2], [$3])$4])]) # lt_dict_add(DICT, KEY, VALUE) # ----------------------------- m4_define([lt_dict_add], [m4_define([$1($2)], [$3])]) # lt_dict_add_subkey(DICT, KEY, SUBKEY, VALUE) # -------------------------------------------- m4_define([lt_dict_add_subkey], [m4_define([$1($2:$3)], [$4])]) # lt_dict_fetch(DICT, KEY, [SUBKEY]) # ---------------------------------- m4_define([lt_dict_fetch], [m4_ifval([$3], m4_ifdef([$1($2:$3)], [m4_defn([$1($2:$3)])]), m4_ifdef([$1($2)], [m4_defn([$1($2)])]))]) # lt_if_dict_fetch(DICT, KEY, [SUBKEY], VALUE, IF-TRUE, [IF-FALSE]) # ----------------------------------------------------------------- m4_define([lt_if_dict_fetch], [m4_if(lt_dict_fetch([$1], [$2], [$3]), [$4], [$5], [$6])]) # lt_dict_filter(DICT, [SUBKEY], VALUE, [SEPARATOR], KEY, [...]) # -------------------------------------------------------------- m4_define([lt_dict_filter], [m4_if([$5], [], [], [lt_join(m4_quote(m4_default([$4], [[, ]])), lt_unquote(m4_split(m4_normalize(m4_foreach(_Lt_key, lt_car([m4_shiftn(4, $@)]), [lt_if_dict_fetch([$1], _Lt_key, [$2], [$3], [_Lt_key ])])))))])[]dnl ]) # ltversion.m4 -- version numbers -*- Autoconf -*- # # Copyright (C) 2004 Free Software Foundation, Inc. # Written by Scott James Remnant, 2004 # # This file is free software; the Free Software Foundation gives # unlimited permission to copy and/or distribute it, with or without # modifications, as long as this notice is preserved. # @configure_input@ # serial 3337 ltversion.m4 # This file is part of GNU Libtool m4_define([LT_PACKAGE_VERSION], [2.4.2]) m4_define([LT_PACKAGE_REVISION], [1.3337]) AC_DEFUN([LTVERSION_VERSION], [macro_version='2.4.2' macro_revision='1.3337' _LT_DECL(, macro_version, 0, [Which release of libtool.m4 was used?]) _LT_DECL(, macro_revision, 0) ]) # lt~obsolete.m4 -- aclocal satisfying obsolete definitions. -*-Autoconf-*- # # Copyright (C) 2004, 2005, 2007, 2009 Free Software Foundation, Inc. # Written by Scott James Remnant, 2004. # # This file is free software; the Free Software Foundation gives # unlimited permission to copy and/or distribute it, with or without # modifications, as long as this notice is preserved. # serial 5 lt~obsolete.m4 # These exist entirely to fool aclocal when bootstrapping libtool. # # In the past libtool.m4 has provided macros via AC_DEFUN (or AU_DEFUN) # which have later been changed to m4_define as they aren't part of the # exported API, or moved to Autoconf or Automake where they belong. # # The trouble is, aclocal is a bit thick. It'll see the old AC_DEFUN # in /usr/share/aclocal/libtool.m4 and remember it, then when it sees us # using a macro with the same name in our local m4/libtool.m4 it'll # pull the old libtool.m4 in (it doesn't see our shiny new m4_define # and doesn't know about Autoconf macros at all.) # # So we provide this file, which has a silly filename so it's always # included after everything else. This provides aclocal with the # AC_DEFUNs it wants, but when m4 processes it, it doesn't do anything # because those macros already exist, or will be overwritten later. # We use AC_DEFUN over AU_DEFUN for compatibility with aclocal-1.6. # # Anytime we withdraw an AC_DEFUN or AU_DEFUN, remember to add it here. # Yes, that means every name once taken will need to remain here until # we give up compatibility with versions before 1.7, at which point # we need to keep only those names which we still refer to. # This is to help aclocal find these macros, as it can't see m4_define. AC_DEFUN([LTOBSOLETE_VERSION], [m4_if([1])]) m4_ifndef([AC_LIBTOOL_LINKER_OPTION], [AC_DEFUN([AC_LIBTOOL_LINKER_OPTION])]) m4_ifndef([AC_PROG_EGREP], [AC_DEFUN([AC_PROG_EGREP])]) m4_ifndef([_LT_AC_PROG_ECHO_BACKSLASH], [AC_DEFUN([_LT_AC_PROG_ECHO_BACKSLASH])]) m4_ifndef([_LT_AC_SHELL_INIT], [AC_DEFUN([_LT_AC_SHELL_INIT])]) m4_ifndef([_LT_AC_SYS_LIBPATH_AIX], [AC_DEFUN([_LT_AC_SYS_LIBPATH_AIX])]) m4_ifndef([_LT_PROG_LTMAIN], [AC_DEFUN([_LT_PROG_LTMAIN])]) m4_ifndef([_LT_AC_TAGVAR], [AC_DEFUN([_LT_AC_TAGVAR])]) m4_ifndef([AC_LTDL_ENABLE_INSTALL], [AC_DEFUN([AC_LTDL_ENABLE_INSTALL])]) m4_ifndef([AC_LTDL_PREOPEN], [AC_DEFUN([AC_LTDL_PREOPEN])]) m4_ifndef([_LT_AC_SYS_COMPILER], [AC_DEFUN([_LT_AC_SYS_COMPILER])]) m4_ifndef([_LT_AC_LOCK], [AC_DEFUN([_LT_AC_LOCK])]) m4_ifndef([AC_LIBTOOL_SYS_OLD_ARCHIVE], [AC_DEFUN([AC_LIBTOOL_SYS_OLD_ARCHIVE])]) m4_ifndef([_LT_AC_TRY_DLOPEN_SELF], [AC_DEFUN([_LT_AC_TRY_DLOPEN_SELF])]) m4_ifndef([AC_LIBTOOL_PROG_CC_C_O], [AC_DEFUN([AC_LIBTOOL_PROG_CC_C_O])]) m4_ifndef([AC_LIBTOOL_SYS_HARD_LINK_LOCKS], [AC_DEFUN([AC_LIBTOOL_SYS_HARD_LINK_LOCKS])]) m4_ifndef([AC_LIBTOOL_OBJDIR], [AC_DEFUN([AC_LIBTOOL_OBJDIR])]) m4_ifndef([AC_LTDL_OBJDIR], [AC_DEFUN([AC_LTDL_OBJDIR])]) m4_ifndef([AC_LIBTOOL_PROG_LD_HARDCODE_LIBPATH], [AC_DEFUN([AC_LIBTOOL_PROG_LD_HARDCODE_LIBPATH])]) m4_ifndef([AC_LIBTOOL_SYS_LIB_STRIP], [AC_DEFUN([AC_LIBTOOL_SYS_LIB_STRIP])]) m4_ifndef([AC_PATH_MAGIC], [AC_DEFUN([AC_PATH_MAGIC])]) m4_ifndef([AC_PROG_LD_GNU], [AC_DEFUN([AC_PROG_LD_GNU])]) m4_ifndef([AC_PROG_LD_RELOAD_FLAG], [AC_DEFUN([AC_PROG_LD_RELOAD_FLAG])]) m4_ifndef([AC_DEPLIBS_CHECK_METHOD], [AC_DEFUN([AC_DEPLIBS_CHECK_METHOD])]) m4_ifndef([AC_LIBTOOL_PROG_COMPILER_NO_RTTI], [AC_DEFUN([AC_LIBTOOL_PROG_COMPILER_NO_RTTI])]) m4_ifndef([AC_LIBTOOL_SYS_GLOBAL_SYMBOL_PIPE], [AC_DEFUN([AC_LIBTOOL_SYS_GLOBAL_SYMBOL_PIPE])]) m4_ifndef([AC_LIBTOOL_PROG_COMPILER_PIC], [AC_DEFUN([AC_LIBTOOL_PROG_COMPILER_PIC])]) m4_ifndef([AC_LIBTOOL_PROG_LD_SHLIBS], [AC_DEFUN([AC_LIBTOOL_PROG_LD_SHLIBS])]) m4_ifndef([AC_LIBTOOL_POSTDEP_PREDEP], [AC_DEFUN([AC_LIBTOOL_POSTDEP_PREDEP])]) m4_ifndef([LT_AC_PROG_EGREP], [AC_DEFUN([LT_AC_PROG_EGREP])]) m4_ifndef([LT_AC_PROG_SED], [AC_DEFUN([LT_AC_PROG_SED])]) m4_ifndef([_LT_CC_BASENAME], [AC_DEFUN([_LT_CC_BASENAME])]) m4_ifndef([_LT_COMPILER_BOILERPLATE], [AC_DEFUN([_LT_COMPILER_BOILERPLATE])]) m4_ifndef([_LT_LINKER_BOILERPLATE], [AC_DEFUN([_LT_LINKER_BOILERPLATE])]) m4_ifndef([_AC_PROG_LIBTOOL], [AC_DEFUN([_AC_PROG_LIBTOOL])]) m4_ifndef([AC_LIBTOOL_SETUP], [AC_DEFUN([AC_LIBTOOL_SETUP])]) m4_ifndef([_LT_AC_CHECK_DLFCN], [AC_DEFUN([_LT_AC_CHECK_DLFCN])]) m4_ifndef([AC_LIBTOOL_SYS_DYNAMIC_LINKER], [AC_DEFUN([AC_LIBTOOL_SYS_DYNAMIC_LINKER])]) m4_ifndef([_LT_AC_TAGCONFIG], [AC_DEFUN([_LT_AC_TAGCONFIG])]) m4_ifndef([AC_DISABLE_FAST_INSTALL], [AC_DEFUN([AC_DISABLE_FAST_INSTALL])]) m4_ifndef([_LT_AC_LANG_CXX], [AC_DEFUN([_LT_AC_LANG_CXX])]) m4_ifndef([_LT_AC_LANG_F77], [AC_DEFUN([_LT_AC_LANG_F77])]) m4_ifndef([_LT_AC_LANG_GCJ], [AC_DEFUN([_LT_AC_LANG_GCJ])]) m4_ifndef([AC_LIBTOOL_LANG_C_CONFIG], [AC_DEFUN([AC_LIBTOOL_LANG_C_CONFIG])]) m4_ifndef([_LT_AC_LANG_C_CONFIG], [AC_DEFUN([_LT_AC_LANG_C_CONFIG])]) m4_ifndef([AC_LIBTOOL_LANG_CXX_CONFIG], [AC_DEFUN([AC_LIBTOOL_LANG_CXX_CONFIG])]) m4_ifndef([_LT_AC_LANG_CXX_CONFIG], [AC_DEFUN([_LT_AC_LANG_CXX_CONFIG])]) m4_ifndef([AC_LIBTOOL_LANG_F77_CONFIG], [AC_DEFUN([AC_LIBTOOL_LANG_F77_CONFIG])]) m4_ifndef([_LT_AC_LANG_F77_CONFIG], [AC_DEFUN([_LT_AC_LANG_F77_CONFIG])]) m4_ifndef([AC_LIBTOOL_LANG_GCJ_CONFIG], [AC_DEFUN([AC_LIBTOOL_LANG_GCJ_CONFIG])]) m4_ifndef([_LT_AC_LANG_GCJ_CONFIG], [AC_DEFUN([_LT_AC_LANG_GCJ_CONFIG])]) m4_ifndef([AC_LIBTOOL_LANG_RC_CONFIG], [AC_DEFUN([AC_LIBTOOL_LANG_RC_CONFIG])]) m4_ifndef([_LT_AC_LANG_RC_CONFIG], [AC_DEFUN([_LT_AC_LANG_RC_CONFIG])]) m4_ifndef([AC_LIBTOOL_CONFIG], [AC_DEFUN([AC_LIBTOOL_CONFIG])]) m4_ifndef([_LT_AC_FILE_LTDLL_C], [AC_DEFUN([_LT_AC_FILE_LTDLL_C])]) m4_ifndef([_LT_REQUIRED_DARWIN_CHECKS], [AC_DEFUN([_LT_REQUIRED_DARWIN_CHECKS])]) m4_ifndef([_LT_AC_PROG_CXXCPP], [AC_DEFUN([_LT_AC_PROG_CXXCPP])]) m4_ifndef([_LT_PREPARE_SED_QUOTE_VARS], [AC_DEFUN([_LT_PREPARE_SED_QUOTE_VARS])]) m4_ifndef([_LT_PROG_ECHO_BACKSLASH], [AC_DEFUN([_LT_PROG_ECHO_BACKSLASH])]) m4_ifndef([_LT_PROG_F77], [AC_DEFUN([_LT_PROG_F77])]) m4_ifndef([_LT_PROG_FC], [AC_DEFUN([_LT_PROG_FC])]) m4_ifndef([_LT_PROG_CXX], [AC_DEFUN([_LT_PROG_CXX])]) ldns-1.6.17/Changelog0000664000175100017510000011131112264060151013723 0ustar willemwillem1.6.17 2014-01-10 * Fix ldns_dnssec_zone_new_frm_fp_l to allow the last parsed line of a zone to be an NSEC3 (or its RRSIG) covering an empty non terminal. * Add --disable-dane option to configure and check availability of the for dane needed X509_check_ca function in openssl. * bugfix #490: Get rid of type-punned pointer warnings. Thanks Adam Tkac. * Make sure executables are linked against libcrypto with the LIBSSL_LDFLAGS. Thanks Leo Baltus. * Miscellaneous prototype fixes. Thanks Dag-Erling Smørgrav. * README now shows preferred way to configure for examples and drill. * Bind to source address for resolvers. drill binds to source with -I. Thanks Bryan Duff. * -T option for ldns-dane that has specific exit status for PKIX validated connections without (secure) TLSA records. * Fix b{32,64}_{ntop,pton} detection and handling. * New RR type TKEY, but without operational practice. * New RR types HIP, NINFO, RKEY, CDS, EUI48, EUI64, URI, CAA and TA. * New output format flag (and accompanying functions) to print certain RR's as unknown type * -u and -U parameter for ldns-read-zone to mark/unmark a RR type for printing as unknown type * bugfix #504: GPOS RR has three rdata fields. Thanks Jelte Jansen. * bugfix #497: Properly test for EOF when reading key files with drill. * New functions: ldns_pkt_ixfr_request_new and ldns_pkt_ixfr_request_new_frm_str. * Use SNI with ldns-dane * bugfix #507: ldnsx Fix use of non-existent variables and not properly referring to instance variable. Patch from shussain. * bugfix #508: ldnsx Adding NSEC3PARAM to known/allowable RR type dictionary. Patch from shussain. * bugfix #517: ldns_resolver_new_frm_fp error when invoked using a NULL file pointer. * Fix memory leak in contrib/python: ldns_pkt.new_query. * Fix buffer overflow in fget_token and bget_token. * ldns-verify-zone NSEC3 checking from quadratic to linear performance. Thanks NIC MX (nicmexico.mx) * ldns-dane setup new ssl session for each new connect to prevent hangs * bugfix #521: drill trace continue on empty non-terminals with NSEC3 * bugfix #525: Fix documentation of ldns_resolver_set_retry * Remove unused LDNS_RDF_TYPE_TSIG and associated functions. * Fix ldns_nsec_covers_name for zones with an apex only. Thanks Miek. * Configure option to build perl bindings: --with-p5-dns-ldns (DNS::LDNS is a contribution from Erik Ostlyngen) * bugfix #527: Move -lssl before -lcrypto when linking * Optimize TSIG digest function name comparison (Thanks Marc Buijsman) * Compare names case insensitive with ldns_pkt_rr_list_by_name and ldns_pkt_rr_list_by_name_and_type (thanks Johannes Naab) * A separate --enable for each draft RR type: --enable-rrtype-ninfo, --enable-rrtype-rkey, --enable-rrtype-cds, --enable-rrtype-uri and --enable-rrtype-ta * bugfix #530: Don't sign and verify duplicate RRs (Thanks Jelte Jansen) * bugfix #505: Manpage and usage output fixes (Thanks Tomas Hozza) * Adjust ldns_sha1() so that the input data is not modified (Thanks Marc Buijsman) * Messages to stderr are now off by default and can be reenabled with the --enable-stderr-msgs configure option. 1.6.16 2012-11-13 * Fix Makefile to build pyldns with BSD make * Fix typo in exporting b32_* symbols to make pyldns load again * Allow leaving the RR owner name empty in ldns-testns datafiles. * Fix fail to create NSEC3 bitmap for empty non-terminal (bug introduced in 1.6.14). 1.6.15 2012-10-25 * Remove LDNS_STATUS_EXISTS_ERR from ldns/error.h to make ldns binary compatible with earlier releases again. 1.6.14 2012-10-23 * DANE support (RFC6698), including ldns-dane example tool. * Configurable default CA certificate repository for ldns-dane with --with-ca-file=CAFILE and --with-ca-path=CAPATH * Configurable default trust anchor with --with-trust-anchor=FILE for drill, ldns-verify-zone and ldns-dane * bugfix #474: Define socklen_t when undefined (like in Win32) * bugfix #473: Dead code removal and resource leak fix in drill * bugfix #471: Let ldns_resolver_push_dnssec_anchor accept DS RR's too. * Various bugfixes from code reviews from CZ.NIC and Paul Wouters * ldns-notify TSIG option argument checking * Let ldns_resolver_nameservers_randomize keep nameservers and rtt's in sync. * Let ldns_pkt_push_rr now return false on (memory) errors. * Make buffer_export comply to documentation and fix buffer2str * Various improvements and fixes of pyldns from Katel Slany now documented in their own Changelog. * bugfix: Make ldns_resolver_pop_nameserver clear the array when there was only one. * bugfix #459: Remove ldns_symbols and export symbols based on regex * bugfix #458: Track all newly created signatures when signing. * bugfix #454: Only set -g and -O2 CFLAGS when no CFLAGS was given. * bugfix #457: Memory leak fix for ldns_key_new_frm_algorithm. * pyldns memory handling fixes and the python3/ldns-signzone.py examples script contribution from Karel Slany. * bugfix #450: Base # bytes for P, G and Y (T) on the guaranteed to be bigger (or equal) P in ldns_key_dsa2bin. * bugfix #449: Deep free cloned rdf's in ldns_tsig_mac_new. * bugfix #448: Copy nameserver value (in stead of reference) of the answering nameserver to the answer packet in ldns_send_buffer, so the original value may be deep freed with the ldns_resolver struct. * New -0 option for ldns-read-zone to replace inception, expiration and signature rdata fields with (null). Thanks Paul Wouters. * New -p option for ldns-read-zone to prepend-pad SOA serial to take up ten characters. * Return error if printing RR fails due to unknown/null RDATA. 1.6.13 2012-05-21 * New -S option for ldns-verify-zone to chase signatures online. * New -k option for ldns-verify-zone to validate using a trusted key. * New inception and expiration margin options (-i and -e) to ldns-verify-zone. * New ldns_dnssec_zone_new_frm_fp and ldns_dnssec_zone_new_frm_fp_l functions. * New ldns_duration* functions (copied from OpenDNSSEC source) * fix ldns-verify-zone to allow NSEC3 signatures to come before the NSEC3 RR in all cases. Thanks Wolfgang Nagele. * Zero the correct flag (opt-out) when creating NSEC3PARAMS. Thanks Peter van Dijk. * Canonicalize RRSIG's Signer's name too when validating, because bind and unbound do that too. Thanks Peter van Dijk. * bugfix #433: Allocate rdf using ldns_rdf_new in ldns_dname_label * bugfix #432: Use LDNS_MALLOC & LDNS_FREE i.s.o. malloc & free * bugfix #431: Added error message for LDNS_STATUS_INVALID_B32_EXT * bugfix #427: Explicitely link ssl with the programs that use it. * Fix reading \DDD: Error on values that are outside range (>255). * bugfix #429: fix doxyparse.pl fails on NetBSD because specified path to perl. * New ECDSA support (RFC 6605), use --disable-ecdsa for older openssl. * fix verifying denial of existence for DS's in NSEC3 Opt-Out zones. Thanks John Barnitz 1.6.12 2012-01-11 * bugfix #413: Fix manpage source for srcdir != builddir * Canonicalize the signers name rdata field in RRSIGs when signing * Ignore minor version of Private-key-format (so v1.3 may be used) * Allow a check_time to be given in stead of always checking against the current time. With ldns-verify-zone the check_time can be set with the -t option. * Added functions for updating and manipulating SOA serial numbers. ldns-read-zone has an option -S for updating and manipulating the serial numbers. * The library Makefile is now GNU and BSD make compatible. * bugfix #419: NSEC3 validation of a name covered by a wildcard with no data. * Two new options (--with-drill and --with-examples) to the main configure script (in the root of the source tree) to build drill and examples too. * Fix days_since_epoch to year_yday calculation on 32bits systems. 1.6.11 2011-09-29 * bugfix #394: Fix socket leak on errors * bugfix #392: Apex only and percentage checks for ldns-verify-zone (thanks Miek Gieben) * bugfix #398: Allow NSEC RRSIGs before the NSEC3 in ldns-verify-zone * Fix python site package path from sitelib to sitearch for pyldns. * Fix python api to support python2 and python3 (thanks Karel Slany). * bugfix #401: Correction of date/time functions algorithm and prevention of an infinite loop therein * bugfix #402: Correct the minimum and maximum number of rdata fields in TSIG. (thanks David Keeler) * bugfix #403: Fix heap overflow (thanks David Keeler) * bugfix #404: Make parsing APL strings more robust (thanks David Keeler) * bugfix #391: Complete library assessment to prevent assertion errors through ldns_rdf_size usage. * Slightly more specific error messaging on wrong number of rdata fields with the LDNS_STATUS_MISSING_RDATA_FIELDS_RRSIG and LDNS_STATUS_MISSING_RDATA_FIELDS_KEY result codes. * bugfix #406: More rigorous openssl result code handling to prevent future crashes within openssl. * Fix ldns_fetch_valid_domain_keys to search deeper than just one level for a DNSKEY that signed a DS RR. (this function was used in the check_dnssec_trace nagios module) * bugfix #407: Canonicalize TSIG dnames and algorithm fields * A new output specifier to accommodate configuration of what to show in comment texts when converting host and/or wire-format data to string. All conversion to string and printing functions have a new version that have such a format specifier as an extra argument. The default is changed so that only DNSKEY RR's are annotated with an comment show the Key Tag of the DNSKEY. * Fixed the ldns resolver to not mark a nameserver unreachable when edns0 is tried unsuccessfully with size 4096 (no return packet came), but to still try TCP. A big UDP packet might have been corrupted by fragments dropping firewalls. * Update of libdns.vim (thanks Miek Gieben) * Added the ldnsx Python module to our contrib section, which adds even more pythonisticism to the usage of ldns with Python. (Many thanks to Christpher Olah and Paul Wouters) The ldnsx module is automatically installed when --with-pyldns is used with configuring, but may explicitly be excluded with the --without-pyldnsx option to configure. * bugfix #410: Fix clearing out temporary data on stack in sha2.c * bugfix #411: Don't let empty non-terminal NSEC3s cause assertion failure. 1.6.10 2011-05-31 * New example tool added: ldns-gen-zone. * bugfix #359: Serial-arithmetic for the inception and expiration fields of a RRSIG and correctly converting them to broken-out time information. * bugfix #364: Slight performance increase of ldns-verifyzone. * bugfix #367: Fix to allow glue records with the same name as the delegation. * Fix ldns-verifyzone to allow NSEC3-less records for NS rrsets *and* glue when the zone is opt-out. * bugfix #376: Adapt ldns_nsec3_salt, ldns_nsec3_iterations, ldns_nsec3_flags and ldns_nsec3_algorithm to work for NSEC3PARAMS too. * pyldns memory leaks fixed by Bedrich Kosata (at the cost of a bit performance) * Better handling of reference variables in ldns_rr_new_frm_fp_l from pyldns, with a very nice generator function by Bedrich Kosata. * Decoupling of the rdfs in rrs in the python wrappers to enable the python garbage collector by Bedrich Kosata. * bugfix #380: Minimizing effect of discrepancies in sizeof(bool) at build time and when used. * bugfix #383: Fix detection of empty nonterminals of multiple labels. * Fixed the ommission of rrsets in nsec(3)s and rrsigs to all occluded names (in stead of just the ones that contain glue only) and all occluded records on the delegation points (in stead of just the glue). * Clarify the operation of ldns_dnssec_mark_glue and the usage of ldns_dnssec_node_next_nonglue functions in the documentation. * Added function ldns_dnssec_mark_and_get_glue as an real fast alternative for ldns_zone_glue_rr_list. * Fix parse buffer overflow for max length domain names. * Fix Makefile for U in environment, since wrong U is more common than deansification necessity. 1.6.9 2011-03-16 * Fix creating NSEC(3) bitmaps: make array size 65536, don't add doubles. * Fix printout of escaped binary in TXT records. * Parsing TXT records: don't skip starting whitespace that is quoted. * bugfix #358: Check if memory was successfully allocated in ldns_rdf2str(). * Added more memory allocation checks in host2str.c * python wrapper for ldns_fetch_valid_domain_keys by Bedrich Kosata. * fix to compile python wrapper with swig 2.0.2. * Don't fallback to SHA-1 when creating NSEC3 hash with another algorithm identifier, fail instead (no other algorithm identifiers are assigned yet). 1.6.8 2011-01-24 * Fix ldns zone, so that $TTL definition match RFC 2308. * Fix lots of missing checks on allocation failures and parse of NSEC with many types and max parse length in hosts_frm_fp routine and off by one in read_anchor_file routine (thanks Dan Kaminsky and Justin Ferguson). * bugfix #335: Drill: Print both SHA-1 and SHA-256 corresponding DS records. * Print correct WHEN in query packet (is not always 1-1-1970) * ldns-test-edns: new example tool that detects EDNS support. * fix ldns_resolver_send without openssl. * bugfix #342: patch for support for more CERT key types (RFC4398). * bugfix #351: fix udp_send hang if UDP checksum error. * fix set_bit (from NSEC3 sign) patch from Jan Komissar. 1.6.7 2010-11-08 * EXPERIMENTAL ecdsa implementation, please do not enable on real servers. * GOST code enabled by default (RFC 5933). * bugfix #326: ignore whitespace between directives and their values. * Header comment to advertise ldns_axfr_complete to check for successfully completed zone transfers. * read resolv.conf skips interface labels, e.g. %eth0. * Fix drill verify NSEC3 denials. * Use closesocket() on windows. * Add ldns_get_signing_algorithm_by_name that understand aliases, names changed to RFC names and aliases for compatibility added. * bugfix: don't print final dot if the domain is relative. * bugfix: resolver search continue when packet rcode != NOERROR. * bugfix: resolver push all domains in search directive to list. * bugfix: resolver search by default includes the root domain. * bugfix: tcp read could fail on single octet recv. * bugfix: read of RR in unknown syntax with missing fields. * added ldns_pkt_tsig_sign_next() and ldns_pkt_tsig_verify_next() to sign and verify TSIG RRs on subsequent messages (section 4.4, RFC 2845, thanks to Michael Sheldon). * bugfix: signer sigs nsecs with zsks only. * bugfix #333: fix ldns_dname_absolute for name ending with backslash. 1.6.6 2010-08-09 * Fix ldns_rr_clone to copy question rrs properly. * Fix ldns_sign_zone(_nsec3) to clone the soa for the new zone. * Fix ldns_wire2dname size check from reading 1 byte beyond buffer end. * Fix ldns_wire2dname from reading 1 byte beyond end for pointer. * Fix crash using GOST for particular platform configurations. * extern C declarations used in the header file. * Removed debug fprintf from resolver.c. * ldns-signzone checks if public key file is for the right zone. * NETLDNS, .NET port of ldns functionality, by Alex Nicoll, in contrib. * Fix handling of comments in resolv.conf parse. * GOST code enabled if SSL recent, RFC 5933. * bugfix #317: segfault util.c ldns_init_random() fixed. * Fix ldns_tsig_mac_new: allocate enough memory for the hash, fix use of b64_pton_calculate_size. * Fix ldns_dname_cat: size calculation and handling of realloc(). * Fix ldns_rr_pop_rdf: fix handling of realloc(). * Fix ldns-signzone for single type key scheme: sign whole zone if there are only KSKs. * Fix ldns_resolver: also close socket if AXFR failed (if you don't, it would block subsequent transfers (thanks Roland van Rijswijk). * Fix drill: allow for a secure trace if you use DS records as trust anchors (thanks Jan Komissar). 1.6.5 2010-06-15 * Catch \X where X is a digit as an error. * Fix segfault when ip6 ldns resolver only has ip4 servers. * Fix NSEC record after DNSKEY at zone apex not properly signed. * Fix syntax error if last label too long and no dot at end of domain. * Fix parse of \# syntax with space for type LOC. * Fix ldns_dname_absolute for escape sequences, fixes some parse errs. * bugfix #297: linking ssl, bug due to patch submitted as #296. * bugfix #299: added missing declarations to host2str.h * ldns-compare-zones -s to not exclude SOA record from comparison. * --disable-rpath fix * fix ldns_pkt_empty(), reported by Alex Nicoll. * fix ldns_resolver_new_frm_fp not ignore lines after a comment. * python code for ldns_rr.new_question_frm_str() * Fix ldns_dnssec_verify_denial: the signature selection routine. * Type TALINK parsed (draft-ietf-dnsop-trust-history). * bugfix #304: fixed dead loop in ldns_tcp_read_wire() and ldns_tcp_read_wire_timeout(). * GOST support with correct algorithm numbers. The plan is to make it enabled if openssl support is detected, but it is disabled by default in this release because the RFC is not ready. * Fixed comment in rbtree.h about being first member and data ptr. * Fixed possibly leak in case of out of memory in ldns_native2rdf... * ldns_dname_is_wildcard added. * Fixed: signatures over wildcards had the wrong labelcount. * Fixed ldns_verify() inconsistent return values. * Fixed ldns_resolver to copy and free tsig name, data and algorithm. * Fixed ldns_resolver to push search onto searchlist. * A ldns resolver now defaults to a non-recursive resolver that handles the TC bit. * ldns_resolver_print() prints more details. * Fixed ldns_rdf2buffer_str_time(), which did not print timestamps on 64bit systems. * Make ldns_resolver_nameservers_randomize() more random. * bugfix #310: POSIX specifies NULL second argument of gettimeofday. * fix compiler warnings from llvm clang compiler. * bugfix #309: ldns_pkt_clone did not clone the tsig_rr. * Fix gentoo ebuild for drill, 'no m4 directory'. * bugfix #313: drill trace on an empty nonterminal continuation. 1.6.4 2010-01-20 * Imported pyldns contribution by Zdenek Vasicek and Karel Slany. Changed its configure and Makefile to fit into ldns. Added its dname_* methods to the rdf_* class (as is the ldns API). Changed swig destroy of ldns_buffer class to ldns_buffer_free. Declared ldns_pkt_all and ldns_pkt_all_noquestion so swig sees them. * Bugfix: parse PTR target of .tomhendrikx.nl with error not crash. * Bugfix: handle escaped characters in TXT rdata. * bug292: no longer crash on malformed domain names where a label is on position 255, which was a buffer overflow by one. * Fix ldns_get_rr_list_hosts_frm_fp_l (strncpy to strlcpy change), which fixes resolv.conf reading badly terminated string buffers. * Fix ldns_pkt_set_random_id to be more random, and a little faster, it did not do value 0 statistically correctly. * Fix ldns_rdf2native_sockaddr_storage to set sockaddr type to zeroes, for portability. * bug295: nsec3-hash routine no longer case sensitive. * bug298: drill failed nsec3 denial of existence proof. 1.6.3 2009-12-04 * Bugfix: allow for unknown resource records in zonefile with rdlen=0. * Bugfix: also mark an RR as question if it comes from the wire * Bugfix: NSEC3 bitmap contained NSEC * Bugfix: Inherit class when creating signatures 1.6.2 2009-11-12 * Fix Makefile patch from Havard Eidnes, better install.sh usage. * Fix parse error on SOA serial of 2910532839. Fix print of ';' and readback of '\;' in names, also for '\\'. Fix parse of '\(' and '\)' in names. Also for file read. Also '\.' * Fix signature creation when TTLs are different for RRs in RRset. * bug273: fix so EDNS rdata is included in pkt to wire conversion. * bug274: fix use of c++ keyword 'class' for RR class in the code. * bug275: fix memory leak of packet edns rdata. * Fix timeout procedure for TCP and AXFR on Solaris. * Fix occasional NSEC bitmap bogus * Fix rr comparing (was in reversed order since 1.6.0) * bug278: fix parsing HINFO rdata (and other cases). * Fix previous owner name: also pick up if owner name is @. * RFC5702: enabled sha2 functions by default. This requires OpenSSL 0.9.8 or higher. Reason for this default is the root to be signed with RSASHA256. * Fix various LDNS RR parsing issues: IPSECKEY, WKS, NSAP, very long lines * Fix: Make ldns_dname_is_subdomain case insensitive. * Fix ldns-verify-zone so that address records at zone NS set are not considered glue (Or glue records fall below delegation) * Fix LOC RR altitude printing. * Feature: Added period (e.g. '3m6d') support at explicit TTLs. * Feature: DNSKEY rrset by default signed with minimal signatures but -A option for ldns-signzone to sign it with all keys. This makes the DNSKEY responses smaller for signed domains. 1.6.1 2009-09-14 * --enable-gost : use the GOST algorithm (experimental). * Added some missing options to drill manpage * Some fixes to --without-ssl option * Fixed quote parsing withing strings * Bitmask fix in EDNS handling * Fixed non-fqdn domain name completion for rdata field domain names of length 1 * Fixed chain validation with SHA256 DS records 1.6.0 Additions: * Addition of an ldns-config script which gives cflags and libs values, for use in configure scripts for applications that use use ldns. Can be disabled with ./configure --disable-ldns-config * Added direct sha1, sha256, and sha512 support in ldns. With these functions, all NSEC3 functionality can still be used, even if ldns is built without OpenSSL. Thanks to OpenBSD, Steve Reid, and Aaron D. Gifford for the code. * Added reading/writing support for the SPF Resource Record * Base32 functions are now exported Bugfixes: * ldns_is_rrset did not go through the complete rrset, but only compared the first two records. Thanks to Olafur Gudmundsson for report and patch * Fixed a small memory bug in ldns_rr_list_subtype_by_rdf(), thanks to Marius Rieder for finding an patching this. * --without-ssl should now work. Make sure that examples/ and drill also get the --without-ssl flag on their configure, if this is used. * Some malloc() return value checks have been added * NSEC3 creation has been improved wrt to empty nonterminals, and opt-out. * Fixed a bug in the parser when reading large NSEC3 salt values. * Made the allowed length for domain names on wire and presentation format the same. Example tools: * ldns-key2ds can now also generate DS records for keys without the SEP flag * ldns-signzone now equalizes the TTL of the DNSKEY RRset (to the first non-default DNSKEY TTL value it sees) 1.5.1 Example tools: * ldns-signzone was broken in 1.5.0 for multiple keys, this has been repaired Build system: * Removed a small erroneous output warning in examples/configure and drill/configure 1.5.0 Bug fixes: * fixed a possible memory overflow in the RR parser * build flag fix for Sun Studio * fixed a building race condition in the copying of header files * EDNS0 extended rcode; the correct assembled code number is now printed (still in the EDNS0 field, though) * ldns_pkt_rr no longer leaks memory (in fact, it no longer copies anything all) API addition: * ldns_key now has support for 'external' data, in which case the OpenSSL EVP structures are not used; ldns_key_set_external_key() and ldns_key_external_key() * added ldns_key_get_file_base_name() which creates a 'default' filename base string for key storage, of the form "K++" * the ldns_dnssec_* family of structures now have deep_free() functions, which also free the ldns_rr's contained in them * there is now an ldns_match_wildcard() function, which checks whether a domain name matches a wildcard name * ldns_sign_public has been split up; this resulted in the addition of ldns_create_empty_rrsig() and ldns_sign_public_buffer() Examples: * ldns-signzone can now automatically add DNSKEY records when using an OpenSSL engine, as it already did when using key files * added new example tool: ldns-nsec3-hash * ldns-dpa can now filter on specific query name and types * ldnsd has fixes for the zone name, a fix for the return value of recvfrom(), and an memory initialization fix (Thanks to Colm MacCárthaigh for the patch) * Fixed memory leaks in ldnsd 1.4.1 Bug fixes: * fixed a build issue where ldns lib existence was done too early * removed unnecessary check for pcap.h * NSEC3 optout flag now correctly printed in string output * inttypes.h moved to configured inclusion * fixed NSEC3 type bitmaps for empty nonterminals and unsigned delegations API addition: * for that last fix, we added a new function ldns_dname_add_from() that can clone parts of a dname 1.4.0 Bug fixes: * sig chase return code fix (patch from Rafael Justo, bug id 189) * rdata.c memory leaks on error and allocation checks fixed (patch from Shane Kerr, bug id 188) * zone.c memory leaks on error and allocation checks fixed (patch from Shane Kerr, bug id 189) * ldns-zplit output and error messages fixed (patch from Shane Kerr, bug id 190) * Fixed potential buffer overflow in ldns_str2rdf_dname * Signing code no longer signs delegation NS rrsets * Some minor configure/makefile updates * Fixed a bug in the randomness initialization * Fixed a bug in the reading of resolv.conf * Fixed a bug concerning whitespace in zone data (with patch from Ondrej Sury, bug 213) * Fixed a small fallback problem in axfr client code API CHANGES: * added 2str convenience functions: - ldns_rr_type2str - ldns_rr_class2str - ldns_rr_type2buffer_str - ldns_rr_class2buffer_str * buffer2str() is now called ldns_buffer2str * base32 and base64 function names are now also prepended with ldns_ * ldns_rr_new_frm_str() now returns an error on missing RDATA fields. Since you cannot read QUESTION section RRs with this anymore, there is now a function called ldns_rr_new_question_frm_str() LIBRARY FEATURES: * DS RRs string representation now add bubblebabble in a comment (patch from Jakob Schlyter) * DLV RR type added * TCP fallback system has been improved * HMAC-SHA256 TSIG support has been added. * TTLS are now correcly set in NSEC(3) records when signing zones EXAMPLE TOOLS: * New example: ldns-revoke to revoke DNSKEYs according to RFC5011 * ldns-testpkts has been fixed and updated * ldns-signzone now has the option to not add the DNSKEY * ldns-signzone now has an (full zone only) opt-out option for NSEC3 * ldns-keygen can create HMAC-SHA1 and HMAC-SHA256 symmetric keys * ldns-walk output has been fixed * ldns-compare-zones has been fixed, and now has an option to show all differences (-a) * ldns-read-zone now has an option to print DNSSEC records only 1.3 Base library: * Added a new family of functions based around ldns_dnssec_zone, which is a new structure that keeps a zone sorted through an rbtree and links signatures and NSEC(3) records directly to their RRset. These functions all start with ldns_dnssec_ * ldns_zone_sign and ldns_zone_sign_nsec3 are now deprecated, but have been changed to internally use the new ldns_dnssec_zone_sign(_nsec3) * Moved some ldns_buffer functions inline, so a clean rebuild of applications relying on those is needed (otherwise you'll get linker errors) * ldns_dname_label now returns one extra (zero) byte, so it can be seen as an fqdn. * NSEC3 type code update for signing algorithms. * DSA key generation of DNSKEY RRs fixed (one byte too small). * Added support for RSA/SHA256 and RSA/SHA512, as specified in draft-ietf-dnsext-dnssec-rsasha256-04. The typecodes are not final, and this feature is not enabled by default. It can be enabled at compilation time with the flag --with-sha2 * Added 2wire_canonical family of functions that lowercase dnames in rdata fields in resource records of the types in the list in rfc3597 * Added base32 conversion functions. * Fixed DSA RRSIG conversion when calling OpenSSL Drill: * Chase output is completely different, it shows, in ascii, the relations in the trust hierarchy. Examples: * Added ldns-verify-zone, that can verify the internal DNSSEC records of a signed BIND-style zone file * ldns-keygen now takes an -a argument specifying the algorithm, instead of -R or -D. -a list show a list of supported algorithms * ldns-keygen now defaults to the exponent RSA_F4 instead of RSA_3 for RSA key generation * ldns-signzone now has support for HSMs * ldns-signzone uses the new ldns_dnssec_ structures and functions which improves its speed, and output; RRSIGS are now placed directly after their RRset, NSEC(3) records directly after the name they handle Contrib: * new contrib/ dir with user contributions * added compilation script for solaris (thanks to Jakob Schlyter) 28 Nov 2007 1.2.2: * Added support for HMAC-MD5 keys in generator * Added a new example tool (written by Ondrej Sury): ldns-compare-zones * ldns-keygen now checks key sizes for rfc conformancy * ldns-signzone outputs SSL error if present * Fixed manpages (thanks to Ondrej Sury) * Fixed Makefile for -j * Fixed a $ORIGIN error when reading zones * Fixed another off-by-one error 03 Oct 2007 1.2.1: * Fixed an offset error in rr comparison * Fixed ldns-read-zone exit code * Added check for availability of SHA256 hashing algorithm * Fixed ldns-key2ds -2 argument * Fixed $ORIGIN bug in .key files * Output algorithms as an integer instead of their mnemonic * Fixed a memory leak in dnssec code when SHA256 is not available * Updated fedora .spec file 11 Apr 2007 1.2.0: * canonicalization of rdata in DNSSEC functions now adheres to the rr type list in rfc3597, not rfc4035, which will be updated (see http://www.ops.ietf.org/lists/namedroppers/namedroppers.2007/msg00183.html) * ldns-walk now support dnames with maximum label length * ldnsd now takes an extra argument containing the address to listen on * signing no longer signs every rrset with KSK's, but only the DNSKEY rrset * ported to Solaris 10 * added ldns_send_buffer() function * added ldns-testpkts fake packet server * added ldns-notify to send NOTIFY packets * ldns-dpa can now accurately calculate the number of matches per second * libtool is now used for compilation too (still gcc, but not directly) * Bugfixes: - TSIG signing buffer size - resolv.conf reading (comments) - dname comparison off by one error - typo in keyfetchers output file name fixed (a . too much) - fixed zone file parser when comments contain ( or ) - fixed LOC RR type - fixed CERT RR type Drill: * drill prints error on failed axfr. * drill now accepts mangled packets with -f * old -c option (use tcp) changed to -t * -c option to specify alternative resolv.conf file added * feedback of signature chase improved * chaser now stops at root when no trusted keys are found instead of looping forever trying to find the DS for . * Fixed bugs: - wildcard on multiple labels signature verification - error in -f packet writing for malformed packets - made KSK check more resilient 7 Jul 2006: 1.1.0: ldns-team * Added tutorials and an introduction to the documentation * Added include/ and lib/ dirs so that you can compile against ldns without installing ldns on your system * Makefile updates * Starting usage of assert throughout the library to catch illegal calls * Solaris 9 testing was carried out. Ldns now compiles on that platform; some gnuism were identified and fixed. * The ldns_zone structure was stress tested. The current setup (ie. just a list of rrs) can scale to zone file in order of megabytes. Sorting such zone is still difficult. * Reading multiline b64 encoded rdata works. * OpenSSL was made optional, configure --without-ssl. Ofcourse all dnssec/tsig related functions are disabled * Building of examples and drill now happens with the same defines as the building of ldns itself. * Preliminary sha-256 support was added. Currently is your OpenSSL supports it, it is supported in the DS creation. * ldns_resolver_search was implemented * Fixed a lot of bugs Drill: * -r was killed in favor of -o
which allows for a header bits setting (and maybe more in the future) * DNSSEC is never automaticaly set, even when you query for DNSKEY/RRSIG or DS. * Implement a crude RTT check, it now distinguishes between reachable and unreachable. * A form of secure tracing was added * Secure Chasing has been improved * -x does a reverse lookup for the given IP address Examples: * ldns-dpa was added to the examples - this is the Dns Packet Analyzer tool. * ldnsd - as very, very simple nameserver impl. * ldns-zsplit - split zones for parrallel signing * ldns-zcat - cat split zones back together * ldns-keyfetcher - Fetches DNSKEY records with a few (non-strong, non-DNSSEC) anti-spoofing techniques. * ldns-walk - 'Walks' a DNSSEC signed zone * Added an all-static target to the makefile so you can use examples without installing the library * When building in the source tree or in a direct subdirectory of the build dir, configure does not need --with-ldns=../ anymore Code: * All networking code was moved to net.c * rdata.c: added asserts to the rdf set/get functions * const keyword was added to pointer arguments that aren't changed API: Changed: * renamed ldns/dns.h to ldns/ldns.h * ldns_rr_new_frm_str() is extented with an extra variable which in common use may be NULL. This trickles through to: o ldns_rr_new_frm_fp o ldns_rr_new_frm_fp_l Which also get an extra variable Also the function has been changed to return a status message. The compiled RR is returned in the first argument. * ldns_zone_new_frm_fp_l() and ldns_zone_new_frm_fp() are changed to return a status msg. * ldns_key_new_frm_fp is changed to return ldns_status and the actual key list in the first argument * ldns_rdata_new_frm_fp[_l]() are changed to return a status. the rdf is return in the first argument * ldns_resolver_new_frm_fp: same treatment: return status and the new resolver in the first argument * ldns_pkt_query_new_frm_str(): same: return status and the packet in the first arg * tsig.h: internal used functions are now static: ldns_digest_name and ldns_tsig_mac_new * ldns_key_rr2ds has an extra argument to specify the hash to use. * ldns_pkt_rcode() is renamed to ldns_pkt_get_rcode, ldns_pkt_rcode is now the rcode type, like ldns_pkt_opcode New: * ldns_resolver_searchlist_count: return the searchlist counter * ldns_zone_sort: Sort a zone * ldns_bgsend(): background send, returns a socket. * ldns_pkt_empty(): check is a packet is empty * ldns_rr_list_pop_rr_list(): pop multiple rr's from another rr_list * ldns_rr_list_push_rr_list(): push multiple rr's to an rr_list * ldns_rr_list_compare(): compare 2 ldns_rr_lists * ldns_pkt_push_rr_list: rr_list equiv for rr * ldns_pkt_safe_push_rr_list: rr_list equiv for rr Removed: * ldns_resolver_bgsend(): was not used in 1.0.0 and is not used now * ldns_udp_server_connect(): was faulty and isn't really part of the core ldns idea any how. * ldns_rr_list_insert_rr(): obsoleted, because not used. * char *_when was removed from the ldns_pkt structure 18 Oct 2005: 1.0.0: ldns-team * Commited a patch from HÃ¥kan Olsson * Added UPDATE support (Jakob Schlyter and HÃ¥kan Olsson) * License change: ldns is now BSD licensed * ldns now depends on SSL * Networking code cleanup, added (some) server udp/tcp support * A zone type is introduced. Currently this is a list of RRs, so it will not scale well. * [beta] Zonefile parsing was added * [tools] Drill was added to ldns - see drill/ * [tools] experimental signer was added * [building] better check for ssl * [building] major revision of build system * [building] added rpm .spec in packaging/ (thanks to Paul Wouters) * [building] A lot of cleanup in the build scripts (thanks to Jakob Schlyter and Paul Wouters) 28 Jul 2005: 0.70: ldns-team * [func] ldns_pkt_get_section now returns copies from the rrlists in the packet. This can be freed by the user program * [code] added ldns_ prefixes to function from util.h * [inst] removed documentation from default make install * Usual fixes in documentation and code 20 Jun 2005: 0.66: ldns-team Rel. Focus: drill-pre2 uses some functions which are not in 0.65 * dnssec_cd bit function was added * Zone infrastructure was added * Usual fixes in documentation and code 13 Jun 2005: 0.65: ldns-team * Repository is online at: http://www.nlnetlabs.nl/ldns/svn/ * Apply reference copying throuhgout ldns, except in 2 places in the ldns_resolver structure (._domain and ._nameservers) * Usual array of bugfixes * Documentation added * keygen.c added as an example for DNSSEC programming 23 May 2005: 0.60: ldns-team * Removed config.h from the header installed files (you're not supposed to include that in a libary) * Further tweaking - DNSSEC signing/verification works - Assorted bug fixes and tweaks (memory management) May 2005: 0.50: ldns-team * First usable release * Basic DNS functionality works * DNSSEC validation works ldns-1.6.17/ldns/0000775000175100017510000000000012264060171013055 5ustar willemwillemldns-1.6.17/ldns/rbtree.h0000664000175100017510000001650112264060151014512 0ustar willemwillem/* * rbtree.h -- generic red-black tree * * Copyright (c) 2001-2008, NLnet Labs. All rights reserved. * * This software is open source. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * Redistributions of source code must retain the above copyright notice, * this list of conditions and the following disclaimer. * * Redistributions in binary form must reproduce the above copyright notice, * this list of conditions and the following disclaimer in the documentation * and/or other materials provided with the distribution. * * Neither the name of the NLNET LABS nor the names of its contributors may * be used to endorse or promote products derived from this software without * specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. * */ /** * \file * Red black tree. Implementation taken from NSD 3.0.5, adjusted for use * in unbound (memory allocation, logging and so on). */ #ifndef LDNS_RBTREE_H_ #define LDNS_RBTREE_H_ #ifdef __cplusplus extern "C" { #endif /** * This structure must be the first member of the data structure in * the rbtree. This allows easy casting between an rbnode_t and the * user data (poor man's inheritance). * Or you can use the data pointer member to get to your data item. */ typedef struct ldns_rbnode_t ldns_rbnode_t; /** * The rbnode_t struct definition. */ struct ldns_rbnode_t { /** parent in rbtree, RBTREE_NULL for root */ ldns_rbnode_t *parent; /** left node (smaller items) */ ldns_rbnode_t *left; /** right node (larger items) */ ldns_rbnode_t *right; /** pointer to sorting key */ const void *key; /** pointer to data */ const void *data; /** colour of this node */ uint8_t color; }; /** The nullpointer, points to empty node */ #define LDNS_RBTREE_NULL &ldns_rbtree_null_node /** the global empty node */ extern ldns_rbnode_t ldns_rbtree_null_node; /** An entire red black tree */ typedef struct ldns_rbtree_t ldns_rbtree_t; /** definition for tree struct */ struct ldns_rbtree_t { /** The root of the red-black tree */ ldns_rbnode_t *root; /** The number of the nodes in the tree */ size_t count; /** * Key compare function. <0,0,>0 like strcmp. * Return 0 on two NULL ptrs. */ int (*cmp) (const void *, const void *); }; /** * Create new tree (malloced) with given key compare function. * @param cmpf: compare function (like strcmp) takes pointers to two keys. * @return: new tree, empty. */ ldns_rbtree_t *ldns_rbtree_create(int (*cmpf)(const void *, const void *)); /** * Free the complete tree (but not its keys) * @param rbtree The tree to free */ void ldns_rbtree_free(ldns_rbtree_t *rbtree); /** * Init a new tree (malloced by caller) with given key compare function. * @param rbtree: uninitialised memory for new tree, returned empty. * @param cmpf: compare function (like strcmp) takes pointers to two keys. */ void ldns_rbtree_init(ldns_rbtree_t *rbtree, int (*cmpf)(const void *, const void *)); /** * Insert data into the tree. * @param rbtree: tree to insert to. * @param data: element to insert. * @return: data ptr or NULL if key already present. */ ldns_rbnode_t *ldns_rbtree_insert(ldns_rbtree_t *rbtree, ldns_rbnode_t *data); /** * Insert data into the tree (reversed arguments, for use as callback) * \param[in] data element to insert * \param[out] rbtree tree to insert in to * \return data ptr or NULL if key is already present */ void ldns_rbtree_insert_vref(ldns_rbnode_t *data, void *rbtree); /** * Delete element from tree. * @param rbtree: tree to delete from. * @param key: key of item to delete. * @return: node that is now unlinked from the tree. User to delete it. * returns 0 if node not present */ ldns_rbnode_t *ldns_rbtree_delete(ldns_rbtree_t *rbtree, const void *key); /** * Find key in tree. Returns NULL if not found. * @param rbtree: tree to find in. * @param key: key that must match. * @return: node that fits or NULL. */ ldns_rbnode_t *ldns_rbtree_search(ldns_rbtree_t *rbtree, const void *key); /** * Find, but match does not have to be exact. * @param rbtree: tree to find in. * @param key: key to find position of. * @param result: set to the exact node if present, otherwise to element that * precedes the position of key in the tree. NULL if no smaller element. * @return: true if exact match in result. Else result points to <= element, * or NULL if key is smaller than the smallest key. */ int ldns_rbtree_find_less_equal(ldns_rbtree_t *rbtree, const void *key, ldns_rbnode_t **result); /** * Returns first (smallest) node in the tree * @param rbtree: tree * @return: smallest element or NULL if tree empty. */ ldns_rbnode_t *ldns_rbtree_first(ldns_rbtree_t *rbtree); /** * Returns last (largest) node in the tree * @param rbtree: tree * @return: largest element or NULL if tree empty. */ ldns_rbnode_t *ldns_rbtree_last(ldns_rbtree_t *rbtree); /** * Returns next larger node in the tree * @param rbtree: tree * @return: next larger element or NULL if no larger in tree. */ ldns_rbnode_t *ldns_rbtree_next(ldns_rbnode_t *rbtree); /** * Returns previous smaller node in the tree * @param rbtree: tree * @return: previous smaller element or NULL if no previous in tree. */ ldns_rbnode_t *ldns_rbtree_previous(ldns_rbnode_t *rbtree); /** * split off 'elements' number of elements from the start * of the name tree and return a new tree containing those * elements */ ldns_rbtree_t *ldns_rbtree_split(ldns_rbtree_t *tree, size_t elements); /** * add all node from the second tree to the first (removing them from the * second), and fix up nsec(3)s if present */ void ldns_rbtree_join(ldns_rbtree_t *tree1, ldns_rbtree_t *tree2); /** * Call with node=variable of struct* with rbnode_t as first element. * with type is the type of a pointer to that struct. */ #define LDNS_RBTREE_FOR(node, type, rbtree) \ for(node=(type)ldns_rbtree_first(rbtree); \ (ldns_rbnode_t*)node != LDNS_RBTREE_NULL; \ node = (type)ldns_rbtree_next((ldns_rbnode_t*)node)) /** * Call function for all elements in the redblack tree, such that * leaf elements are called before parent elements. So that all * elements can be safely free()d. * Note that your function must not remove the nodes from the tree. * Since that may trigger rebalances of the rbtree. * @param tree: the tree * @param func: function called with element and user arg. * The function must not alter the rbtree. * @param arg: user argument. */ void ldns_traverse_postorder(ldns_rbtree_t* tree, void (*func)(ldns_rbnode_t*, void*), void* arg); #ifdef __cplusplus } #endif #endif /* UTIL_RBTREE_H_ */ ldns-1.6.17/ldns/higher.h0000664000175100017510000000644112264060151014477 0ustar willemwillem/** * \file higher.h * * Specifies some higher level functions that could * be useful for certain applications */ /* * a Net::DNS like library for C * * (c) NLnet Labs, 2005-2006 * * See the file LICENSE for the license */ #ifndef LDNS_HIGHER_H #define LDNS_HIGHER_H #include #include #include #include #include #ifdef __cplusplus extern "C" { #endif /** * Ask the resolver about name * and return all address records * \param[in] r the resolver to use * \param[in] name the name to look for * \param[in] c the class to use * \param[in] flags give some optional flags to the query */ ldns_rr_list *ldns_get_rr_list_addr_by_name(ldns_resolver *r, ldns_rdf *name, ldns_rr_class c, uint16_t flags); /** * ask the resolver about the address * and return the name * \param[in] r the resolver to use * \param[in] addr the addr to look for * \param[in] c the class to use * \param[in] flags give some optional flags to the query */ ldns_rr_list *ldns_get_rr_list_name_by_addr(ldns_resolver *r, ldns_rdf *addr, ldns_rr_class c, uint16_t flags); /** * wade through fp (a /etc/hosts like file) * and return a rr_list containing all the * defined hosts in there * \param[in] fp the file pointer to use * \return ldns_rr_list * with the names */ ldns_rr_list *ldns_get_rr_list_hosts_frm_fp(FILE *fp); /** * wade through fp (a /etc/hosts like file) * and return a rr_list containing all the * defined hosts in there * \param[in] fp the file pointer to use * \param[in] line_nr pointer to an integer containing the current line number (for debugging purposes) * \return ldns_rr_list * with the names */ ldns_rr_list *ldns_get_rr_list_hosts_frm_fp_l(FILE *fp, int *line_nr); /** * wade through fp (a /etc/hosts like file) * and return a rr_list containing all the * defined hosts in there * \param[in] filename the filename to use (NULL for /etc/hosts) * \return ldns_rr_list * with the names */ ldns_rr_list *ldns_get_rr_list_hosts_frm_file(char *filename); /** * This function is a wrapper function for ldns_get_rr_list_name_by_addr * and ldns_get_rr_list_addr_by_name. It's name is from the getaddrinfo() * library call. It tries to mimic that call, but without the lowlevel * stuff. * \param[in] res The resolver. If this value is NULL then a resolver will * be created by ldns_getaddrinfo. * \param[in] node the name or ip address to look up * \param[in] c the class to look in * \param[out] list put the found RR's in this list * \return the number of RR found. */ uint16_t ldns_getaddrinfo(ldns_resolver *res, ldns_rdf *node, ldns_rr_class c, ldns_rr_list **list); /** * Check if t is enumerated in the nsec type rdata * \param[in] nsec the NSEC Record to look in * \param[in] t the type to check for * \return true when t is found, otherwise return false */ bool ldns_nsec_type_check(ldns_rr *nsec, ldns_rr_type t); /** * Print a number of rdf's of the RR. The rdfnum-list must * be ended by -1, otherwise unpredictable things might happen. * rdfs may be printed multiple times * \param[in] fp FILE * to write to * \param[in] r RR to write * \param[in] rdfnum a list of rdf to print. */ void ldns_print_rr_rdf(FILE *fp, ldns_rr *r, int rdfnum, ...); #ifdef __cplusplus } #endif #endif /* LDNS_HIGHER_H */ ldns-1.6.17/ldns/sha2.h0000664000175100017510000001261212264060151014063 0ustar willemwillem/* * FILE: sha2.h * AUTHOR: Aaron D. Gifford - http://www.aarongifford.com/ * * Copyright (c) 2000-2001, Aaron D. Gifford * All rights reserved. * * Modified by Jelte Jansen to fit in ldns, and not clash with any * system-defined SHA code. * Changes: * - Renamed (external) functions and constants to fit ldns style * - Removed uintXX vs. u_intXX smartness, since ldns needs uintXX * anyway * - BYTE ORDER check replaced by simple ifdef as defined or not by * configure.ac * - Removed _End and _Data functions * - Added ldns_shaX(data, len, digest) functions * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. Neither the name of the copyright holder nor the names of contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTOR(S) ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTOR(S) BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * $Id: sha2.h,v 1.1 2001/11/08 00:02:01 adg Exp adg $ */ #ifndef __LDNS_SHA2_H__ #define __LDNS_SHA2_H__ #ifdef __cplusplus extern "C" { #endif /* * Import u_intXX_t size_t type definitions from system headers. You * may need to change this, or define these things yourself in this * file. */ #include #if LDNS_BUILD_CONFIG_HAVE_INTTYPES_H #include #endif /* LDNS_BUILD_CONFIG_HAVE_INTTYPES_H */ /*** SHA-256/384/512 Various Length Definitions ***********************/ #define LDNS_SHA256_BLOCK_LENGTH 64 #define LDNS_SHA256_DIGEST_LENGTH 32 #define LDNS_SHA256_DIGEST_STRING_LENGTH (LDNS_SHA256_DIGEST_LENGTH * 2 + 1) #define LDNS_SHA384_BLOCK_LENGTH 128 #define LDNS_SHA384_DIGEST_LENGTH 48 #define LDNS_SHA384_DIGEST_STRING_LENGTH (LDNS_SHA384_DIGEST_LENGTH * 2 + 1) #define LDNS_SHA512_BLOCK_LENGTH 128 #define LDNS_SHA512_DIGEST_LENGTH 64 #define LDNS_SHA512_DIGEST_STRING_LENGTH (LDNS_SHA512_DIGEST_LENGTH * 2 + 1) /*** SHA-256/384/512 Context Structures *******************************/ typedef struct _ldns_sha256_CTX { uint32_t state[8]; uint64_t bitcount; uint8_t buffer[LDNS_SHA256_BLOCK_LENGTH]; } ldns_sha256_CTX; typedef struct _ldns_sha512_CTX { uint64_t state[8]; uint64_t bitcount[2]; uint8_t buffer[LDNS_SHA512_BLOCK_LENGTH]; } ldns_sha512_CTX; typedef ldns_sha512_CTX ldns_sha384_CTX; /*** SHA-256/384/512 Function Prototypes ******************************/ void ldns_sha256_init(ldns_sha256_CTX *); void ldns_sha256_update(ldns_sha256_CTX*, const uint8_t*, size_t); void ldns_sha256_final(uint8_t[LDNS_SHA256_DIGEST_LENGTH], ldns_sha256_CTX*); void ldns_sha384_init(ldns_sha384_CTX*); void ldns_sha384_update(ldns_sha384_CTX*, const uint8_t*, size_t); void ldns_sha384_final(uint8_t[LDNS_SHA384_DIGEST_LENGTH], ldns_sha384_CTX*); void ldns_sha512_init(ldns_sha512_CTX*); void ldns_sha512_update(ldns_sha512_CTX*, const uint8_t*, size_t); void ldns_sha512_final(uint8_t[LDNS_SHA512_DIGEST_LENGTH], ldns_sha512_CTX*); /** * Convenience function to digest a fixed block of data at once. * * \param[in] data the data to digest * \param[in] data_len the length of data in bytes * \param[out] digest the length of data in bytes * This pointer MUST have LDNS_SHA256_DIGEST_LENGTH bytes * available * \return the SHA1 digest of the given data */ unsigned char *ldns_sha256(unsigned char *data, unsigned int data_len, unsigned char *digest); /** * Convenience function to digest a fixed block of data at once. * * \param[in] data the data to digest * \param[in] data_len the length of data in bytes * \param[out] digest the length of data in bytes * This pointer MUST have LDNS_SHA384_DIGEST_LENGTH bytes * available * \return the SHA1 digest of the given data */ unsigned char *ldns_sha384(unsigned char *data, unsigned int data_len, unsigned char *digest); /** * Convenience function to digest a fixed block of data at once. * * \param[in] data the data to digest * \param[in] data_len the length of data in bytes * \param[out] digest the length of data in bytes * This pointer MUST have LDNS_SHA512_DIGEST_LENGTH bytes * available * \return the SHA1 digest of the given data */ unsigned char *ldns_sha512(unsigned char *data, unsigned int data_len, unsigned char *digest); #ifdef __cplusplus } #endif /* __cplusplus */ #endif /* __LDNS_SHA2_H__ */ ldns-1.6.17/ldns/dnssec_zone.h0000664000175100017510000003455512264060151015552 0ustar willemwillem/* * special zone file structures and functions for better dnssec handling * * A zone contains a SOA dnssec_zone_rrset, and an AVL tree of 'normal' * dnssec_zone_rrsets, indexed by name and type */ #ifndef LDNS_DNSSEC_ZONE_H #define LDNS_DNSSEC_ZONE_H #include #include #ifdef __cplusplus extern "C" { #endif /** * Singly linked list of rrs */ typedef struct ldns_struct_dnssec_rrs ldns_dnssec_rrs; struct ldns_struct_dnssec_rrs { ldns_rr *rr; ldns_dnssec_rrs *next; }; /** * Singly linked list of RRsets */ typedef struct ldns_struct_dnssec_rrsets ldns_dnssec_rrsets; struct ldns_struct_dnssec_rrsets { ldns_dnssec_rrs *rrs; ldns_rr_type type; ldns_dnssec_rrs *signatures; ldns_dnssec_rrsets *next; }; /** * Structure containing all resource records for a domain name * Including the derived NSEC3, if present */ typedef struct ldns_struct_dnssec_name ldns_dnssec_name; struct ldns_struct_dnssec_name { /** * pointer to a dname containing the name. * Usually points to the owner name of the first RR of the first RRset */ ldns_rdf *name; /** * Usually, the name is a pointer to the owner name of the first rr for * this name, but sometimes there is no actual data to point to, * for instance in * names representing empty nonterminals. If so, set alloced to true to * indicate that this data must also be freed when the name is freed */ bool name_alloced; /** * The rrsets for this name */ ldns_dnssec_rrsets *rrsets; /** * NSEC pointing to the next name (or NSEC3 pointing to the next NSEC3) */ ldns_rr *nsec; /** * signatures for the NSEC record */ ldns_dnssec_rrs *nsec_signatures; /** * Unlike what the name is_glue suggests, this field is set to true by * ldns_dnssec_zone_mark_glue() or ldns_dnssec_zone_mark_and_get_glue() * when the name, this dnssec_name struct represents, is occluded. * Names that contain other occluded rrsets and records with glue on * the delegation point will NOT have this bool set to true. * This field should NOT be read directly, but only via the * ldns_dnssec_name_is_glue() function! */ bool is_glue; /** * pointer to store the hashed name (only used when in an NSEC3 zone */ ldns_rdf *hashed_name; }; /** * Structure containing a dnssec zone */ struct ldns_struct_dnssec_zone { /** points to the name containing the SOA RR */ ldns_dnssec_name *soa; /** tree of ldns_dnssec_names */ ldns_rbtree_t *names; /** tree of ldns_dnssec_names by nsec3 hashes (when applicible) */ ldns_rbtree_t *hashed_names; /** points to the first added NSEC3 rr whose parameters will be * assumed for all subsequent NSEC3 rr's and which will be used * to calculate hashed names */ ldns_rr *_nsec3params; }; typedef struct ldns_struct_dnssec_zone ldns_dnssec_zone; /** * Creates a new entry for 1 pointer to an rr and 1 pointer to the next rrs * \return the allocated data */ ldns_dnssec_rrs *ldns_dnssec_rrs_new(void); /** * Frees the list of rrs, but *not* the individual ldns_rr records * contained in the list * * \param[in] rrs the data structure to free */ void ldns_dnssec_rrs_free(ldns_dnssec_rrs *rrs); /** * Frees the list of rrs, and the individual ldns_rr records * contained in the list * * \param[in] rrs the data structure to free */ void ldns_dnssec_rrs_deep_free(ldns_dnssec_rrs *rrs); /** * Adds an RR to the list of RRs. The list will remain ordered. * If an equal RR already exists, this RR will not be added. * * \param[in] rrs the list to add to * \param[in] rr the RR to add * \return LDNS_STATUS_OK on success */ ldns_status ldns_dnssec_rrs_add_rr(ldns_dnssec_rrs *rrs, ldns_rr *rr); /** * Prints the given rrs to the file descriptor * * \param[in] out the file descriptor to print to * \param[in] rrs the list of RRs to print */ void ldns_dnssec_rrs_print(FILE *out, ldns_dnssec_rrs *rrs); /** * Prints the given rrs to the file descriptor * * \param[in] out the file descriptor to print to * \param[in] fmt the format of the textual representation * \param[in] rrs the list of RRs to print */ void ldns_dnssec_rrs_print_fmt(FILE *out, const ldns_output_format *fmt, ldns_dnssec_rrs *rrs); /** * Creates a new list (entry) of RRsets * \return the newly allocated structure */ ldns_dnssec_rrsets *ldns_dnssec_rrsets_new(void); /** * Frees the list of rrsets and their rrs, but *not* the ldns_rr * records in the sets * * \param[in] rrsets the data structure to free */ void ldns_dnssec_rrsets_free(ldns_dnssec_rrsets *rrsets); /** * Frees the list of rrsets and their rrs, and the ldns_rr * records in the sets * * \param[in] rrsets the data structure to free */ void ldns_dnssec_rrsets_deep_free(ldns_dnssec_rrsets *rrsets); /** * Returns the rr type of the rrset (that is head of the given list) * * \param[in] rrsets the rrset to get the type of * \return the rr type */ ldns_rr_type ldns_dnssec_rrsets_type(ldns_dnssec_rrsets *rrsets); /** * Sets the RR type of the rrset (that is head of the given list) * * \param[in] rrsets the rrset to set the type of * \param[in] type the type to set * \return LDNS_STATUS_OK on success */ ldns_status ldns_dnssec_rrsets_set_type(ldns_dnssec_rrsets *rrsets, ldns_rr_type type); /** * Add an ldns_rr to the corresponding RRset in the given list of RRsets. * If it is not present, add it as a new RRset with 1 record. * * \param[in] rrsets the list of rrsets to add the RR to * \param[in] rr the rr to add to the list of rrsets * \return LDNS_STATUS_OK on success */ ldns_status ldns_dnssec_rrsets_add_rr(ldns_dnssec_rrsets *rrsets, ldns_rr *rr); /** * Print the given list of rrsets to the fiven file descriptor * * \param[in] out the file descriptor to print to * \param[in] rrsets the list of RRsets to print * \param[in] follow if set to false, only print the first RRset */ void ldns_dnssec_rrsets_print(FILE *out, ldns_dnssec_rrsets *rrsets, bool follow); /** * Print the given list of rrsets to the fiven file descriptor * * \param[in] out the file descriptor to print to * \param[in] fmt the format of the textual representation * \param[in] rrsets the list of RRsets to print * \param[in] follow if set to false, only print the first RRset */ void ldns_dnssec_rrsets_print_fmt(FILE *out, const ldns_output_format *fmt, ldns_dnssec_rrsets *rrsets, bool follow); /** * Create a new data structure for a dnssec name * \return the allocated structure */ ldns_dnssec_name *ldns_dnssec_name_new(void); /** * Create a new data structure for a dnssec name for the given RR * * \param[in] rr the RR to derive properties from, and to add to the name */ ldns_dnssec_name *ldns_dnssec_name_new_frm_rr(ldns_rr *rr); /** * Frees the name structure and its rrs and rrsets. * Individual ldns_rr records therein are not freed * * \param[in] name the structure to free */ void ldns_dnssec_name_free(ldns_dnssec_name *name); /** * Frees the name structure and its rrs and rrsets. * Individual ldns_rr records contained in the name are also freed * * \param[in] name the structure to free */ void ldns_dnssec_name_deep_free(ldns_dnssec_name *name); /** * Returns the domain name of the given dnssec_name structure * * \param[in] name the dnssec name to get the domain name from * \return the domain name */ ldns_rdf *ldns_dnssec_name_name(ldns_dnssec_name *name); /** * Sets the domain name of the given dnssec_name structure * * \param[in] name the dnssec name to set the domain name of * \param[in] dname the domain name to set it to. This data is *not* copied. */ void ldns_dnssec_name_set_name(ldns_dnssec_name *name, ldns_rdf *dname); /** * Returns if dnssec_name structure is marked as glue. * The ldns_dnssec_zone_mark_glue() function has to be called on a zone before * using this function. * Only names that have only glue rrsets will be marked. * Names that have other occluded rrsets and names containing glue on the * delegation point will NOT be marked! * * \param[in] name the dnssec name to get the domain name from * \return true if the structure is marked as glue, false otherwise. */ bool ldns_dnssec_name_is_glue(ldns_dnssec_name *name); /** * Sets the NSEC(3) RR of the given dnssec_name structure * * \param[in] name the dnssec name to set the domain name of * \param[in] nsec the nsec rr to set it to. This data is *not* copied. */ void ldns_dnssec_name_set_nsec(ldns_dnssec_name *name, ldns_rr *nsec); /** * Compares the domain names of the two arguments in their * canonical ordening. * * \param[in] a The first dnssec_name to compare * \param[in] b The second dnssec_name to compare * \return -1 if the domain name of a comes before that of b in canonical * ordening, 1 if it is the other way around, and 0 if they are * equal */ int ldns_dnssec_name_cmp(const void *a, const void *b); /** * Inserts the given rr at the right place in the current dnssec_name * No checking is done whether the name matches * * \param[in] name The ldns_dnssec_name to add the RR to * \param[in] rr The RR to add * \return LDNS_STATUS_OK on success, error code otherwise */ ldns_status ldns_dnssec_name_add_rr(ldns_dnssec_name *name, ldns_rr *rr); /** * Find the RRset with the given type in within this name structure * * \param[in] name the name to find the RRset in * \param[in] type the type of the RRset to find * \return the RRset, or NULL if not present */ ldns_dnssec_rrsets *ldns_dnssec_name_find_rrset(ldns_dnssec_name *name, ldns_rr_type type); /** * Find the RRset with the given name and type in the zone * * \param[in] zone the zone structure to find the RRset in * \param[in] dname the domain name of the RRset to find * \param[in] type the type of the RRset to find * \return the RRset, or NULL if not present */ ldns_dnssec_rrsets *ldns_dnssec_zone_find_rrset(ldns_dnssec_zone *zone, ldns_rdf *dname, ldns_rr_type type); /** * Prints the RRs in the dnssec name structure to the given * file descriptor * * \param[in] out the file descriptor to print to * \param[in] name the name structure to print the contents of */ void ldns_dnssec_name_print(FILE *out, ldns_dnssec_name *name); /** * Prints the RRs in the dnssec name structure to the given * file descriptor * * \param[in] out the file descriptor to print to * \param[in] fmt the format of the textual representation * \param[in] name the name structure to print the contents of */ void ldns_dnssec_name_print_fmt(FILE *out, const ldns_output_format *fmt, ldns_dnssec_name *name); /** * Creates a new dnssec_zone structure * \return the allocated structure */ ldns_dnssec_zone *ldns_dnssec_zone_new(void); /** * Create a new dnssec zone from a file. * \param[out] z the new zone * \param[in] *fp the filepointer to use * \param[in] *origin the zones' origin * \param[in] c default class to use (IN) * \param[in] ttl default ttl to use * * \return ldns_status mesg with an error or LDNS_STATUS_OK */ ldns_status ldns_dnssec_zone_new_frm_fp(ldns_dnssec_zone** z, FILE* fp, ldns_rdf* origin, uint32_t ttl, ldns_rr_class c); /** * Create a new dnssec zone from a file, keep track of the line numbering * \param[out] z the new zone * \param[in] *fp the filepointer to use * \param[in] *origin the zones' origin * \param[in] ttl default ttl to use * \param[in] c default class to use (IN) * \param[out] line_nr used for error msg, to get to the line number * * \return ldns_status mesg with an error or LDNS_STATUS_OK */ ldns_status ldns_dnssec_zone_new_frm_fp_l(ldns_dnssec_zone** z, FILE* fp, ldns_rdf* origin, uint32_t ttl, ldns_rr_class c, int* line_nr); /** * Frees the given zone structure, and its rbtree of dnssec_names * Individual ldns_rr RRs within those names are *not* freed * \param[in] *zone the zone to free */ void ldns_dnssec_zone_free(ldns_dnssec_zone *zone); /** * Frees the given zone structure, and its rbtree of dnssec_names * Individual ldns_rr RRs within those names are also freed * \param[in] *zone the zone to free */ void ldns_dnssec_zone_deep_free(ldns_dnssec_zone *zone); /** * Adds the given RR to the zone. * It find whether there is a dnssec_name with that name present. * If so, add it to that, if not create a new one. * Special handling of NSEC and RRSIG provided * * \param[in] zone the zone to add the RR to * \param[in] rr The RR to add * \return LDNS_STATUS_OK on success, an error code otherwise */ ldns_status ldns_dnssec_zone_add_rr(ldns_dnssec_zone *zone, ldns_rr *rr); /** * Prints the rbtree of ldns_dnssec_name structures to the file descriptor * * \param[in] out the file descriptor to print the names to * \param[in] tree the tree of ldns_dnssec_name structures to print * \param[in] print_soa if true, print SOA records, if false, skip them */ void ldns_dnssec_zone_names_print(FILE *out, ldns_rbtree_t *tree, bool print_soa); /** * Prints the rbtree of ldns_dnssec_name structures to the file descriptor * * \param[in] out the file descriptor to print the names to * \param[in] fmt the format of the textual representation * \param[in] tree the tree of ldns_dnssec_name structures to print * \param[in] print_soa if true, print SOA records, if false, skip them */ void ldns_dnssec_zone_names_print_fmt(FILE *out, const ldns_output_format *fmt, ldns_rbtree_t *tree, bool print_soa); /** * Prints the complete zone to the given file descriptor * * \param[in] out the file descriptor to print to * \param[in] zone the dnssec_zone to print */ void ldns_dnssec_zone_print(FILE *out, ldns_dnssec_zone *zone); /** * Prints the complete zone to the given file descriptor * * \param[in] out the file descriptor to print to * \param[in] fmt the format of the textual representation * \param[in] zone the dnssec_zone to print */ void ldns_dnssec_zone_print_fmt(FILE *out, const ldns_output_format *fmt, ldns_dnssec_zone *zone); /** * Adds explicit dnssec_name structures for the empty nonterminals * in this zone. (this is needed for NSEC3 generation) * * \param[in] zone the zone to check for empty nonterminals * return LDNS_STATUS_OK on success. */ ldns_status ldns_dnssec_zone_add_empty_nonterminals(ldns_dnssec_zone *zone); /** * If a NSEC3PARAM is available in the apex, walks the zone and returns true * on the first optout nsec3. * * \param[in] zone the zone to check for nsec3 optout records * return true when the zone has at least one nsec3 optout record. */ bool ldns_dnssec_zone_is_nsec3_optout(ldns_dnssec_zone* zone); #ifdef __cplusplus } #endif #endif ldns-1.6.17/ldns/duration.h0000664000175100017510000000565012264060151015057 0ustar willemwillem/* * $Id: duration.h 4341 2011-01-31 15:21:09Z matthijs $ * * Copyright (c) 2009 NLNet Labs. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * */ /** * * This file is copied from the OpenDNSSEC source repository * and only slightly adapted to make it fit. */ /** * * Durations. */ #ifndef LDNS_DURATION_H #define LDNS_DURATION_H #include #include /** * Duration. * */ typedef struct ldns_duration_struct ldns_duration_type; struct ldns_duration_struct { time_t years; time_t months; time_t weeks; time_t days; time_t hours; time_t minutes; time_t seconds; }; /** * Create a new 'instant' duration. * \return ldns_duration_type* created duration * */ ldns_duration_type* ldns_duration_create(void); /** * Compare durations. * \param[in] d1 one duration * \param[in] d2 another duration * \return int 0 if equal, -1 if d1 < d2, 1 if d2 < d1 * */ int ldns_duration_compare(ldns_duration_type* d1, ldns_duration_type* d2); /** * Create a duration from string. * \param[in] str string-format duration * \return ldns_duration_type* created duration * */ ldns_duration_type* ldns_duration_create_from_string(const char* str); /** * Convert a duration to a string. * \param[in] duration duration to be converted * \return char* string-format duration * */ char* ldns_duration2string(ldns_duration_type* duration); /** * Convert a duration to a time. * \param[in] duration duration to be converted * \return time_t time-format duration * */ time_t ldns_duration2time(ldns_duration_type* duration); /** * Clean up duration. * \param[in] duration duration to be cleaned up * */ void ldns_duration_cleanup(ldns_duration_type* duration); #endif /* LDNS_DURATION_H */ ldns-1.6.17/ldns/dnssec_sign.h0000664000175100017510000003414012264060151015525 0ustar willemwillem/** dnssec_verify */ #ifndef LDNS_DNSSEC_SIGN_H #define LDNS_DNSSEC_SIGN_H #include #ifdef __cplusplus extern "C" { #endif /* sign functions */ /** Sign flag that makes DNSKEY type signed by all keys, not only by SEP keys*/ #define LDNS_SIGN_DNSKEY_WITH_ZSK 1 /** * Create an empty RRSIG RR (i.e. without the actual signature data) * \param[in] rrset The RRset to create the signature for * \param[in] key The key that will create the signature * \return signature rr */ ldns_rr * ldns_create_empty_rrsig(ldns_rr_list *rrset, ldns_key *key); /** * Sign the buffer which contains the wiredata of an rrset, and the * corresponding empty rrsig rr with the given key * \param[in] sign_buf the buffer with data to sign * \param[in] key the key to sign with * \return an rdata field with the signature data */ ldns_rdf * ldns_sign_public_buffer(ldns_buffer *sign_buf, ldns_key *key); /** * Sign an rrset * \param[in] rrset the rrset * \param[in] keys the keys to use * \return a rr_list with the signatures */ ldns_rr_list *ldns_sign_public(ldns_rr_list *rrset, ldns_key_list *keys); #if LDNS_BUILD_CONFIG_HAVE_SSL /** * Sign a buffer with the DSA key (hash with SHA1) * \param[in] to_sign buffer with the data * \param[in] key the key to use * \return a ldns_rdf with the signed data */ ldns_rdf *ldns_sign_public_dsa(ldns_buffer *to_sign, DSA *key); /** * Sign data with EVP (general method for different algorithms) * * \param[in] to_sign The ldns_buffer containing raw data that is * to be signed * \param[in] key The EVP_PKEY key structure to sign with * \param[in] digest_type The digest algorithm to use in the creation of * the signature * \return ldns_rdf for the RRSIG ldns_rr */ ldns_rdf *ldns_sign_public_evp(ldns_buffer *to_sign, EVP_PKEY *key, const EVP_MD *digest_type); /** * Sign a buffer with the RSA key (hash with SHA1) * \param[in] to_sign buffer with the data * \param[in] key the key to use * \return a ldns_rdf with the signed data */ ldns_rdf *ldns_sign_public_rsasha1(ldns_buffer *to_sign, RSA *key); /** * Sign a buffer with the RSA key (hash with MD5) * \param[in] to_sign buffer with the data * \param[in] key the key to use * \return a ldns_rdf with the signed data */ ldns_rdf *ldns_sign_public_rsamd5(ldns_buffer *to_sign, RSA *key); #endif /* LDNS_BUILD_CONFIG_HAVE_SSL */ /** * Marks the names in the zone that are occluded. Those names will be skipped * when walking the tree with the ldns_dnssec_name_node_next_nonglue() * function. But watch out! Names that are partially occluded (like glue with * the same name as the delegation) will not be marked and should specifically * be taken into account separately. * * When glue_list is given (not NULL), in the process of marking the names, all * glue resource records will be pushed to that list, even glue at the delegation name. * * \param[in] zone the zone in which to mark the names * \param[in] glue_list the list to which to push the glue rrs * \return LDNS_STATUS_OK on success, an error code otherwise */ ldns_status ldns_dnssec_zone_mark_and_get_glue( ldns_dnssec_zone *zone, ldns_rr_list *glue_list); /** * Marks the names in the zone that are occluded. Those names will be skipped * when walking the tree with the ldns_dnssec_name_node_next_nonglue() * function. But watch out! Names that are partially occluded (like glue with * the same name as the delegation) will not be marked and should specifically * be taken into account separately. * * \param[in] zone the zone in which to mark the names * \return LDNS_STATUS_OK on succesful completion */ ldns_status ldns_dnssec_zone_mark_glue(ldns_dnssec_zone *zone); /** * Finds the first dnssec_name node in the rbtree that is not occluded. * It *does* return names that are partially occluded. * * \param[in] node the first node to check * \return the first node that has not been marked as glue, or NULL * if not found (TODO: make that LDNS_RBTREE_NULL?) */ ldns_rbnode_t *ldns_dnssec_name_node_next_nonglue(ldns_rbnode_t *node); /** * Adds NSEC records to the given dnssec_zone * * \param[in] zone the zone to add the records to * \param[in] new_rrs ldns_rr's created by this function are * added to this rr list, so the caller can free them later * \return LDNS_STATUS_OK on success, an error code otherwise */ ldns_status ldns_dnssec_zone_create_nsecs(ldns_dnssec_zone *zone, ldns_rr_list *new_rrs); /** * Adds NSEC3 records to the zone */ ldns_status ldns_dnssec_zone_create_nsec3s(ldns_dnssec_zone *zone, ldns_rr_list *new_rrs, uint8_t algorithm, uint8_t flags, uint16_t iterations, uint8_t salt_length, uint8_t *salt); /** * remove signatures if callback function tells to * * \param[in] signatures list of signatures to check, and * possibly remove, depending on the value of the * callback * \param[in] key_list these are marked to be used or not, * on the return value of the callback * \param[in] func this function is called to specify what to * do with each signature (and corresponding key) * \param[in] arg Optional argument for the callback function * \returns pointer to the new signatures rrs (the original * passed to this function may have been removed) */ ldns_dnssec_rrs *ldns_dnssec_remove_signatures(ldns_dnssec_rrs *signatures, ldns_key_list *key_list, int (*func)(ldns_rr *, void *), void *arg); /** * Adds signatures to the zone * * \param[in] zone the zone to add RRSIG Resource Records to * \param[in] new_rrs the RRSIG RRs that are created are also * added to this list, so the caller can free them * later * \param[in] key_list list of keys to sign with. * \param[in] func Callback function to decide what keys to * use and what to do with old signatures * \param[in] arg Optional argument for the callback function * \param[in] flags option flags for signing process. 0 makes DNSKEY * RRset signed with the minimal key set, that is only SEP keys are used * for signing. If there are no SEP keys available, non-SEP keys will * be used. LDNS_SIGN_DNSKEY_WITH_ZSK makes DNSKEY type signed with all * keys. 0 is the default. * \return LDNS_STATUS_OK on success, error otherwise */ ldns_status ldns_dnssec_zone_create_rrsigs_flg(ldns_dnssec_zone *zone, ldns_rr_list *new_rrs, ldns_key_list *key_list, int (*func)(ldns_rr *, void*), void *arg, int flags); /** * Adds signatures to the zone * * \param[in] zone the zone to add RRSIG Resource Records to * \param[in] new_rrs the RRSIG RRs that are created are also * added to this list, so the caller can free them * later * \param[in] key_list list of keys to sign with. * \param[in] func Callback function to decide what keys to * use and what to do with old signatures * \param[in] arg Optional argument for the callback function * \return LDNS_STATUS_OK on success, error otherwise */ ldns_status ldns_dnssec_zone_create_rrsigs(ldns_dnssec_zone *zone, ldns_rr_list *new_rrs, ldns_key_list *key_list, int (*func)(ldns_rr *, void*), void *arg); /** * signs the given zone with the given keys * * \param[in] zone the zone to sign * \param[in] key_list the list of keys to sign the zone with * \param[in] new_rrs newly created resource records are added to this list, to free them later * \param[in] func callback function that decides what to do with old signatures * This function takes an ldns_rr* and an optional void *arg argument, and returns one of four values: * LDNS_SIGNATURE_LEAVE_ADD_NEW: * leave the signature and add a new one for the corresponding key * LDNS_SIGNATURE_REMOVE_ADD_NEW: * remove the signature and replace is with a new one from the same key * LDNS_SIGNATURE_LEAVE_NO_ADD: * leave the signature and do not add a new one with the corresponding key * LDNS_SIGNATURE_REMOVE_NO_ADD: * remove the signature and do not replace * * \param[in] arg optional argument for the callback function * \param[in] flags option flags for signing process. 0 makes DNSKEY * RRset signed with the minimal key set, that is only SEP keys are used * for signing. If there are no SEP keys available, non-SEP keys will * be used. LDNS_SIGN_DNSKEY_WITH_ZSK makes DNSKEY type signed with all * keys. 0 is the default. * \return LDNS_STATUS_OK on success, an error code otherwise */ ldns_status ldns_dnssec_zone_sign_flg(ldns_dnssec_zone *zone, ldns_rr_list *new_rrs, ldns_key_list *key_list, int (*func)(ldns_rr *, void *), void *arg, int flags); /** * signs the given zone with the given new zone, with NSEC3 * * \param[in] zone the zone to sign * \param[in] key_list the list of keys to sign the zone with * \param[in] new_rrs newly created resource records are added to this list, to free them later * \param[in] func callback function that decides what to do with old signatures * \param[in] arg optional argument for the callback function * \param[in] algorithm the NSEC3 hashing algorithm to use * \param[in] flags NSEC3 flags * \param[in] iterations the number of NSEC3 hash iterations to use * \param[in] salt_length the length (in octets) of the NSEC3 salt * \param[in] salt the NSEC3 salt data * \param[in] signflags option flags for signing process. 0 is the default. * \return LDNS_STATUS_OK on success, an error code otherwise */ ldns_status ldns_dnssec_zone_sign_nsec3_flg(ldns_dnssec_zone *zone, ldns_rr_list *new_rrs, ldns_key_list *key_list, int (*func)(ldns_rr *, void *), void *arg, uint8_t algorithm, uint8_t flags, uint16_t iterations, uint8_t salt_length, uint8_t *salt, int signflags); /** * signs the given zone with the given new zone, with NSEC3 * * \param[in] zone the zone to sign * \param[in] key_list the list of keys to sign the zone with * \param[in] new_rrs newly created resource records are added to this list, to free them later * \param[in] func callback function that decides what to do with old signatures * \param[in] arg optional argument for the callback function * \param[in] algorithm the NSEC3 hashing algorithm to use * \param[in] flags NSEC3 flags * \param[in] iterations the number of NSEC3 hash iterations to use * \param[in] salt_length the length (in octets) of the NSEC3 salt * \param[in] salt the NSEC3 salt data * \param[in] signflags option flags for signing process. 0 is the default. * \param[out] map a referenced rbtree pointer variable. The newly created * rbtree will contain mappings from hashed owner names to the * unhashed name. * \return LDNS_STATUS_OK on success, an error code otherwise */ ldns_status ldns_dnssec_zone_sign_nsec3_flg_mkmap(ldns_dnssec_zone *zone, ldns_rr_list *new_rrs, ldns_key_list *key_list, int (*func)(ldns_rr *, void *), void *arg, uint8_t algorithm, uint8_t flags, uint16_t iterations, uint8_t salt_length, uint8_t *salt, int signflags, ldns_rbtree_t **map ); /** * signs the given zone with the given keys * * \param[in] zone the zone to sign * \param[in] key_list the list of keys to sign the zone with * \param[in] new_rrs newly created resource records are added to this list, to free them later * \param[in] func callback function that decides what to do with old signatures * This function takes an ldns_rr* and an optional void *arg argument, and returns one of four values: * LDNS_SIGNATURE_LEAVE_ADD_NEW: * leave the signature and add a new one for the corresponding key * LDNS_SIGNATURE_REMOVE_ADD_NEW: * remove the signature and replace is with a new one from the same key * LDNS_SIGNATURE_LEAVE_NO_ADD: * leave the signature and do not add a new one with the corresponding key * LDNS_SIGNATURE_REMOVE_NO_ADD: * remove the signature and do not replace * * \param[in] arg optional argument for the callback function * \return LDNS_STATUS_OK on success, an error code otherwise */ ldns_status ldns_dnssec_zone_sign(ldns_dnssec_zone *zone, ldns_rr_list *new_rrs, ldns_key_list *key_list, int (*func)(ldns_rr *, void *), void *arg); /** * signs the given zone with the given new zone, with NSEC3 * * \param[in] zone the zone to sign * \param[in] key_list the list of keys to sign the zone with * \param[in] new_rrs newly created resource records are added to this list, to free them later * \param[in] func callback function that decides what to do with old signatures * \param[in] arg optional argument for the callback function * \param[in] algorithm the NSEC3 hashing algorithm to use * \param[in] flags NSEC3 flags * \param[in] iterations the number of NSEC3 hash iterations to use * \param[in] salt_length the length (in octets) of the NSEC3 salt * \param[in] salt the NSEC3 salt data * \return LDNS_STATUS_OK on success, an error code otherwise */ ldns_status ldns_dnssec_zone_sign_nsec3(ldns_dnssec_zone *zone, ldns_rr_list *new_rrs, ldns_key_list *key_list, int (*func)(ldns_rr *, void *), void *arg, uint8_t algorithm, uint8_t flags, uint16_t iterations, uint8_t salt_length, uint8_t *salt); /** * Signs the zone, and returns a newly allocated signed zone * \param[in] zone the zone to sign * \param[in] key_list list of keys to sign with * \return signed zone */ ldns_zone *ldns_zone_sign(const ldns_zone *zone, ldns_key_list *key_list); /** * Signs the zone with NSEC3, and returns a newly allocated signed zone * \param[in] zone the zone to sign * \param[in] key_list list of keys to sign with * \param[in] algorithm the NSEC3 hashing algorithm to use * \param[in] flags NSEC3 flags * \param[in] iterations the number of NSEC3 hash iterations to use * \param[in] salt_length the length (in octets) of the NSEC3 salt * \param[in] salt the NSEC3 salt data * \return signed zone */ ldns_zone *ldns_zone_sign_nsec3(ldns_zone *zone, ldns_key_list *key_list, uint8_t algorithm, uint8_t flags, uint16_t iterations, uint8_t salt_length, uint8_t *salt); #ifdef __cplusplus } #endif #endif ldns-1.6.17/ldns/rr_functions.h0000664000175100017510000002756112264060151015752 0ustar willemwillem/* * rr_functions.h * * the .h file with defs for the per rr * functions * * a Net::DNS like library for C * * (c) NLnet Labs, 2005-2006 * * See the file LICENSE for the license */ #ifndef LDNS_RR_FUNCTIONS_H #define LDNS_RR_FUNCTIONS_H #ifdef __cplusplus extern "C" { #endif /** * \file * * Defines some extra convenience functions for ldns_rr structures */ /* A / AAAA */ /** * returns the address of a LDNS_RR_TYPE_A rr * \param[in] r the resource record * \return a ldns_rdf* with the address or NULL on failure */ ldns_rdf* ldns_rr_a_address(const ldns_rr *r); /** * sets the address of a LDNS_RR_TYPE_A rr * \param[in] r the rr to use * \param[in] f the address to set * \return true on success, false otherwise */ bool ldns_rr_a_set_address(ldns_rr *r, ldns_rdf *f); /* NS */ /** * returns the name of a LDNS_RR_TYPE_NS rr * \param[in] r the resource record * \return a ldns_rdf* with the name or NULL on failure */ ldns_rdf* ldns_rr_ns_nsdname(const ldns_rr *r); /* MX */ /** * returns the mx pref. of a LDNS_RR_TYPE_MX rr * \param[in] r the resource record * \return a ldns_rdf* with the preference or NULL on failure */ ldns_rdf* ldns_rr_mx_preference(const ldns_rr *r); /** * returns the mx host of a LDNS_RR_TYPE_MX rr * \param[in] r the resource record * \return a ldns_rdf* with the name of the MX host or NULL on failure */ ldns_rdf* ldns_rr_mx_exchange(const ldns_rr *r); /* RRSIG */ /** * returns the type covered of a LDNS_RR_TYPE_RRSIG rr * \param[in] r the resource record * \return a ldns_rdf* with the type covered or NULL on failure */ ldns_rdf* ldns_rr_rrsig_typecovered(const ldns_rr *r); /** * sets the typecovered of a LDNS_RR_TYPE_RRSIG rr * \param[in] r the rr to use * \param[in] f the typecovered to set * \return true on success, false otherwise */ bool ldns_rr_rrsig_set_typecovered(ldns_rr *r, ldns_rdf *f); /** * returns the algorithm of a LDNS_RR_TYPE_RRSIG RR * \param[in] r the resource record * \return a ldns_rdf* with the algorithm or NULL on failure */ ldns_rdf* ldns_rr_rrsig_algorithm(const ldns_rr *r); /** * sets the algorithm of a LDNS_RR_TYPE_RRSIG rr * \param[in] r the rr to use * \param[in] f the algorithm to set * \return true on success, false otherwise */ bool ldns_rr_rrsig_set_algorithm(ldns_rr *r, ldns_rdf *f); /** * returns the number of labels of a LDNS_RR_TYPE_RRSIG RR * \param[in] r the resource record * \return a ldns_rdf* with the number of labels or NULL on failure */ ldns_rdf *ldns_rr_rrsig_labels(const ldns_rr *r); /** * sets the number of labels of a LDNS_RR_TYPE_RRSIG rr * \param[in] r the rr to use * \param[in] f the number of labels to set * \return true on success, false otherwise */ bool ldns_rr_rrsig_set_labels(ldns_rr *r, ldns_rdf *f); /** * returns the original TTL of a LDNS_RR_TYPE_RRSIG RR * \param[in] r the resource record * \return a ldns_rdf* with the original TTL or NULL on failure */ ldns_rdf* ldns_rr_rrsig_origttl(const ldns_rr *r); /** * sets the original TTL of a LDNS_RR_TYPE_RRSIG rr * \param[in] r the rr to use * \param[in] f the original TTL to set * \return true on success, false otherwise */ bool ldns_rr_rrsig_set_origttl(ldns_rr *r, ldns_rdf *f); /** * returns the expiration time of a LDNS_RR_TYPE_RRSIG RR * \param[in] r the resource record * \return a ldns_rdf* with the expiration time or NULL on failure */ ldns_rdf* ldns_rr_rrsig_expiration(const ldns_rr *r); /** * sets the expireation date of a LDNS_RR_TYPE_RRSIG rr * \param[in] r the rr to use * \param[in] f the expireation date to set * \return true on success, false otherwise */ bool ldns_rr_rrsig_set_expiration(ldns_rr *r, ldns_rdf *f); /** * returns the inception time of a LDNS_RR_TYPE_RRSIG RR * \param[in] r the resource record * \return a ldns_rdf* with the inception time or NULL on failure */ ldns_rdf* ldns_rr_rrsig_inception(const ldns_rr *r); /** * sets the inception date of a LDNS_RR_TYPE_RRSIG rr * \param[in] r the rr to use * \param[in] f the inception date to set * \return true on success, false otherwise */ bool ldns_rr_rrsig_set_inception(ldns_rr *r, ldns_rdf *f); /** * returns the keytag of a LDNS_RR_TYPE_RRSIG RR * \param[in] r the resource record * \return a ldns_rdf* with the keytag or NULL on failure */ ldns_rdf* ldns_rr_rrsig_keytag(const ldns_rr *r); /** * sets the keytag of a LDNS_RR_TYPE_RRSIG rr * \param[in] r the rr to use * \param[in] f the keytag to set * \return true on success, false otherwise */ bool ldns_rr_rrsig_set_keytag(ldns_rr *r, ldns_rdf *f); /** * returns the signers name of a LDNS_RR_TYPE_RRSIG RR * \param[in] r the resource record * \return a ldns_rdf* with the signers name or NULL on failure */ ldns_rdf* ldns_rr_rrsig_signame(const ldns_rr *r); /** * sets the signers name of a LDNS_RR_TYPE_RRSIG rr * \param[in] r the rr to use * \param[in] f the signers name to set * \return true on success, false otherwise */ bool ldns_rr_rrsig_set_signame(ldns_rr *r, ldns_rdf *f); /** * returns the signature data of a LDNS_RR_TYPE_RRSIG RR * \param[in] r the resource record * \return a ldns_rdf* with the signature data or NULL on failure */ ldns_rdf* ldns_rr_rrsig_sig(const ldns_rr *r); /** * sets the signature data of a LDNS_RR_TYPE_RRSIG rr * \param[in] r the rr to use * \param[in] f the signature data to set * \return true on success, false otherwise */ bool ldns_rr_rrsig_set_sig(ldns_rr *r, ldns_rdf *f); /* DNSKEY */ /** * returns the flags of a LDNS_RR_TYPE_DNSKEY rr * \param[in] r the resource record * \return a ldns_rdf* with the flags or NULL on failure */ ldns_rdf* ldns_rr_dnskey_flags(const ldns_rr *r); /** * sets the flags of a LDNS_RR_TYPE_DNSKEY rr * \param[in] r the rr to use * \param[in] f the flags to set * \return true on success, false otherwise */ bool ldns_rr_dnskey_set_flags(ldns_rr *r, ldns_rdf *f); /** * returns the protocol of a LDNS_RR_TYPE_DNSKEY rr * \param[in] r the resource record * \return a ldns_rdf* with the protocol or NULL on failure */ ldns_rdf* ldns_rr_dnskey_protocol(const ldns_rr *r); /** * sets the protocol of a LDNS_RR_TYPE_DNSKEY rr * \param[in] r the rr to use * \param[in] f the protocol to set * \return true on success, false otherwise */ bool ldns_rr_dnskey_set_protocol(ldns_rr *r, ldns_rdf *f); /** * returns the algorithm of a LDNS_RR_TYPE_DNSKEY rr * \param[in] r the resource record * \return a ldns_rdf* with the algorithm or NULL on failure */ ldns_rdf* ldns_rr_dnskey_algorithm(const ldns_rr *r); /** * sets the algorithm of a LDNS_RR_TYPE_DNSKEY rr * \param[in] r the rr to use * \param[in] f the algorithm to set * \return true on success, false otherwise */ bool ldns_rr_dnskey_set_algorithm(ldns_rr *r, ldns_rdf *f); /** * returns the key data of a LDNS_RR_TYPE_DNSKEY rr * \param[in] r the resource record * \return a ldns_rdf* with the key data or NULL on failure */ ldns_rdf* ldns_rr_dnskey_key(const ldns_rr *r); /** * sets the key data of a LDNS_RR_TYPE_DNSKEY rr * \param[in] r the rr to use * \param[in] f the key data to set * \return true on success, false otherwise */ bool ldns_rr_dnskey_set_key(ldns_rr *r, ldns_rdf *f); /** * get the length of the keydata in bits * \param[in] keydata the raw key data * \param[in] len the length of the keydata * \param[in] alg the cryptographic algorithm this is a key for * \return the keysize in bits, or 0 on error */ size_t ldns_rr_dnskey_key_size_raw(const unsigned char *keydata, const size_t len, const ldns_algorithm alg); /** * get the length of the keydata in bits * \param[in] key the key rr to use * \return the keysize in bits */ size_t ldns_rr_dnskey_key_size(const ldns_rr *key); /** * The type of function to be passed to ldns_rr_soa_increment_func, * ldns_rr_soa_increment_func_data or ldns_rr_soa_increment_int. * The function will be called with as the first argument the current serial * number of the SOA RR to be updated, and as the second argument a value * given when calling ldns_rr_soa_increment_func_data or * ldns_rr_soa_increment_int. With ldns_rr_soa_increment_int the pointer * value holds the integer value passed to ldns_rr_soa_increment_int, * and it should be cast to intptr_t to be used as an integer by the * serial modifying function. */ typedef uint32_t (*ldns_soa_serial_increment_func_t)(uint32_t, void*); /** * Function to be used with dns_rr_soa_increment_func_int, to set the soa * serial number. * \param[in] unused the (unused) current serial number. * \param[in] data the serial number to be set. */ uint32_t ldns_soa_serial_identity(uint32_t unused, void *data); /** * Function to be used with dns_rr_soa_increment_func, to increment the soa * serial number with one. * \param[in] s the current serial number. * \param[in] unused unused. */ uint32_t ldns_soa_serial_increment(uint32_t s, void *unused); /** * Function to be used with dns_rr_soa_increment_func_int, to increment the soa * serial number with a certain amount. * \param[in] s the current serial number. * \param[in] data the amount to add to the current serial number. */ uint32_t ldns_soa_serial_increment_by(uint32_t s, void *data); /** * Function to be used with ldns_rr_soa_increment_func or * ldns_rr_soa_increment_func_int to set the soa serial to the number of * seconds since unix epoch (1-1-1970 00:00). * When data is given (i.e. the function is called via * ldns_rr_soa_increment_func_int), it is used as the current time. * When the resulting serial number is smaller than the current serial number, * the current serial number is increased by one. * \param[in] s the current serial number. * \param[in] data the time in seconds since 1-1-1970 00:00 */ uint32_t ldns_soa_serial_unixtime(uint32_t s, void *data); /** * Function to be used with ldns_rr_soa_increment_func or * ldns_rr_soa_increment_func_int to set the soa serial to the current date * succeeded by a two digit iteration (datecounter). * When data is given (i.e. the function is called via * ldns_rr_soa_increment_func_int), it is used as the current time. * When the resulting serial number is smaller than the current serial number, * the current serial number is increased by one. * \param[in] s the current serial number. * \param[in] data the time in seconds since 1-1-1970 00:00 */ uint32_t ldns_soa_serial_datecounter(uint32_t s, void *data); /** * Increment the serial number of the given SOA by one. * \param[in] soa The soa rr to be incremented */ void ldns_rr_soa_increment( ldns_rr *soa); /** * Increment the serial number of the given SOA with the given function. * Included functions to be used here are: ldns_rr_soa_increment, * ldns_soa_serial_unixtime and ldns_soa_serial_datecounter. * \param[in] soa The soa rr to be incremented * \param[in] f the function to use to increment the soa rr. */ void ldns_rr_soa_increment_func( ldns_rr *soa, ldns_soa_serial_increment_func_t f); /** * Increment the serial number of the given SOA with the given function * passing it the given data argument. * \param[in] soa The soa rr to be incremented * \param[in] f the function to use to increment the soa rr. * \param[in] data this argument will be passed to f as the second argument. */ void ldns_rr_soa_increment_func_data( ldns_rr *soa, ldns_soa_serial_increment_func_t f, void *data); /** * Increment the serial number of the given SOA with the given function * using data as an argument for the function. * Included functions to be used here are: ldns_soa_serial_identity, * ldns_rr_soa_increment_by, ldns_soa_serial_unixtime and * ldns_soa_serial_datecounter. * \param[in] soa The soa rr to be incremented * \param[in] f the function to use to increment the soa rr. * \param[in] data this argument will be passed to f as the second argument * (by casting it to void*). */ void ldns_rr_soa_increment_func_int( ldns_rr *soa, ldns_soa_serial_increment_func_t f, int data); #ifdef __cplusplus } #endif #endif /* LDNS_RR_FUNCTIONS_H */ ldns-1.6.17/ldns/dname.h0000664000175100017510000001436112264060151014315 0ustar willemwillem/* * dname.h * * dname definitions * * a Net::DNS like library for C * * (c) NLnet Labs, 2004-2006 * * See the file LICENSE for the license */ /** * \file dname.h * * dname contains function to read and manipulate domain names. * * Example domain names are "www.nlnetlabs.nl." and "." (the root) * * If a domain name ends with a dot ("."), it is called a Fully Qualified * Domain Name (FQDN). In certain places (for instance when reading a zone * file), an origin (which is just another domain name) non-FQDNs will be * placed after the current. For instance, if i have a zone file where the * origin has been set to "nl.", and my file contains the name * "www.nlnetlabs", it will result in "www.nlnetlabs.nl.". Internally, dnames are * always absolute (the dot is added when it is missing and there is no origin). * * An FQDN is also * known as an absolute domain name, therefore the function to check this is * called \ref ldns_dname_str_absolute * * Domain names are stored in \ref ldns_rdf structures, with the type * \ref LDNS_RDF_TYPE_DNAME * * This module is *NOT* about the RR type called DNAME. */ #ifndef LDNS_DNAME_H #define LDNS_DNAME_H #include #include #ifdef __cplusplus extern "C" { #endif #define LDNS_DNAME_NORMALIZE tolower /** * concatenates two dnames together * \param[in] rd1 the leftside * \param[in] rd2 the rightside * \return a new rdf with leftside/rightside */ ldns_rdf *ldns_dname_cat_clone(const ldns_rdf *rd1, const ldns_rdf *rd2); /** * concatenates rd2 after rd1 (rd2 is copied, rd1 is modified) * \param[in] rd1 the leftside * \param[in] rd2 the rightside * \return LDNS_STATUS_OK on success */ ldns_status ldns_dname_cat(ldns_rdf *rd1, ldns_rdf *rd2); /** * Returns a clone of the given dname with the labels * reversed * \param[in] d the dname to reverse * \return clone of the dname with the labels reversed. */ ldns_rdf *ldns_dname_reverse(const ldns_rdf *d); /** * Clones the given dname from the nth label on * \param[in] d The dname to clone * \param[in] n the label nr to clone from, if this is 0, the complete * dname is cloned * \return A newly allocated *rdf structure, containing the cloned dname, * or NULL if either d was NULL, not a dname, or if n >= * label_count */ ldns_rdf * ldns_dname_clone_from(const ldns_rdf *d, uint16_t n); /** * chop one label off the left side of a dname. so * wwww.nlnetlabs.nl, becomes nlnetlabs.nl * This new name is a clone and must be freed with ldns_deep_free() * \param[in] d the dname to chop * \return the remaining dname */ ldns_rdf *ldns_dname_left_chop(const ldns_rdf *d); /** * count the number of labels inside a LDNS_RDF_DNAME type rdf. * \param[in] *r the rdf * \return the number of labels */ uint8_t ldns_dname_label_count(const ldns_rdf *r); /** * creates a new dname rdf from a string. * \param[in] str string to use * \return ldns_rdf* or NULL in case of an error */ ldns_rdf *ldns_dname_new_frm_str(const char *str); /** * Create a new dname rdf from a string * \param[in] s the size of the new dname * \param[in] *data pointer to the actual data * * \return ldns_rdf* */ ldns_rdf *ldns_dname_new(uint16_t s, void *data); /** * Create a new dname rdf from data (the data is copied) * \param[in] size the size of the data * \param[in] *data pointer to the actual data * * \return ldns_rdf* */ ldns_rdf *ldns_dname_new_frm_data(uint16_t size, const void *data); /** * Put a dname into canonical fmt - ie. lowercase it * \param[in] rdf the dname to lowercase * \return void */ void ldns_dname2canonical(const ldns_rdf *rdf); /** * test wether the name sub falls under parent (i.e. is a subdomain * of parent). This function will return false if the given dnames are * equal. * \param[in] sub the name to test * \param[in] parent the parent's name * \return true if sub falls under parent, otherwise false */ bool ldns_dname_is_subdomain(const ldns_rdf *sub, const ldns_rdf *parent); /** * Compares the two dname rdf's according to the algorithm for ordering * in RFC4034 Section 6. * \param[in] dname1 First dname rdf to compare * \param[in] dname2 Second dname rdf to compare * \return -1 if dname1 comes before dname2, 1 if dname1 comes after dname2, and 0 if they are equal. */ int ldns_dname_compare(const ldns_rdf *dname1, const ldns_rdf *dname2); /** * Checks whether the dname matches the given wildcard * \param[in] dname The dname to check * \param[in] wildcard The wildcard to check with * \return 1 If the wildcard matches, OR if 'wildcard' is not a wildcard and * the names are *exactly* the same * 0 If the wildcard does not match, or if it is not a wildcard and * the names are not the same */ int ldns_dname_match_wildcard(const ldns_rdf *dname, const ldns_rdf *wildcard); /** * check if middle lays in the interval defined by prev and next * prev <= middle < next. This is usefull for nsec checking * \param[in] prev the previous dname * \param[in] middle the dname to check * \param[in] next the next dname * return 0 on error or unknown, -1 when middle is in the interval, +1 when not */ int ldns_dname_interval(const ldns_rdf *prev, const ldns_rdf *middle, const ldns_rdf *next); /** * Checks whether the given dname string is absolute (i.e. ends with a '.') * \param[in] *dname_str a string representing the dname * \return true or false */ bool ldns_dname_str_absolute(const char *dname_str); /** * Checks whether the given dname is absolute (i.e. ends with a '.') * \param[in] *dname a rdf representing the dname * \return true or false */ bool ldns_dname_absolute(const ldns_rdf *dname); /** * look inside the rdf and if it is an LDNS_RDF_TYPE_DNAME * try and retrieve a specific label. The labels are numbered * starting from 0 (left most). * \param[in] rdf the rdf to look in * \param[in] labelpos return the label with this number * \return a ldns_rdf* with the label as name or NULL on error */ ldns_rdf * ldns_dname_label(const ldns_rdf *rdf, uint8_t labelpos); /** * Check if dname is a wildcard, starts with *. * \param[in] dname: the rdf to look in * \return true if a wildcard, false if not. */ int ldns_dname_is_wildcard(const ldns_rdf* dname); #ifdef __cplusplus } #endif #endif /* LDNS_DNAME_H */ ldns-1.6.17/ldns/rr.h0000664000175100017510000006547712264060151013672 0ustar willemwillem/* * rr.h - resource record definitions * * a Net::DNS like library for C * * (c) NLnet Labs, 2005-2006 * * See the file LICENSE for the license */ /** * \file * * Contains the definition of ldns_rr and functions to manipulate those. */ #ifndef LDNS_RR_H #define LDNS_RR_H #include #include #include #include #ifdef __cplusplus extern "C" { #endif /** Maximum length of a dname label */ #define LDNS_MAX_LABELLEN 63 /** Maximum length of a complete dname */ #define LDNS_MAX_DOMAINLEN 255 /** Maximum number of pointers in 1 dname */ #define LDNS_MAX_POINTERS 65535 /** The bytes TTL, CLASS and length use up in an rr */ #define LDNS_RR_OVERHEAD 10 /* The first fields are contiguous and can be referenced instantly */ #define LDNS_RDATA_FIELD_DESCRIPTORS_COMMON 258 /** * The different RR classes. */ enum ldns_enum_rr_class { /** the Internet */ LDNS_RR_CLASS_IN = 1, /** Chaos class */ LDNS_RR_CLASS_CH = 3, /** Hesiod (Dyer 87) */ LDNS_RR_CLASS_HS = 4, /** None class, dynamic update */ LDNS_RR_CLASS_NONE = 254, /** Any class */ LDNS_RR_CLASS_ANY = 255, LDNS_RR_CLASS_FIRST = 0, LDNS_RR_CLASS_LAST = 65535, LDNS_RR_CLASS_COUNT = LDNS_RR_CLASS_LAST - LDNS_RR_CLASS_FIRST + 1 }; typedef enum ldns_enum_rr_class ldns_rr_class; /** * Used to specify whether compression is allowed. */ enum ldns_enum_rr_compress { /** compression is allowed */ LDNS_RR_COMPRESS, LDNS_RR_NO_COMPRESS }; typedef enum ldns_enum_rr_compress ldns_rr_compress; /** * The different RR types. */ enum ldns_enum_rr_type { /** a host address */ LDNS_RR_TYPE_A = 1, /** an authoritative name server */ LDNS_RR_TYPE_NS = 2, /** a mail destination (Obsolete - use MX) */ LDNS_RR_TYPE_MD = 3, /** a mail forwarder (Obsolete - use MX) */ LDNS_RR_TYPE_MF = 4, /** the canonical name for an alias */ LDNS_RR_TYPE_CNAME = 5, /** marks the start of a zone of authority */ LDNS_RR_TYPE_SOA = 6, /** a mailbox domain name (EXPERIMENTAL) */ LDNS_RR_TYPE_MB = 7, /** a mail group member (EXPERIMENTAL) */ LDNS_RR_TYPE_MG = 8, /** a mail rename domain name (EXPERIMENTAL) */ LDNS_RR_TYPE_MR = 9, /** a null RR (EXPERIMENTAL) */ LDNS_RR_TYPE_NULL = 10, /** a well known service description */ LDNS_RR_TYPE_WKS = 11, /** a domain name pointer */ LDNS_RR_TYPE_PTR = 12, /** host information */ LDNS_RR_TYPE_HINFO = 13, /** mailbox or mail list information */ LDNS_RR_TYPE_MINFO = 14, /** mail exchange */ LDNS_RR_TYPE_MX = 15, /** text strings */ LDNS_RR_TYPE_TXT = 16, /** RFC1183 */ LDNS_RR_TYPE_RP = 17, /** RFC1183 */ LDNS_RR_TYPE_AFSDB = 18, /** RFC1183 */ LDNS_RR_TYPE_X25 = 19, /** RFC1183 */ LDNS_RR_TYPE_ISDN = 20, /** RFC1183 */ LDNS_RR_TYPE_RT = 21, /** RFC1706 */ LDNS_RR_TYPE_NSAP = 22, /** RFC1348 */ LDNS_RR_TYPE_NSAP_PTR = 23, /** 2535typecode */ LDNS_RR_TYPE_SIG = 24, /** 2535typecode */ LDNS_RR_TYPE_KEY = 25, /** RFC2163 */ LDNS_RR_TYPE_PX = 26, /** RFC1712 */ LDNS_RR_TYPE_GPOS = 27, /** ipv6 address */ LDNS_RR_TYPE_AAAA = 28, /** LOC record RFC1876 */ LDNS_RR_TYPE_LOC = 29, /** 2535typecode */ LDNS_RR_TYPE_NXT = 30, /** draft-ietf-nimrod-dns-01.txt */ LDNS_RR_TYPE_EID = 31, /** draft-ietf-nimrod-dns-01.txt */ LDNS_RR_TYPE_NIMLOC = 32, /** SRV record RFC2782 */ LDNS_RR_TYPE_SRV = 33, /** http://www.jhsoft.com/rfc/af-saa-0069.000.rtf */ LDNS_RR_TYPE_ATMA = 34, /** RFC2915 */ LDNS_RR_TYPE_NAPTR = 35, /** RFC2230 */ LDNS_RR_TYPE_KX = 36, /** RFC2538 */ LDNS_RR_TYPE_CERT = 37, /** RFC2874 */ LDNS_RR_TYPE_A6 = 38, /** RFC2672 */ LDNS_RR_TYPE_DNAME = 39, /** dnsind-kitchen-sink-02.txt */ LDNS_RR_TYPE_SINK = 40, /** Pseudo OPT record... */ LDNS_RR_TYPE_OPT = 41, /** RFC3123 */ LDNS_RR_TYPE_APL = 42, /** RFC4034, RFC3658 */ LDNS_RR_TYPE_DS = 43, /** SSH Key Fingerprint */ LDNS_RR_TYPE_SSHFP = 44, /* RFC 4255 */ /** IPsec Key */ LDNS_RR_TYPE_IPSECKEY = 45, /* RFC 4025 */ /** DNSSEC */ LDNS_RR_TYPE_RRSIG = 46, /* RFC 4034 */ LDNS_RR_TYPE_NSEC = 47, /* RFC 4034 */ LDNS_RR_TYPE_DNSKEY = 48, /* RFC 4034 */ LDNS_RR_TYPE_DHCID = 49, /* RFC 4701 */ /* NSEC3 */ LDNS_RR_TYPE_NSEC3 = 50, /* RFC 5155 */ LDNS_RR_TYPE_NSEC3PARAM = 51, /* RFC 5155 */ LDNS_RR_TYPE_NSEC3PARAMS = 51, LDNS_RR_TYPE_TLSA = 52, /* RFC 6698 */ LDNS_RR_TYPE_HIP = 55, /* RFC 5205 */ /** draft-reid-dnsext-zs */ LDNS_RR_TYPE_NINFO = 56, /** draft-reid-dnsext-rkey */ LDNS_RR_TYPE_RKEY = 57, /** draft-ietf-dnsop-trust-history */ LDNS_RR_TYPE_TALINK = 58, /** draft-barwood-dnsop-ds-publis */ LDNS_RR_TYPE_CDS = 59, LDNS_RR_TYPE_SPF = 99, /* RFC 4408 */ LDNS_RR_TYPE_UINFO = 100, LDNS_RR_TYPE_UID = 101, LDNS_RR_TYPE_GID = 102, LDNS_RR_TYPE_UNSPEC = 103, LDNS_RR_TYPE_NID = 104, /* RFC 6742 */ LDNS_RR_TYPE_L32 = 105, /* RFC 6742 */ LDNS_RR_TYPE_L64 = 106, /* RFC 6742 */ LDNS_RR_TYPE_LP = 107, /* RFC 6742 */ LDNS_RR_TYPE_EUI48 = 108, /* RFC 7043 */ LDNS_RR_TYPE_EUI64 = 109, /* RFC 7043 */ LDNS_RR_TYPE_TKEY = 249, /* RFC 2930 */ LDNS_RR_TYPE_TSIG = 250, LDNS_RR_TYPE_IXFR = 251, LDNS_RR_TYPE_AXFR = 252, /** A request for mailbox-related records (MB, MG or MR) */ LDNS_RR_TYPE_MAILB = 253, /** A request for mail agent RRs (Obsolete - see MX) */ LDNS_RR_TYPE_MAILA = 254, /** any type (wildcard) */ LDNS_RR_TYPE_ANY = 255, /** draft-faltstrom-uri-06 */ LDNS_RR_TYPE_URI = 256, LDNS_RR_TYPE_CAA = 257, /* RFC 6844 */ /** DNSSEC Trust Authorities */ LDNS_RR_TYPE_TA = 32768, /* RFC 4431, 5074, DNSSEC Lookaside Validation */ LDNS_RR_TYPE_DLV = 32769, /* type codes from nsec3 experimental phase LDNS_RR_TYPE_NSEC3 = 65324, LDNS_RR_TYPE_NSEC3PARAMS = 65325, */ LDNS_RR_TYPE_FIRST = 0, LDNS_RR_TYPE_LAST = 65535, LDNS_RR_TYPE_COUNT = LDNS_RR_TYPE_LAST - LDNS_RR_TYPE_FIRST + 1 }; typedef enum ldns_enum_rr_type ldns_rr_type; /** * Resource Record * * This is the basic DNS element that contains actual data * * From RFC1035: *
3.2.1. Format

All RRs have the same top level format shown below:

                                    1  1  1  1  1  1
      0  1  2  3  4  5  6  7  8  9  0  1  2  3  4  5
    +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
    |                                               |
    /                                               /
    /                      NAME                     /
    |                                               |
    +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
    |                      TYPE                     |
    +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
    |                     CLASS                     |
    +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
    |                      TTL                      |
    |                                               |
    +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
    |                   RDLENGTH                    |
    +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--|
    /                     RDATA                     /
    /                                               /
    +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+

where:

NAME            an owner name, i.e., the name of the node to which this
                resource record pertains.

TYPE            two octets containing one of the RR TYPE codes.

CLASS           two octets containing one of the RR CLASS codes.

TTL             a 32 bit signed integer that specifies the time interval
                that the resource record may be cached before the source
                of the information should again be consulted.  Zero
                values are interpreted to mean that the RR can only be
                used for the transaction in progress, and should not be
                cached.  For example, SOA records are always distributed
                with a zero TTL to prohibit caching.  Zero values can
                also be used for extremely volatile data.

RDLENGTH        an unsigned 16 bit integer that specifies the length in
                octets of the RDATA field.

RDATA           a variable length string of octets that describes the
                resource.  The format of this information varies
                according to the TYPE and CLASS of the resource record.
 * 
* * The actual amount and type of rdata fields depend on the RR type of the * RR, and can be found by using \ref ldns_rr_descriptor functions. */ struct ldns_struct_rr { /** Owner name, uncompressed */ ldns_rdf *_owner; /** Time to live */ uint32_t _ttl; /** Number of data fields */ size_t _rd_count; /** the type of the RR. A, MX etc. */ ldns_rr_type _rr_type; /** Class of the resource record. */ ldns_rr_class _rr_class; /* everything in the rdata is in network order */ /** The array of rdata's */ ldns_rdf **_rdata_fields; /** question rr [it would be nicer if thous is after _rd_count] ABI change: Fix this in next major release */ bool _rr_question; }; typedef struct ldns_struct_rr ldns_rr; /** * List or Set of Resource Records * * Contains a list of rr's
* No official RFC-like checks are made */ struct ldns_struct_rr_list { size_t _rr_count; size_t _rr_capacity; ldns_rr **_rrs; }; typedef struct ldns_struct_rr_list ldns_rr_list; /** * Contains all information about resource record types. * * This structure contains, for all rr types, the rdata fields that are defined. */ struct ldns_struct_rr_descriptor { /** Type of the RR that is described here */ ldns_rr_type _type; /** Textual name of the RR type. */ const char *_name; /** Minimum number of rdata fields in the RRs of this type. */ uint8_t _minimum; /** Maximum number of rdata fields in the RRs of this type. */ uint8_t _maximum; /** Wireformat specification for the rr, i.e. the types of rdata fields in their respective order. */ const ldns_rdf_type *_wireformat; /** Special rdf types */ ldns_rdf_type _variable; /** Specifies whether compression can be used for dnames in this RR type. */ ldns_rr_compress _compress; /** The number of DNAMEs in the _wireformat string, for parsing. */ uint8_t _dname_count; }; typedef struct ldns_struct_rr_descriptor ldns_rr_descriptor; /** * Create a rr type bitmap rdf providing enough space to set all * known (to ldns) rr types. * \param[out] rdf the constructed rdf * \return LDNS_STATUS_OK if all went well. */ ldns_status ldns_rdf_bitmap_known_rr_types_space(ldns_rdf** rdf); /** * Create a rr type bitmap rdf with at least all known (to ldns) rr types set. * \param[out] rdf the constructed rdf * \return LDNS_STATUS_OK if all went well. */ ldns_status ldns_rdf_bitmap_known_rr_types(ldns_rdf** rdf); /** * creates a new rr structure. * \return ldns_rr * */ ldns_rr* ldns_rr_new(void); /** * creates a new rr structure, based on the given type. * alloc enough space to hold all the rdf's */ ldns_rr* ldns_rr_new_frm_type(ldns_rr_type t); /** * frees an RR structure * \param[in] *rr the RR to be freed * \return void */ void ldns_rr_free(ldns_rr *rr); /** * creates an rr from a string. * The string should be a fully filled-in rr, like * ownername <space> TTL <space> CLASS <space> * TYPE <space> RDATA. * \param[out] n the rr to return * \param[in] str the string to convert * \param[in] default_ttl default ttl value for the rr. * If 0 DEF_TTL will be used * \param[in] origin when the owner is relative add this. * The caller must ldns_rdf_deep_free it. * \param[out] prev the previous ownername. if this value is not NULL, * the function overwrites this with the ownername found in this * string. The caller must then ldns_rdf_deep_free it. * \return a status msg describing an error or LDNS_STATUS_OK */ ldns_status ldns_rr_new_frm_str(ldns_rr **n, const char *str, uint32_t default_ttl, ldns_rdf *origin, ldns_rdf **prev); /** * creates an rr for the question section from a string, i.e. * without RDATA fields * Origin and previous RR functionality are the same as in * ldns_rr_new_frm_str() * \param[out] n the rr to return * \param[in] str the string to convert * \param[in] origin when the owner is relative add this. * The caller must ldns_rdf_deep_free it. * \param prev the previous ownername. the function overwrite this with * the current found ownername. The caller must ldns_rdf_deep_free it. * \return a status msg describing an error or LDNS_STATUS_OK */ ldns_status ldns_rr_new_question_frm_str(ldns_rr **n, const char *str, ldns_rdf *origin, ldns_rdf **prev); /** * creates a new rr from a file containing a string. * \param[out] rr the new rr * \param[in] fp the file pointer to use * \param[in] default_ttl pointer to a default ttl for the rr. If NULL DEF_TTL will be used * the pointer will be updated if the file contains a $TTL directive * \param[in] origin when the owner is relative add this * the pointer will be updated if the file contains a $ORIGIN directive * The caller must ldns_rdf_deep_free it. * \param[in] prev when the owner is whitespaces use this as the * ownername * the pointer will be updated after the call * The caller must ldns_rdf_deep_free it. * \return a ldns_status with an error or LDNS_STATUS_OK */ ldns_status ldns_rr_new_frm_fp(ldns_rr **rr, FILE *fp, uint32_t *default_ttl, ldns_rdf **origin, ldns_rdf **prev); /** * creates a new rr from a file containing a string. * \param[out] rr the new rr * \param[in] fp the file pointer to use * \param[in] default_ttl a default ttl for the rr. If NULL DEF_TTL will be used * the pointer will be updated if the file contains a $TTL directive * \param[in] origin when the owner is relative add this * the pointer will be updated if the file contains a $ORIGIN directive * The caller must ldns_rdf_deep_free it. * \param[in] line_nr pointer to an integer containing the current line number (for debugging purposes) * \param[in] prev when the owner is whitespaces use this as the * ownername * the pointer will be updated after the call * The caller must ldns_rdf_deep_free it. * \return a ldns_status with an error or LDNS_STATUS_OK */ ldns_status ldns_rr_new_frm_fp_l(ldns_rr **rr, FILE *fp, uint32_t *default_ttl, ldns_rdf **origin, ldns_rdf **prev, int *line_nr); /** * sets the owner in the rr structure. * \param[in] *rr rr to operate on * \param[in] *owner set to this owner * \return void */ void ldns_rr_set_owner(ldns_rr *rr, ldns_rdf *owner); /** * sets the question flag in the rr structure. * \param[in] *rr rr to operate on * \param[in] question question flag * \return void */ void ldns_rr_set_question(ldns_rr *rr, bool question); /** * sets the ttl in the rr structure. * \param[in] *rr rr to operate on * \param[in] ttl set to this ttl * \return void */ void ldns_rr_set_ttl(ldns_rr *rr, uint32_t ttl); /** * sets the rd_count in the rr. * \param[in] *rr rr to operate on * \param[in] count set to this count * \return void */ void ldns_rr_set_rd_count(ldns_rr *rr, size_t count); /** * sets the type in the rr. * \param[in] *rr rr to operate on * \param[in] rr_type set to this type * \return void */ void ldns_rr_set_type(ldns_rr *rr, ldns_rr_type rr_type); /** * sets the class in the rr. * \param[in] *rr rr to operate on * \param[in] rr_class set to this class * \return void */ void ldns_rr_set_class(ldns_rr *rr, ldns_rr_class rr_class); /** * sets a rdf member, it will be set on the * position given. The old value is returned, like pop. * \param[in] *rr the rr to operate on * \param[in] *f the rdf to set * \param[in] position the position the set the rdf * \return the old value in the rr, NULL on failyre */ ldns_rdf* ldns_rr_set_rdf(ldns_rr *rr, const ldns_rdf *f, size_t position); /** * sets rd_field member, it will be * placed in the next available spot. * \param[in] *rr rr to operate on * \param[in] *f the data field member to set * \return bool */ bool ldns_rr_push_rdf(ldns_rr *rr, const ldns_rdf *f); /** * removes a rd_field member, it will be * popped from the last position. * \param[in] *rr rr to operate on * \return rdf which was popped (null if nothing) */ ldns_rdf* ldns_rr_pop_rdf(ldns_rr *rr); /** * returns the rdata field member counter. * \param[in] *rr rr to operate on * \param[in] nr the number of the rdf to return * \return ldns_rdf * */ ldns_rdf* ldns_rr_rdf(const ldns_rr *rr, size_t nr); /** * returns the owner name of an rr structure. * \param[in] *rr rr to operate on * \return ldns_rdf * */ ldns_rdf* ldns_rr_owner(const ldns_rr *rr); /** * returns the question flag of an rr structure. * \param[in] *rr rr to operate on * \return bool true if question */ bool ldns_rr_is_question(const ldns_rr *rr); /** * returns the ttl of an rr structure. * \param[in] *rr the rr to read from * \return the ttl of the rr */ uint32_t ldns_rr_ttl(const ldns_rr *rr); /** * returns the rd_count of an rr structure. * \param[in] *rr the rr to read from * \return the rd count of the rr */ size_t ldns_rr_rd_count(const ldns_rr *rr); /** * returns the type of the rr. * \param[in] *rr the rr to read from * \return the type of the rr */ ldns_rr_type ldns_rr_get_type(const ldns_rr *rr); /** * returns the class of the rr. * \param[in] *rr the rr to read from * \return the class of the rr */ ldns_rr_class ldns_rr_get_class(const ldns_rr *rr); /* rr_lists */ /** * returns the number of rr's in an rr_list. * \param[in] rr_list the rr_list to read from * \return the number of rr's */ size_t ldns_rr_list_rr_count(const ldns_rr_list *rr_list); /** * sets the number of rr's in an rr_list. * \param[in] rr_list the rr_list to set the count on * \param[in] count the number of rr in this list * \return void */ void ldns_rr_list_set_rr_count(ldns_rr_list *rr_list, size_t count); /** * set a rr on a specific index in a ldns_rr_list * \param[in] rr_list the rr_list to use * \param[in] r the rr to set * \param[in] count index into the rr_list * \return the old rr which was stored in the rr_list, or * NULL is the index was too large * set a specific rr */ ldns_rr * ldns_rr_list_set_rr(ldns_rr_list *rr_list, const ldns_rr *r, size_t count); /** * returns a specific rr of an rrlist. * \param[in] rr_list the rr_list to read from * \param[in] nr return this rr * \return the rr at position nr */ ldns_rr* ldns_rr_list_rr(const ldns_rr_list *rr_list, size_t nr); /** * creates a new rr_list structure. * \return a new rr_list structure */ ldns_rr_list* ldns_rr_list_new(void); /** * frees an rr_list structure. * \param[in] rr_list the list to free */ void ldns_rr_list_free(ldns_rr_list *rr_list); /** * frees an rr_list structure and all rrs contained therein. * \param[in] rr_list the list to free */ void ldns_rr_list_deep_free(ldns_rr_list *rr_list); /** * concatenates two ldns_rr_lists together. This modifies * *left (to extend it and add the pointers from *right). * \param[in] left the leftside * \param[in] right the rightside * \return a left with right concatenated to it */ bool ldns_rr_list_cat(ldns_rr_list *left, ldns_rr_list *right); /** * concatenates two ldns_rr_lists together, but makes clones of the rr's * (instead of pointer copying). * \param[in] left the leftside * \param[in] right the rightside * \return a new rr_list with leftside/rightside concatenated */ ldns_rr_list* ldns_rr_list_cat_clone(ldns_rr_list *left, ldns_rr_list *right); /** * pushes an rr to an rrlist. * \param[in] rr_list the rr_list to push to * \param[in] rr the rr to push * \return false on error, otherwise true */ bool ldns_rr_list_push_rr(ldns_rr_list *rr_list, const ldns_rr *rr); /** * pushes an rr_list to an rrlist. * \param[in] rr_list the rr_list to push to * \param[in] push_list the rr_list to push * \return false on error, otherwise true */ bool ldns_rr_list_push_rr_list(ldns_rr_list *rr_list, const ldns_rr_list *push_list); /** * pops the last rr from an rrlist. * \param[in] rr_list the rr_list to pop from * \return NULL if nothing to pop. Otherwise the popped RR */ ldns_rr* ldns_rr_list_pop_rr(ldns_rr_list *rr_list); /** * pops an rr_list of size s from an rrlist. * \param[in] rr_list the rr_list to pop from * \param[in] size the number of rr's to pop * \return NULL if nothing to pop. Otherwise the popped rr_list */ ldns_rr_list* ldns_rr_list_pop_rr_list(ldns_rr_list *rr_list, size_t size); /** * returns true if the given rr is one of the rrs in the * list, or if it is equal to one * \param[in] rr_list the rr_list to check * \param[in] rr the rr to check * \return true if rr_list contains rr, false otherwise */ bool ldns_rr_list_contains_rr(const ldns_rr_list *rr_list, ldns_rr *rr); /** * checks if an rr_list is a rrset. * \param[in] rr_list the rr_list to check * \return true if it is an rrset otherwise false */ bool ldns_is_rrset(ldns_rr_list *rr_list); /** * pushes an rr to an rrset (which really are rr_list's). * \param[in] *rr_list the rrset to push the rr to * \param[in] *rr the rr to push * \return true if the push succeeded otherwise false */ bool ldns_rr_set_push_rr(ldns_rr_list *rr_list, ldns_rr *rr); /** * pops the last rr from an rrset. This function is there only * for the symmetry. * \param[in] rr_list the rr_list to pop from * \return NULL if nothing to pop. Otherwise the popped RR * */ ldns_rr* ldns_rr_set_pop_rr(ldns_rr_list *rr_list); /** * pops the first rrset from the list, * the list must be sorted, so that all rr's from each rrset * are next to each other */ ldns_rr_list *ldns_rr_list_pop_rrset(ldns_rr_list *rr_list); /** * retrieves a rrtype by looking up its name. * \param[in] name a string with the name * \return the type which corresponds with the name */ ldns_rr_type ldns_get_rr_type_by_name(const char *name); /** * retrieves a class by looking up its name. * \param[in] name string with the name * \return the cass which corresponds with the name */ ldns_rr_class ldns_get_rr_class_by_name(const char *name); /** * clones a rr and all its data * \param[in] rr the rr to clone * \return the new rr or NULL on failure */ ldns_rr* ldns_rr_clone(const ldns_rr *rr); /** * clones an rrlist. * \param[in] rrlist the rrlist to clone * \return the cloned rr list */ ldns_rr_list* ldns_rr_list_clone(const ldns_rr_list *rrlist); /** * sorts an rr_list (canonical wire format). the sorting is done inband. * \param[in] unsorted the rr_list to be sorted * \return void */ void ldns_rr_list_sort(ldns_rr_list *unsorted); /** * compares two rrs. The TTL is not looked at. * \param[in] rr1 the first one * \param[in] rr2 the second one * \return 0 if equal * -1 if rr1 comes before rr2 * +1 if rr2 comes before rr1 */ int ldns_rr_compare(const ldns_rr *rr1, const ldns_rr *rr2); /** * compares two rrs, up to the rdata. * \param[in] rr1 the first one * \param[in] rr2 the second one * \return 0 if equal * -1 if rr1 comes before rr2 * +1 if rr2 comes before rr1 */ int ldns_rr_compare_no_rdata(const ldns_rr *rr1, const ldns_rr *rr2); /** * compares the wireformat of two rrs, contained in the given buffers. * \param[in] rr1_buf the first one * \param[in] rr2_buf the second one * \return 0 if equal * -1 if rr1_buf comes before rr2_buf * +1 if rr2_buf comes before rr1_buf */ int ldns_rr_compare_wire(ldns_buffer *rr1_buf, ldns_buffer *rr2_buf); /** * returns true of the given rr's are equal. * Also returns true if one record is a DS that represents the * same DNSKEY record as the other record * \param[in] rr1 the first rr * \param[in] rr2 the second rr * \return true if equal otherwise false */ bool ldns_rr_compare_ds(const ldns_rr *rr1, const ldns_rr *rr2); /** * compares two rr listss. * \param[in] rrl1 the first one * \param[in] rrl2 the second one * \return 0 if equal * -1 if rrl1 comes before rrl2 * +1 if rrl2 comes before rrl1 */ int ldns_rr_list_compare(const ldns_rr_list *rrl1, const ldns_rr_list *rrl2); /** * calculates the uncompressed size of an RR. * \param[in] r the rr to operate on * \return size of the rr */ size_t ldns_rr_uncompressed_size(const ldns_rr *r); /** * converts each dname in a rr to its canonical form. * \param[in] rr the rr to work on * \return void */ void ldns_rr2canonical(ldns_rr *rr); /** * converts each dname in each rr in a rr_list to its canonical form. * \param[in] rr_list the rr_list to work on * \return void */ void ldns_rr_list2canonical(ldns_rr_list *rr_list); /** * counts the number of labels of the ownername. * \param[in] rr count the labels of this rr * \return the number of labels */ uint8_t ldns_rr_label_count(ldns_rr *rr); /** * returns the resource record descriptor for the given rr type. * * \param[in] type the type value of the rr type *\return the ldns_rr_descriptor for this type */ const ldns_rr_descriptor *ldns_rr_descript(uint16_t type); /** * returns the minimum number of rdata fields of the rr type this descriptor describes. * * \param[in] descriptor for an rr type * \return the minimum number of rdata fields */ size_t ldns_rr_descriptor_minimum(const ldns_rr_descriptor *descriptor); /** * returns the maximum number of rdata fields of the rr type this descriptor describes. * * \param[in] descriptor for an rr type * \return the maximum number of rdata fields */ size_t ldns_rr_descriptor_maximum(const ldns_rr_descriptor *descriptor); /** * returns the rdf type for the given rdata field number of the rr type for the given descriptor. * * \param[in] descriptor for an rr type * \param[in] field the field number * \return the rdf type for the field */ ldns_rdf_type ldns_rr_descriptor_field_type(const ldns_rr_descriptor *descriptor, size_t field); /** * Return the rr_list which matches the rdf at position field. Think * type-covered stuff for RRSIG * * \param[in] l the rr_list to look in * \param[in] r the rdf to use for the comparison * \param[in] pos at which position can we find the rdf * * \return a new rr list with only the RRs that match * */ ldns_rr_list *ldns_rr_list_subtype_by_rdf(ldns_rr_list *l, ldns_rdf *r, size_t pos); /** * convert an rdf of type LDNS_RDF_TYPE_TYPE to an actual * LDNS_RR_TYPE. This is usefull in the case when inspecting * the rrtype covered field of an RRSIG. * \param[in] rd the rdf to look at * \return a ldns_rr_type with equivalent LDNS_RR_TYPE * */ ldns_rr_type ldns_rdf2rr_type(const ldns_rdf *rd); /** * Returns the type of the first element of the RR * If there are no elements present, 0 is returned * * \param[in] rr_list The rr list * \return rr_type of the first element, or 0 if the list is empty */ ldns_rr_type ldns_rr_list_type(const ldns_rr_list *rr_list); /** * Returns the owner domain name rdf of the first element of the RR * If there are no elements present, NULL is returned * * \param[in] rr_list The rr list * \return dname of the first element, or NULL if the list is empty */ ldns_rdf * ldns_rr_list_owner(const ldns_rr_list *rr_list); #ifdef __cplusplus } #endif #endif /* LDNS_RR_H */ ldns-1.6.17/ldns/dane.h0000664000175100017510000002161612264060151014141 0ustar willemwillem/* * dane.h -- defines for the DNS-Based Authentication of Named Entities (DANE) * Transport Layer Security (TLS) Protocol: TLSA * * Copyright (c) 2012, NLnet Labs. All rights reserved. * * See LICENSE for the license. * */ /** * \file * * This module contains base functions for creating and verifying TLSA RR's * with PKIX certificates, certificate chains and validation stores. * (See RFC6394 and RFC6698). * * Since those functions heavily rely op cryptographic operations, * this module is dependent on openssl. */ #ifndef LDNS_DANE_H #define LDNS_DANE_H #if LDNS_BUILD_CONFIG_USE_DANE #include #include #include #if LDNS_BUILD_CONFIG_HAVE_SSL #include #include #endif /* LDNS_BUILD_CONFIG_HAVE_SSL */ #ifdef __cplusplus extern "C" { #endif /** * The different "Certificate usage" rdata field values for a TLSA RR. */ enum ldns_enum_tlsa_certificate_usage { /** CA constraint */ LDNS_TLSA_USAGE_CA_CONSTRAINT = 0, /** Sevice certificate constraint */ LDNS_TLSA_USAGE_SERVICE_CERTIFICATE_CONSTRAINT = 1, /** Trust anchor assertion */ LDNS_TLSA_USAGE_TRUST_ANCHOR_ASSERTION = 2, /** Domain issued certificate */ LDNS_TLSA_USAGE_DOMAIN_ISSUED_CERTIFICATE = 3 }; typedef enum ldns_enum_tlsa_certificate_usage ldns_tlsa_certificate_usage; /** * The different "Selector" rdata field values for a TLSA RR. */ enum ldns_enum_tlsa_selector { /** * Full certificate: the Certificate binary structure * as defined in [RFC5280] */ LDNS_TLSA_SELECTOR_FULL_CERTIFICATE = 0, /** * SubjectPublicKeyInfo: DER-encoded binary structure * as defined in [RFC5280] */ LDNS_TLSA_SELECTOR_SUBJECTPUBLICKEYINFO = 1 }; typedef enum ldns_enum_tlsa_selector ldns_tlsa_selector; /** * The different "Matching type" rdata field values for a TLSA RR. */ enum ldns_enum_tlsa_matching_type { /** Exact match on selected content */ LDNS_TLSA_MATCHING_TYPE_NO_HASH_USED = 0, /** SHA-256 hash of selected content [RFC6234] */ LDNS_TLSA_MATCHING_TYPE_SHA256 = 1, /** SHA-512 hash of selected content [RFC6234] */ LDNS_TLSA_MATCHING_TYPE_SHA512 = 2 }; typedef enum ldns_enum_tlsa_matching_type ldns_tlsa_matching_type; /** * Known transports to use with TLSA owner names. */ enum ldns_enum_dane_transport { /** TCP */ LDNS_DANE_TRANSPORT_TCP = 0, /** UDP */ LDNS_DANE_TRANSPORT_UDP = 1, /** SCTP */ LDNS_DANE_TRANSPORT_SCTP = 2 }; typedef enum ldns_enum_dane_transport ldns_dane_transport; /** * Creates a dname consisting of the given name, prefixed by the service port * and type of transport: _port._transport.name. * * \param[out] tlsa_owner The created dname. * \param[in] name The dname that should be prefixed. * \param[in] port The service port number for wich the name should be created. * \param[in] transport The transport for wich the name should be created. * \return LDNS_STATUS_OK on success or an error code otherwise. */ ldns_status ldns_dane_create_tlsa_owner(ldns_rdf** tlsa_owner, const ldns_rdf* name, uint16_t port, ldns_dane_transport transport); #if LDNS_BUILD_CONFIG_HAVE_SSL /** * Creates a LDNS_RDF_TYPE_HEX type rdf based on the binary data choosen by * the selector and encoded using matching_type. * * \param[out] rdf The created created rdf of type LDNS_RDF_TYPE_HEX. * \param[in] cert The certificate from which the data is selected * \param[in] selector The full certificate or the public key * \param[in] matching_type The full data or the SHA256 or SHA512 hash * of the selected data * \return LDNS_STATUS_OK on success or an error code otherwise. */ ldns_status ldns_dane_cert2rdf(ldns_rdf** rdf, X509* cert, ldns_tlsa_selector selector, ldns_tlsa_matching_type matching_type); /** * Selects the certificate from cert, extra_certs or the pkix_validation_store * based on the value of cert_usage and index. * * \param[out] selected_cert The selected cert. * \param[in] cert The certificate to validate (or not) * \param[in] extra_certs Intermediate certificates that might be necessary * during validation. May be NULL, except when the certificate * usage is "Trust Anchor Assertion" because the trust anchor has * to be provided.(otherwise choose a "Domain issued certificate!" * \param[in] pkix_validation_store Used when the certificate usage is * "CA constraint" or "Service Certificate Constraint" to * validate the certificate and, in case of "CA constraint", * select the CA. * When pkix_validation_store is NULL, validation is explicitely * turned off and the behaviour is then the same as for "Trust * anchor assertion" and "Domain issued certificate" respectively. * \param[in] cert_usage Which certificate to use and how to validate. * \param[in] index Used to select the trust anchor when certificate usage * is "Trust Anchor Assertion". 0 is the last certificate in the * validation chain. 1 the one but last, etc. When index is -1, * the last certificate is used that MUST be self-signed. * This can help to make sure that the intended (self signed) * trust anchor is actually present in extra_certs (which is a * DANE requirement). * * \return LDNS_STATUS_OK on success or an error code otherwise. */ ldns_status ldns_dane_select_certificate(X509** selected_cert, X509* cert, STACK_OF(X509)* extra_certs, X509_STORE* pkix_validation_store, ldns_tlsa_certificate_usage cert_usage, int index); /** * Creates a TLSA resource record from the certificate. * No PKIX validation is performed! The given certificate is used as data * regardless the value of certificate_usage. * * \param[out] tlsa The created TLSA resource record. * \param[in] certificate_usage The value for the Certificate Usage field * \param[in] selector The value for the Selector field * \param[in] matching_type The value for the Matching Type field * \param[in] cert The certificate which data will be represented * * \return LDNS_STATUS_OK on success or an error code otherwise. */ ldns_status ldns_dane_create_tlsa_rr(ldns_rr** tlsa, ldns_tlsa_certificate_usage certificate_usage, ldns_tlsa_selector selector, ldns_tlsa_matching_type matching_type, X509* cert); /** * Verify if the given TLSA resource record matches the given certificate. * Reporting on a TLSA rr mismatch (LDNS_STATUS_DANE_TLSA_DID_NOT_MATCH) * is preferred over PKIX failure (LDNS_STATUS_DANE_PKIX_DID_NOT_VALIDATE). * So when PKIX validation is required by the TLSA Certificate usage, * but the TLSA data does not match, LDNS_STATUS_DANE_TLSA_DID_NOT_MATCH * is returned whether the PKIX validated or not. * * \param[in] tlsa_rr The resource record that specifies what and how to * match the certificate. With tlsa_rr == NULL, regular PKIX * validation is performed. * \param[in] cert The certificate to match (and validate) * \param[in] extra_certs Intermediate certificates that might be necessary * creating the validation chain. * \param[in] pkix_validation_store Used when the certificate usage is * "CA constraint" or "Service Certificate Constraint" to * validate the certificate. * * \return LDNS_STATUS_OK on success, * LDNS_STATUS_DANE_TLSA_DID_NOT_MATCH on TLSA data mismatch, * LDNS_STATUS_DANE_PKIX_DID_NOT_VALIDATE when TLSA matched, * but the PKIX validation failed, or other ldns_status errors. */ ldns_status ldns_dane_verify_rr(const ldns_rr* tlsa_rr, X509* cert, STACK_OF(X509)* extra_certs, X509_STORE* pkix_validation_store); /** * Verify if any of the given TLSA resource records matches the given * certificate. * * \param[in] tlsas The resource records that specify what and how to * match the certificate. One must match for this function * to succeed. With tlsas == NULL or the number of TLSA records * in tlsas == 0, regular PKIX validation is performed. * \param[in] cert The certificate to match (and validate) * \param[in] extra_certs Intermediate certificates that might be necessary * creating the validation chain. * \param[in] pkix_validation_store Used when the certificate usage is * "CA constraint" or "Service Certificate Constraint" to * validate the certificate. * * \return LDNS_STATUS_OK on success, * LDNS_STATUS_DANE_PKIX_DID_NOT_VALIDATE when one of the TLSA's * matched but the PKIX validation failed, * LDNS_STATUS_DANE_TLSA_DID_NOT_MATCH when none of the TLSA's matched, * or other ldns_status errors. */ ldns_status ldns_dane_verify(ldns_rr_list* tlsas, X509* cert, STACK_OF(X509)* extra_certs, X509_STORE* pkix_validation_store); #endif /* LDNS_BUILD_CONFIG_HAVE_SSL */ #ifdef __cplusplus } #endif #endif /* LDNS_BUILD_CONFIG_USE_DANE */ #endif /* LDNS_DANE_H */ ldns-1.6.17/ldns/rdata.h0000664000175100017510000002730112264060151014322 0ustar willemwillem/* * rdata.h * * rdata definitions * * a Net::DNS like library for C * * (c) NLnet Labs, 2005-2006 * * See the file LICENSE for the license */ /** * \file * * Defines ldns_rdf and functions to manipulate those. */ #ifndef LDNS_RDATA_H #define LDNS_RDATA_H #include #include #ifdef __cplusplus extern "C" { #endif #define LDNS_MAX_RDFLEN 65535 #define LDNS_RDF_SIZE_BYTE 1 #define LDNS_RDF_SIZE_WORD 2 #define LDNS_RDF_SIZE_DOUBLEWORD 4 #define LDNS_RDF_SIZE_6BYTES 6 #define LDNS_RDF_SIZE_8BYTES 8 #define LDNS_RDF_SIZE_16BYTES 16 #define LDNS_NSEC3_VARS_OPTOUT_MASK 0x01 /** * The different types of RDATA fields. */ enum ldns_enum_rdf_type { /** none */ LDNS_RDF_TYPE_NONE, /** domain name */ LDNS_RDF_TYPE_DNAME, /** 8 bits */ LDNS_RDF_TYPE_INT8, /** 16 bits */ LDNS_RDF_TYPE_INT16, /** 32 bits */ LDNS_RDF_TYPE_INT32, /** A record */ LDNS_RDF_TYPE_A, /** AAAA record */ LDNS_RDF_TYPE_AAAA, /** txt string */ LDNS_RDF_TYPE_STR, /** apl data */ LDNS_RDF_TYPE_APL, /** b32 string */ LDNS_RDF_TYPE_B32_EXT, /** b64 string */ LDNS_RDF_TYPE_B64, /** hex string */ LDNS_RDF_TYPE_HEX, /** nsec type codes */ LDNS_RDF_TYPE_NSEC, /** a RR type */ LDNS_RDF_TYPE_TYPE, /** a class */ LDNS_RDF_TYPE_CLASS, /** certificate algorithm */ LDNS_RDF_TYPE_CERT_ALG, /** a key algorithm */ LDNS_RDF_TYPE_ALG, /** unknown types */ LDNS_RDF_TYPE_UNKNOWN, /** time (32 bits) */ LDNS_RDF_TYPE_TIME, /** period */ LDNS_RDF_TYPE_PERIOD, /** tsig time 48 bits */ LDNS_RDF_TYPE_TSIGTIME, /** Represents the Public Key Algorithm, HIT and Public Key fields for the HIP RR types. A HIP specific rdf type is used because of the unusual layout in wireformat (see RFC 5205 Section 5) */ LDNS_RDF_TYPE_HIP, /** variable length any type rdata where the length is specified by the first 2 bytes */ LDNS_RDF_TYPE_INT16_DATA, /** protocol and port bitmaps */ LDNS_RDF_TYPE_SERVICE, /** location data */ LDNS_RDF_TYPE_LOC, /** well known services */ LDNS_RDF_TYPE_WKS, /** NSAP */ LDNS_RDF_TYPE_NSAP, /** ATMA */ LDNS_RDF_TYPE_ATMA, /** IPSECKEY */ LDNS_RDF_TYPE_IPSECKEY, /** nsec3 hash salt */ LDNS_RDF_TYPE_NSEC3_SALT, /** nsec3 base32 string (with length byte on wire */ LDNS_RDF_TYPE_NSEC3_NEXT_OWNER, /** 4 shorts represented as 4 * 16 bit hex numbers * separated by colons. For NID and L64. */ LDNS_RDF_TYPE_ILNP64, /** 6 * 8 bit hex numbers separated by dashes. For EUI48. */ LDNS_RDF_TYPE_EUI48, /** 8 * 8 bit hex numbers separated by dashes. For EUI64. */ LDNS_RDF_TYPE_EUI64, /** A non-zero sequence of US-ASCII letters and numbers in lower case. * For CAA. */ LDNS_RDF_TYPE_TAG, /** A encoding of the value field as specified * [RFC1035], Section 5.1., encoded as remaining rdata. * For CAA. */ LDNS_RDF_TYPE_LONG_STR, /* Aliases */ LDNS_RDF_TYPE_BITMAP = LDNS_RDF_TYPE_NSEC }; typedef enum ldns_enum_rdf_type ldns_rdf_type; /** * algorithms used in CERT rrs */ enum ldns_enum_cert_algorithm { LDNS_CERT_PKIX = 1, LDNS_CERT_SPKI = 2, LDNS_CERT_PGP = 3, LDNS_CERT_IPKIX = 4, LDNS_CERT_ISPKI = 5, LDNS_CERT_IPGP = 6, LDNS_CERT_ACPKIX = 7, LDNS_CERT_IACPKIX = 8, LDNS_CERT_URI = 253, LDNS_CERT_OID = 254 }; typedef enum ldns_enum_cert_algorithm ldns_cert_algorithm; /** * Resource record data field. * * The data is a network ordered array of bytes, which size is specified by * the (16-bit) size field. To correctly parse it, use the type * specified in the (16-bit) type field with a value from \ref ldns_rdf_type. */ struct ldns_struct_rdf { /** The size of the data (in octets) */ size_t _size; /** The type of the data */ ldns_rdf_type _type; /** Pointer to the data (raw octets) */ void *_data; }; typedef struct ldns_struct_rdf ldns_rdf; /* prototypes */ /* write access functions */ /** * sets the size of the rdf. * \param[in] *rd the rdf to operate on * \param[in] size the new size * \return void */ void ldns_rdf_set_size(ldns_rdf *rd, size_t size); /** * sets the size of the rdf. * \param[in] *rd the rdf to operate on * \param[in] type the new type * \return void */ void ldns_rdf_set_type(ldns_rdf *rd, ldns_rdf_type type); /** * sets the size of the rdf. * \param[in] *rd the rdf to operate on * \param[in] *data pointer to the new data * \return void */ void ldns_rdf_set_data(ldns_rdf *rd, void *data); /* read access */ /** * returns the size of the rdf. * \param[in] *rd the rdf to read from * \return uint16_t with the size */ size_t ldns_rdf_size(const ldns_rdf *rd); /** * returns the type of the rdf. We need to insert _get_ * here to prevent conflict the the rdf_type TYPE. * \param[in] *rd the rdf to read from * \return ldns_rdf_type with the type */ ldns_rdf_type ldns_rdf_get_type(const ldns_rdf *rd); /** * returns the data of the rdf. * \param[in] *rd the rdf to read from * * \return uint8_t* pointer to the rdf's data */ uint8_t *ldns_rdf_data(const ldns_rdf *rd); /* creator functions */ /** * allocates a new rdf structure and fills it. * This function DOES NOT copy the contents from * the buffer, unlinke ldns_rdf_new_frm_data() * \param[in] type type of the rdf * \param[in] size size of the buffer * \param[in] data pointer to the buffer to be copied * \return the new rdf structure or NULL on failure */ ldns_rdf *ldns_rdf_new(ldns_rdf_type type, size_t size, void *data); /** * allocates a new rdf structure and fills it. * This function _does_ copy the contents from * the buffer, unlinke ldns_rdf_new() * \param[in] type type of the rdf * \param[in] size size of the buffer * \param[in] data pointer to the buffer to be copied * \return the new rdf structure or NULL on failure */ ldns_rdf *ldns_rdf_new_frm_data(ldns_rdf_type type, size_t size, const void *data); /** * creates a new rdf from a string. * \param[in] type type to use * \param[in] str string to use * \return ldns_rdf* or NULL in case of an error */ ldns_rdf *ldns_rdf_new_frm_str(ldns_rdf_type type, const char *str); /** * creates a new rdf from a file containing a string. * \param[out] r the new rdf * \param[in] type type to use * \param[in] fp the file pointer to use * \return LDNS_STATUS_OK or the error */ ldns_status ldns_rdf_new_frm_fp(ldns_rdf **r, ldns_rdf_type type, FILE *fp); /** * creates a new rdf from a file containing a string. * \param[out] r the new rdf * \param[in] type type to use * \param[in] fp the file pointer to use * \param[in] line_nr pointer to an integer containing the current line number (for debugging purposes) * \return LDNS_STATUS_OK or the error */ ldns_status ldns_rdf_new_frm_fp_l(ldns_rdf **r, ldns_rdf_type type, FILE *fp, int *line_nr); /* destroy functions */ /** * frees a rdf structure, leaving the * data pointer intact. * \param[in] rd the pointer to be freed * \return void */ void ldns_rdf_free(ldns_rdf *rd); /** * frees a rdf structure _and_ frees the * data. rdf should be created with _new_frm_data * \param[in] rd the rdf structure to be freed * \return void */ void ldns_rdf_deep_free(ldns_rdf *rd); /* conversion functions */ /** * returns the rdf containing the native uint8_t repr. * \param[in] type the ldns_rdf type to use * \param[in] value the uint8_t to use * \return ldns_rdf* with the converted value */ ldns_rdf *ldns_native2rdf_int8(ldns_rdf_type type, uint8_t value); /** * returns the rdf containing the native uint16_t representation. * \param[in] type the ldns_rdf type to use * \param[in] value the uint16_t to use * \return ldns_rdf* with the converted value */ ldns_rdf *ldns_native2rdf_int16(ldns_rdf_type type, uint16_t value); /** * returns an rdf that contains the given int32 value. * * Because multiple rdf types can contain an int32, the * type must be specified * \param[in] type the ldns_rdf type to use * \param[in] value the uint32_t to use * \return ldns_rdf* with the converted value */ ldns_rdf *ldns_native2rdf_int32(ldns_rdf_type type, uint32_t value); /** * returns an int16_data rdf that contains the data in the * given array, preceded by an int16 specifying the length. * * The memory is copied, and an LDNS_RDF_TYPE_INT16DATA is returned * \param[in] size the size of the data * \param[in] *data pointer to the actual data * * \return ldns_rd* the rdf with the data */ ldns_rdf *ldns_native2rdf_int16_data(size_t size, uint8_t *data); /** * reverses an rdf, only actually useful for AAAA and A records. * The returned rdf has the type LDNS_RDF_TYPE_DNAME! * \param[in] *rd rdf to be reversed * \return the reversed rdf (a newly created rdf) */ ldns_rdf *ldns_rdf_address_reverse(ldns_rdf *rd); /** * returns the native uint8_t representation from the rdf. * \param[in] rd the ldns_rdf to operate on * \return uint8_t the value extracted */ uint8_t ldns_rdf2native_int8(const ldns_rdf *rd); /** * returns the native uint16_t representation from the rdf. * \param[in] rd the ldns_rdf to operate on * \return uint16_t the value extracted */ uint16_t ldns_rdf2native_int16(const ldns_rdf *rd); /** * returns the native uint32_t representation from the rdf. * \param[in] rd the ldns_rdf to operate on * \return uint32_t the value extracted */ uint32_t ldns_rdf2native_int32(const ldns_rdf *rd); /** * returns the native time_t representation from the rdf. * \param[in] rd the ldns_rdf to operate on * \return time_t the value extracted (32 bits currently) */ time_t ldns_rdf2native_time_t(const ldns_rdf *rd); /** * converts a ttl value (like 5d2h) to a long. * \param[in] nptr the start of the string * \param[out] endptr points to the last char in case of error * \return the convert duration value */ uint32_t ldns_str2period(const char *nptr, const char **endptr); /** * removes \\DDD, \\[space] and other escapes from the input. * See RFC 1035, section 5.1. * \param[in] word what to check * \param[in] length the string * \return ldns_status mesg */ ldns_status ldns_octet(char *word, size_t *length); /** * clones a rdf structure. The data is copied. * \param[in] rd rdf to be copied * \return a new rdf structure */ ldns_rdf *ldns_rdf_clone(const ldns_rdf *rd); /** * compares two rdf's on their wire formats. * (To order dnames according to rfc4034, use ldns_dname_compare) * \param[in] rd1 the first one * \param[in] rd2 the second one * \return 0 if equal * \return -1 if rd1 comes before rd2 * \return +1 if rd2 comes before rd1 */ int ldns_rdf_compare(const ldns_rdf *rd1, const ldns_rdf *rd2); /** * Gets the algorithm value, the HIT and Public Key data from the rdf with * type LDNS_RDF_TYPE_HIP. * \param[in] rdf the rdf with type LDNS_RDF_TYPE_HIP * \param[out] alg the algorithm * \param[out] hit_size the size of the HIT data * \param[out] hit the hit data * \param[out] pk_size the size of the Public Key data * \param[out] pk the Public Key data * \return LDNS_STATUS_OK on success, and the error otherwise */ ldns_status ldns_rdf_hip_get_alg_hit_pk(ldns_rdf *rdf, uint8_t* alg, uint8_t *hit_size, uint8_t** hit, uint16_t *pk_size, uint8_t** pk); /** * Creates a new LDNS_RDF_TYPE_HIP rdf from given data. * \param[out] rdf the newly created LDNS_RDF_TYPE_HIP rdf * \param[in] alg the algorithm * \param[in] hit_size the size of the HIT data * \param[in] hit the hit data * \param[in] pk_size the size of the Public Key data * \param[in] pk the Public Key data * \return LDNS_STATUS_OK on success, and the error otherwise */ ldns_status ldns_rdf_hip_new_frm_alg_hit_pk(ldns_rdf** rdf, uint8_t alg, uint8_t hit_size, uint8_t *hit, uint16_t pk_size, uint8_t *pk); #ifdef __cplusplus } #endif #endif /* LDNS_RDATA_H */ ldns-1.6.17/ldns/wire2host.h0000664000175100017510000001613512264060151015160 0ustar willemwillem/* * wire2host.h - from wire conversion routines * * a Net::DNS like library for C * * (c) NLnet Labs, 2005-2006 * * See the file LICENSE for the license */ /** * \file * * Contains functions that translate dns data from the wire format (as sent * by servers and clients) to the internal structures. */ #ifndef LDNS_WIRE2HOST_H #define LDNS_WIRE2HOST_H #include #include #include #include #include #ifdef __cplusplus extern "C" { #endif /* The length of the header */ #define LDNS_HEADER_SIZE 12 /* First octet of flags */ #define LDNS_RD_MASK 0x01U #define LDNS_RD_SHIFT 0 #define LDNS_RD_WIRE(wirebuf) (*(wirebuf+2) & LDNS_RD_MASK) #define LDNS_RD_SET(wirebuf) (*(wirebuf+2) |= LDNS_RD_MASK) #define LDNS_RD_CLR(wirebuf) (*(wirebuf+2) &= ~LDNS_RD_MASK) #define LDNS_TC_MASK 0x02U #define LDNS_TC_SHIFT 1 #define LDNS_TC_WIRE(wirebuf) (*(wirebuf+2) & LDNS_TC_MASK) #define LDNS_TC_SET(wirebuf) (*(wirebuf+2) |= LDNS_TC_MASK) #define LDNS_TC_CLR(wirebuf) (*(wirebuf+2) &= ~LDNS_TC_MASK) #define LDNS_AA_MASK 0x04U #define LDNS_AA_SHIFT 2 #define LDNS_AA_WIRE(wirebuf) (*(wirebuf+2) & LDNS_AA_MASK) #define LDNS_AA_SET(wirebuf) (*(wirebuf+2) |= LDNS_AA_MASK) #define LDNS_AA_CLR(wirebuf) (*(wirebuf+2) &= ~LDNS_AA_MASK) #define LDNS_OPCODE_MASK 0x78U #define LDNS_OPCODE_SHIFT 3 #define LDNS_OPCODE_WIRE(wirebuf) ((*(wirebuf+2) & LDNS_OPCODE_MASK) >> LDNS_OPCODE_SHIFT) #define LDNS_OPCODE_SET(wirebuf, opcode) \ (*(wirebuf+2) = ((*(wirebuf+2)) & ~LDNS_OPCODE_MASK) | ((opcode) << LDNS_OPCODE_SHIFT)) #define LDNS_QR_MASK 0x80U #define LDNS_QR_SHIFT 7 #define LDNS_QR_WIRE(wirebuf) (*(wirebuf+2) & LDNS_QR_MASK) #define LDNS_QR_SET(wirebuf) (*(wirebuf+2) |= LDNS_QR_MASK) #define LDNS_QR_CLR(wirebuf) (*(wirebuf+2) &= ~LDNS_QR_MASK) /* Second octet of flags */ #define LDNS_RCODE_MASK 0x0fU #define LDNS_RCODE_SHIFT 0 #define LDNS_RCODE_WIRE(wirebuf) (*(wirebuf+3) & LDNS_RCODE_MASK) #define LDNS_RCODE_SET(wirebuf, rcode) \ (*(wirebuf+3) = ((*(wirebuf+3)) & ~LDNS_RCODE_MASK) | (rcode)) #define LDNS_CD_MASK 0x10U #define LDNS_CD_SHIFT 4 #define LDNS_CD_WIRE(wirebuf) (*(wirebuf+3) & LDNS_CD_MASK) #define LDNS_CD_SET(wirebuf) (*(wirebuf+3) |= LDNS_CD_MASK) #define LDNS_CD_CLR(wirebuf) (*(wirebuf+3) &= ~LDNS_CD_MASK) #define LDNS_AD_MASK 0x20U #define LDNS_AD_SHIFT 5 #define LDNS_AD_WIRE(wirebuf) (*(wirebuf+3) & LDNS_AD_MASK) #define LDNS_AD_SET(wirebuf) (*(wirebuf+3) |= LDNS_AD_MASK) #define LDNS_AD_CLR(wirebuf) (*(wirebuf+3) &= ~LDNS_AD_MASK) #define LDNS_Z_MASK 0x40U #define LDNS_Z_SHIFT 6 #define LDNS_Z_WIRE(wirebuf) (*(wirebuf+3) & LDNS_Z_MASK) #define LDNS_Z_SET(wirebuf) (*(wirebuf+3) |= LDNS_Z_MASK) #define LDNS_Z_CLR(wirebuf) (*(wirebuf+3) &= ~LDNS_Z_MASK) #define LDNS_RA_MASK 0x80U #define LDNS_RA_SHIFT 7 #define LDNS_RA_WIRE(wirebuf) (*(wirebuf+3) & LDNS_RA_MASK) #define LDNS_RA_SET(wirebuf) (*(wirebuf+3) |= LDNS_RA_MASK) #define LDNS_RA_CLR(wirebuf) (*(wirebuf+3) &= ~LDNS_RA_MASK) /* Query ID */ #define LDNS_ID_WIRE(wirebuf) (ldns_read_uint16(wirebuf)) #define LDNS_ID_SET(wirebuf, id) (ldns_write_uint16(wirebuf, id)) /* Counter of the question section */ #define LDNS_QDCOUNT_OFF 4 /* #define QDCOUNT(wirebuf) (ntohs(*(uint16_t *)(wirebuf+QDCOUNT_OFF))) */ #define LDNS_QDCOUNT(wirebuf) (ldns_read_uint16(wirebuf+LDNS_QDCOUNT_OFF)) /* Counter of the answer section */ #define LDNS_ANCOUNT_OFF 6 #define LDNS_ANCOUNT(wirebuf) (ldns_read_uint16(wirebuf+LDNS_ANCOUNT_OFF)) /* Counter of the authority section */ #define LDNS_NSCOUNT_OFF 8 #define LDNS_NSCOUNT(wirebuf) (ldns_read_uint16(wirebuf+LDNS_NSCOUNT_OFF)) /* Counter of the additional section */ #define LDNS_ARCOUNT_OFF 10 #define LDNS_ARCOUNT(wirebuf) (ldns_read_uint16(wirebuf+LDNS_ARCOUNT_OFF)) /** * converts the data on the uint8_t bytearray (in wire format) to a DNS packet. * This function will initialize and allocate memory space for the packet * structure. * * \param[in] packet pointer to the structure to hold the packet * \param[in] data pointer to the buffer with the data * \param[in] len the length of the data buffer (in bytes) * \return LDNS_STATUS_OK if everything succeeds, error otherwise */ ldns_status ldns_wire2pkt(ldns_pkt **packet, const uint8_t *data, size_t len); /** * converts the data on the uint8_t bytearray (in wire format) to a DNS packet. * This function will initialize and allocate memory space for the packet * structure. * * \param[in] packet pointer to the structure to hold the packet * \param[in] buffer the buffer with the data * \return LDNS_STATUS_OK if everything succeeds, error otherwise */ ldns_status ldns_buffer2pkt_wire(ldns_pkt **packet, ldns_buffer *buffer); /** * converts the data on the uint8_t bytearray (in wire format) to a DNS * dname rdata field. This function will initialize and allocate memory * space for the dname structure. The length of the wiredata of this rdf * is added to the *pos value. * * \param[in] dname pointer to the structure to hold the rdata value * \param[in] wire pointer to the buffer with the data * \param[in] max the length of the data buffer (in bytes) * \param[in] pos the position of the rdf in the buffer (ie. the number of bytes * from the start of the buffer) * \return LDNS_STATUS_OK if everything succeeds, error otherwise */ ldns_status ldns_wire2dname(ldns_rdf **dname, const uint8_t *wire, size_t max, size_t *pos); /** * converts the data on the uint8_t bytearray (in wire format) to DNS * rdata fields, and adds them to the list of rdfs of the given rr. * This function will initialize and allocate memory space for the dname * structures. * The length of the wiredata of these rdfs is added to the *pos value. * * All rdfs belonging to the RR are read; the rr should have no rdfs * yet. An error is returned if the format cannot be parsed. * * \param[in] rr pointer to the ldns_rr structure to hold the rdata value * \param[in] wire pointer to the buffer with the data * \param[in] max the length of the data buffer (in bytes) * \param[in] pos the position of the rdf in the buffer (ie. the number of bytes * from the start of the buffer) * \return LDNS_STATUS_OK if everything succeeds, error otherwise */ ldns_status ldns_wire2rdf(ldns_rr *rr, const uint8_t *wire, size_t max, size_t *pos); /** * converts the data on the uint8_t bytearray (in wire format) to a DNS * resource record. * This function will initialize and allocate memory space for the rr * structure. * The length of the wiredata of this rr is added to the *pos value. * * \param[in] rr pointer to the structure to hold the rdata value * \param[in] wire pointer to the buffer with the data * \param[in] max the length of the data buffer (in bytes) * \param[in] pos the position of the rr in the buffer (ie. the number of bytes * from the start of the buffer) * \param[in] section the section in the packet the rr is meant for * \return LDNS_STATUS_OK if everything succeeds, error otherwise */ ldns_status ldns_wire2rr(ldns_rr **rr, const uint8_t *wire, size_t max, size_t *pos, ldns_pkt_section section); #ifdef __cplusplus } #endif #endif /* LDNS_WIRE2HOST_H */ ldns-1.6.17/ldns/str2host.h0000664000175100017510000002051012264060151015012 0ustar willemwillem/** * str2host.h - conversion from str to the host fmt * * a Net::DNS like library for C * * (c) NLnet Labs, 2005-2006 * * See the file LICENSE for the license */ #ifndef LDNS_2HOST_H #define LDNS_2HOST_H #include #include #include #include #include #include #include #ifdef __cplusplus extern "C" { #endif /** * \file * * Defines functions to convert dns data in presentation format or text files * to internal structures. */ /** * convert a byte into wireformat * \param[in] rd the rdf where to put the data * \param[in] bytestr the string to be converted * \return ldns_status */ ldns_status ldns_str2rdf_int8(ldns_rdf **rd, const char *bytestr); /** * convert a string to a int16 in wireformat * \param[in] rd the rdf where to put the data * \param[in] shortstr the string to be converted * \return ldns_status */ ldns_status ldns_str2rdf_int16(ldns_rdf **rd, const char *shortstr); /** * convert a strings into a 4 byte int in wireformat * \param[in] rd the rdf where to put the data * \param[in] longstr the string to be converted * \return ldns_status */ ldns_status ldns_str2rdf_int32(ldns_rdf **rd, const char *longstr); /** * convert a time string to a time value in wireformat * \param[in] rd the rdf where to put the data * \param[in] time the string to be converted * \return ldns_status */ ldns_status ldns_str2rdf_time(ldns_rdf **rd, const char *time); /* convert string with NSEC3 salt to wireformat) * \param[in] rd the rdf where to put the data * \param[in] str the string to be converted * return ldns_status */ ldns_status ldns_str2rdf_nsec3_salt(ldns_rdf **rd, const char *nsec3_salt); /* convert a time period (think TTL's) to wireformat) * \param[in] rd the rdf where to put the data * \param[in] str the string to be converted * return ldns_status */ ldns_status ldns_str2rdf_period(ldns_rdf **rd, const char *str); /** * convert str with an A record into wireformat * \param[in] rd the rdf where to put the data * \param[in] str the string to be converted * \return ldns_status */ ldns_status ldns_str2rdf_a(ldns_rdf **rd, const char *str); /** * convert the str with an AAAA record into wireformat * \param[in] rd the rdf where to put the data * \param[in] str the string to be converted * \return ldns_status */ ldns_status ldns_str2rdf_aaaa(ldns_rdf **rd, const char *str); /** * convert a string into wireformat (think txt record) * \param[in] rd the rdf where to put the data * \param[in] str the string to be converted (NULL terminated) * \return ldns_status */ ldns_status ldns_str2rdf_str(ldns_rdf **rd, const char *str); /** * convert str with the apl record into wireformat * \param[in] rd the rdf where to put the data * \param[in] str the string to be converted * \return ldns_status */ ldns_status ldns_str2rdf_apl(ldns_rdf **rd, const char *str); /** * convert the string with the b64 data into wireformat * \param[in] rd the rdf where to put the data * \param[in] str the string to be converted * \return ldns_status */ ldns_status ldns_str2rdf_b64(ldns_rdf **rd, const char *str); /** * convert the string with the b32 ext hex data into wireformat * \param[in] rd the rdf where to put the data * \param[in] str the string to be converted * \return ldns_status */ ldns_status ldns_str2rdf_b32_ext(ldns_rdf **rd, const char *str); /** * convert a hex value into wireformat * \param[in] rd the rdf where to put the data * \param[in] str the string to be converted * \return ldns_status */ ldns_status ldns_str2rdf_hex(ldns_rdf **rd, const char *str); /** * convert string with nsec into wireformat * \param[in] rd the rdf where to put the data * \param[in] str the string to be converted * \return ldns_status */ ldns_status ldns_str2rdf_nsec(ldns_rdf **rd, const char *str); /** * convert a rrtype into wireformat * \param[in] rd the rdf where to put the data * \param[in] str the string to be converted * \return ldns_status */ ldns_status ldns_str2rdf_type(ldns_rdf **rd, const char *str); /** * convert string with a classname into wireformat * \param[in] rd the rdf where to put the data * \param[in] str the string to be converted * \return ldns_status */ ldns_status ldns_str2rdf_class(ldns_rdf **rd, const char *str); /** * convert an certificate algorithm value into wireformat * \param[in] rd the rdf where to put the data * \param[in] str the string to be converted * \return ldns_status */ ldns_status ldns_str2rdf_cert_alg(ldns_rdf **rd, const char *str); /** * convert and algorithm value into wireformat * \param[in] rd the rdf where to put the data * \param[in] str the string to be converted * \return ldns_status */ ldns_status ldns_str2rdf_alg(ldns_rdf **rd, const char *str); /** * convert a string with a unknown RR into wireformat * \param[in] rd the rdf where to put the data * \param[in] str the string to be converted * \return ldns_status */ ldns_status ldns_str2rdf_unknown(ldns_rdf **rd, const char *str); /** * convert string with a protocol service into wireformat * \param[in] rd the rdf where to put the data * \param[in] str the string to be converted * \return ldns_status */ ldns_status ldns_str2rdf_service(ldns_rdf **rd, const char *str); /** * convert a string with a LOC RR into wireformat * \param[in] rd the rdf where to put the data * \param[in] str the string to be converted * \return ldns_status */ ldns_status ldns_str2rdf_loc(ldns_rdf **rd, const char *str); /** * convert string with a WKS RR into wireformat * \param[in] rd the rdf where to put the data * \param[in] str the string to be converted * \return ldns_status */ ldns_status ldns_str2rdf_wks(ldns_rdf **rd, const char *str); /** * convert a str with a NSAP RR into wireformat * \param[in] rd the rdf where to put the data * \param[in] str the string to be converted * \return ldns_status */ ldns_status ldns_str2rdf_nsap(ldns_rdf **rd, const char *str); /** * convert a str with a ATMA RR into wireformat * \param[in] rd the rdf where to put the data * \param[in] str the string to be converted * \return ldns_status */ ldns_status ldns_str2rdf_atma(ldns_rdf **rd, const char *str); /** * convert a str with a IPSECKEY RR into wireformat * \param[in] rd the rdf where to put the data * \param[in] str the string to be converted * \return ldns_status */ ldns_status ldns_str2rdf_ipseckey(ldns_rdf **rd, const char *str); /** * convert a dname string into wireformat * \param[in] rd the rdf where to put the data * \param[in] str the string to be converted * \return ldns_status */ ldns_status ldns_str2rdf_dname(ldns_rdf **rd, const char *str); /** * convert 4 * 16bit hex separated by colons into wireformat * \param[in] rd the rdf where to put the data * \param[in] str the string to be converted * \return ldns_status */ ldns_status ldns_str2rdf_ilnp64(ldns_rdf **rd, const char *str); /** * convert 6 hex bytes separated by dashes into wireformat * \param[in] rd the rdf where to put the data * \param[in] str the string to be converted * \return ldns_status */ ldns_status ldns_str2rdf_eui48(ldns_rdf **rd, const char *str); /** * convert 8 hex bytes separated by dashes into wireformat * \param[in] rd the rdf where to put the data * \param[in] str the string to be converted * \return ldns_status */ ldns_status ldns_str2rdf_eui64(ldns_rdf **rd, const char *str); /** * Convert a non-zero sequence of US-ASCII letters and numbers into wireformat * \param[in] rd the rdf where to put the data * \param[in] str the string to be converted * \return ldns_status */ ldns_status ldns_str2rdf_tag(ldns_rdf **rd, const char *str); /** * Convert a encoding of the value field as specified * [RFC1035], Section 5.1., encoded as one bug chunk of data. * \param[in] rd the rdf where to put the data * \param[in] str the string to be converted * \return ldns_status */ ldns_status ldns_str2rdf_long_str(ldns_rdf **rd, const char *str); /** * Convert a " " encoding of the value field as specified * in Section 6. of [RFC5205], encoded as wireformat as specified in Section 5. * of [RFC5205]. * \param[in] rd the rdf where to put the data * \param[in] str the string to be converted * \return ldns_status */ ldns_status ldns_str2rdf_hip(ldns_rdf **rd, const char *str); #ifdef __cplusplus } #endif #endif /* LDNS_2HOST_H */ ldns-1.6.17/ldns/host2wire.h0000664000175100017510000001200212264060151015145 0ustar willemwillem/* * host2wire.h - 2wire conversion routines * * a Net::DNS like library for C * * (c) NLnet Labs, 2005-2006 * * See the file LICENSE for the license */ /** * \file * * Contains all functions to translate the main structures to wire format */ #ifndef LDNS_HOST2WIRE_H #define LDNS_HOST2WIRE_H #include #include #include #include #include #include #include #include "ldns/util.h" #ifdef __cplusplus extern "C" { #endif /** * Copies the dname data to the buffer in wire format * \param[out] *buffer buffer to append the result to * \param[in] *name rdata dname to convert * \return ldns_status */ ldns_status ldns_dname2buffer_wire(ldns_buffer *buffer, const ldns_rdf *name); /** * Copies the rdata data to the buffer in wire format * \param[out] *output buffer to append the result to * \param[in] *rdf rdata to convert * \return ldns_status */ ldns_status ldns_rdf2buffer_wire(ldns_buffer *output, const ldns_rdf *rdf); /** * Copies the rdata data to the buffer in wire format * If the rdata is a dname, the letters will be lowercased * during the conversion * \param[out] *output buffer to append the result to * \param[in] *rdf rdata to convert * \return ldns_status */ ldns_status ldns_rdf2buffer_wire_canonical(ldns_buffer *output, const ldns_rdf *rdf); /** * Copies the rr data to the buffer in wire format * \param[out] *output buffer to append the result to * \param[in] *rr resource record to convert * \param[in] section the section in the packet this rr is supposed to be in * (to determine whether to add rdata or not) * \return ldns_status */ ldns_status ldns_rr2buffer_wire(ldns_buffer *output, const ldns_rr *rr, int section); /** * Copies the rr data to the buffer in wire format, in canonical format * according to RFC3597 (every dname in rdata fields of RR's mentioned in * that RFC will be lowercased) * \param[out] *output buffer to append the result to * \param[in] *rr resource record to convert * \param[in] section the section in the packet this rr is supposed to be in * (to determine whether to add rdata or not) * \return ldns_status */ ldns_status ldns_rr2buffer_wire_canonical(ldns_buffer *output, const ldns_rr *rr, int section); /** * Converts a rrsig to wireformat BUT EXCLUDE the rrsig rdata * This is needed in DNSSEC verification * \param[out] output buffer to append the result to * \param[in] sigrr signature rr to operate on * \return ldns_status */ ldns_status ldns_rrsig2buffer_wire(ldns_buffer *output, const ldns_rr *sigrr); /** * Converts an rr's rdata to wireformat, while excluding * the ownername and all the stuff before the rdata. * This is needed in DNSSEC keytag calculation, the ds * calcalution from the key and maybe elsewhere. * * \param[out] *output buffer where to put the result * \param[in] *rr rr to operate on * \return ldns_status */ ldns_status ldns_rr_rdata2buffer_wire(ldns_buffer *output, const ldns_rr *rr); /** * Copies the packet data to the buffer in wire format * \param[out] *output buffer to append the result to * \param[in] *pkt packet to convert * \return ldns_status */ ldns_status ldns_pkt2buffer_wire(ldns_buffer *output, const ldns_pkt *pkt); /** * Copies the rr_list data to the buffer in wire format * \param[out] *output buffer to append the result to * \param[in] *rrlist rr_list to to convert * \return ldns_status */ ldns_status ldns_rr_list2buffer_wire(ldns_buffer *output, const ldns_rr_list *rrlist); /** * Allocates an array of uint8_t at dest, and puts the wireformat of the * given rdf in that array. The result_size value contains the * length of the array, if it succeeds, and 0 otherwise (in which case * the function also returns NULL) * * \param[out] dest pointer to the array of bytes to be created * \param[in] rdf the rdata field to convert * \param[out] size the size of the converted result */ ldns_status ldns_rdf2wire(uint8_t **dest, const ldns_rdf *rdf, size_t *size); /** * Allocates an array of uint8_t at dest, and puts the wireformat of the * given rr in that array. The result_size value contains the * length of the array, if it succeeds, and 0 otherwise (in which case * the function also returns NULL) * * If the section argument is LDNS_SECTION_QUESTION, data like ttl and rdata * are not put into the result * * \param[out] dest pointer to the array of bytes to be created * \param[in] rr the rr to convert * \param[out] size the size of the converted result */ ldns_status ldns_rr2wire(uint8_t **dest, const ldns_rr *rr, int, size_t *size); /** * Allocates an array of uint8_t at dest, and puts the wireformat of the * given packet in that array. The result_size value contains the * length of the array, if it succeeds, and 0 otherwise (in which case * the function also returns NULL) */ ldns_status ldns_pkt2wire(uint8_t **dest, const ldns_pkt *p, size_t *size); #ifdef __cplusplus } #endif #endif /* LDNS_HOST2WIRE_H */ ldns-1.6.17/ldns/parse.h0000664000175100017510000001276512264060151014351 0ustar willemwillem/* * parse.h * * a Net::DNS like library for C * LibDNS Team @ NLnet Labs * (c) NLnet Labs, 2005-2006 * See the file LICENSE for the license */ #ifndef LDNS_PARSE_H #define LDNS_PARSE_H #include #include #ifdef __cplusplus extern "C" { #endif #define LDNS_PARSE_SKIP_SPACE "\f\n\r\v" #define LDNS_PARSE_NORMAL " \f\n\r\t\v" #define LDNS_PARSE_NO_NL " \t" #define LDNS_MAX_LINELEN 10230 #define LDNS_MAX_KEYWORDLEN 32 /** * \file * * Contains some low-level parsing functions, mostly used in the _frm_str * family of functions. */ /** * different type of directives in zone files * We now deal with $TTL, $ORIGIN and $INCLUDE. * The latter is not implemented in ldns (yet) */ enum ldns_enum_directive { LDNS_DIR_TTL, LDNS_DIR_ORIGIN, LDNS_DIR_INCLUDE }; typedef enum ldns_enum_directive ldns_directive; /** * returns a token/char from the stream F. * This function deals with ( and ) in the stream, * and ignores them when encountered * \param[in] *f the file to read from * \param[out] *token the read token is put here * \param[in] *delim chars at which the parsing should stop * \param[in] *limit how much to read. If 0 the builtin maximum is used * \return 0 on error of EOF of the stream F. Otherwise return the length of what is read */ ssize_t ldns_fget_token(FILE *f, char *token, const char *delim, size_t limit); /** * returns a token/char from the stream F. * This function deals with ( and ) in the stream, * and ignores when it finds them. * \param[in] *f the file to read from * \param[out] *token the token is put here * \param[in] *delim chars at which the parsing should stop * \param[in] *limit how much to read. If 0 use builtin maximum * \param[in] line_nr pointer to an integer containing the current line number (for debugging purposes) * \return 0 on error of EOF of F otherwise return the length of what is read */ ssize_t ldns_fget_token_l(FILE *f, char *token, const char *delim, size_t limit, int *line_nr); /** * returns a token/char from the buffer b. * This function deals with ( and ) in the buffer, * and ignores when it finds them. * \param[in] *b the buffer to read from * \param[out] *token the token is put here * \param[in] *delim chars at which the parsing should stop * \param[in] *limit how much to read. If 0 the builtin maximum is used * \returns 0 on error of EOF of b. Otherwise return the length of what is read */ ssize_t ldns_bget_token(ldns_buffer *b, char *token, const char *delim, size_t limit); /* * searches for keyword and delim in a file. Gives everything back * after the keyword + k_del until we hit d_del * \param[in] f file pointer to read from * \param[in] keyword keyword to look for * \param[in] k_del keyword delimeter * \param[out] data the data found * \param[in] d_del the data delimeter * \param[in] data_limit maximum size the the data buffer * \return the number of character read */ ssize_t ldns_fget_keyword_data(FILE *f, const char *keyword, const char *k_del, char *data, const char *d_del, size_t data_limit); /* * searches for keyword and delim. Gives everything back * after the keyword + k_del until we hit d_del * \param[in] f file pointer to read from * \param[in] keyword keyword to look for * \param[in] k_del keyword delimeter * \param[out] data the data found * \param[in] d_del the data delimeter * \param[in] data_limit maximum size the the data buffer * \param[in] line_nr pointer to an integer containing the current line number (for debugging purposes) * \return the number of character read */ ssize_t ldns_fget_keyword_data_l(FILE *f, const char *keyword, const char *k_del, char *data, const char *d_del, size_t data_limit, int *line_nr); /* * searches for keyword and delim in a buffer. Gives everything back * after the keyword + k_del until we hit d_del * \param[in] b buffer pointer to read from * \param[in] keyword keyword to look for * \param[in] k_del keyword delimeter * \param[out] data the data found * \param[in] d_del the data delimeter * \param[in] data_limit maximum size the the data buffer * \return the number of character read */ ssize_t ldns_bget_keyword_data(ldns_buffer *b, const char *keyword, const char *k_del, char *data, const char *d_del, size_t data_limit); /** * returns the next character from a buffer. Advances the position pointer with 1. * When end of buffer is reached returns EOF. This is the buffer's equivalent * for getc(). * \param[in] *buffer buffer to read from * \return EOF on failure otherwise return the character */ int ldns_bgetc(ldns_buffer *buffer); /** * skips all of the characters in the given string in the buffer, moving * the position to the first character that is not in *s. * \param[in] *buffer buffer to use * \param[in] *s characters to skip * \return void */ void ldns_bskipcs(ldns_buffer *buffer, const char *s); /** * skips all of the characters in the given string in the fp, moving * the position to the first character that is not in *s. * \param[in] *fp file to use * \param[in] *s characters to skip * \return void */ void ldns_fskipcs(FILE *fp, const char *s); /** * skips all of the characters in the given string in the fp, moving * the position to the first character that is not in *s. * \param[in] *fp file to use * \param[in] *s characters to skip * \param[in] line_nr pointer to an integer containing the current line number (for debugging purposes) * \return void */ void ldns_fskipcs_l(FILE *fp, const char *s, int *line_nr); #ifdef __cplusplus } #endif #endif /* LDNS_PARSE_H */ ldns-1.6.17/ldns/config.h.in0000664000175100017510000003370212264060162015105 0ustar willemwillem/* ldns/config.h.in. Generated from configure.ac by autoheader. */ /* Define if building universal (internal helper macro) */ #undef AC_APPLE_UNIVERSAL_BUILD /* Define to 1 if you have the header file. */ #undef HAVE_ARPA_INET_H /* Whether the C compiler accepts the "format" attribute */ #undef HAVE_ATTR_FORMAT /* Whether the C compiler accepts the "unused" attribute */ #undef HAVE_ATTR_UNUSED /* Define to 1 if you have the `b32_ntop' function. */ #undef HAVE_B32_NTOP /* Define to 1 if you have the `b32_pton' function. */ #undef HAVE_B32_PTON /* Define to 1 if you have the `b64_ntop' function. */ #undef HAVE_B64_NTOP /* Define to 1 if you have the `b64_pton' function. */ #undef HAVE_B64_PTON /* Define to 1 if you have the `bzero' function. */ #undef HAVE_BZERO /* Define to 1 if you have the `calloc' function. */ #undef HAVE_CALLOC /* Define to 1 if you have the `ctime_r' function. */ #undef HAVE_CTIME_R /* Is a CAFILE given at configure time */ #undef HAVE_DANE_CA_FILE /* Is a CAPATH given at configure time */ #undef HAVE_DANE_CA_PATH /* Define to 1 if you have the declaration of `NID_secp384r1', and to 0 if you don't. */ #undef HAVE_DECL_NID_SECP384R1 /* Define to 1 if you have the declaration of `NID_X9_62_prime256v1', and to 0 if you don't. */ #undef HAVE_DECL_NID_X9_62_PRIME256V1 /* Define to 1 if you have the header file. */ #undef HAVE_DLFCN_H /* Define to 1 if you have the `endprotoent' function. */ #undef HAVE_ENDPROTOENT /* Define to 1 if you have the `endservent' function. */ #undef HAVE_ENDSERVENT /* Define to 1 if you have the `EVP_sha256' function. */ #undef HAVE_EVP_SHA256 /* Define to 1 if you have the `fcntl' function. */ #undef HAVE_FCNTL /* Define to 1 if you have the `fork' function. */ #undef HAVE_FORK /* Whether getaddrinfo is available */ #undef HAVE_GETADDRINFO /* Define to 1 if you have the header file. */ #undef HAVE_GETOPT_H /* Define to 1 if you have the `gmtime_r' function. */ #undef HAVE_GMTIME_R /* If you have HMAC_CTX_init */ #undef HAVE_HMAC_CTX_INIT /* Define to 1 if you have the `inet_aton' function. */ #undef HAVE_INET_ATON /* Define to 1 if you have the `inet_ntop' function. */ #undef HAVE_INET_NTOP /* Define to 1 if you have the `inet_pton' function. */ #undef HAVE_INET_PTON /* define if you have inttypes.h */ #undef HAVE_INTTYPES_H /* if the function 'ioctlsocket' is available */ #undef HAVE_IOCTLSOCKET /* Define to 1 if you have the `isascii' function. */ #undef HAVE_ISASCII /* Define to 1 if you have the `isblank' function. */ #undef HAVE_ISBLANK /* Define to 1 if you have the `pcap' library (-lpcap). */ #undef HAVE_LIBPCAP /* Define to 1 if you have the `localtime_r' function. */ #undef HAVE_LOCALTIME_R /* Define to 1 if your system has a GNU libc compatible `malloc' function, and to 0 otherwise. */ #undef HAVE_MALLOC /* Define to 1 if you have the `memmove' function. */ #undef HAVE_MEMMOVE /* Define to 1 if you have the header file. */ #undef HAVE_MEMORY_H /* Define to 1 if you have the `memset' function. */ #undef HAVE_MEMSET /* Define to 1 if you have the header file. */ #undef HAVE_NETDB_H /* Define to 1 if you have the header file. */ #undef HAVE_NETINET_IF_ETHER_H /* Define to 1 if you have the header file. */ #undef HAVE_NETINET_IGMP_H /* Define to 1 if you have the header file. */ #undef HAVE_NETINET_IN_H /* Define to 1 if you have the header file. */ #undef HAVE_NETINET_IN_SYSTM_H /* Define to 1 if you have the header file. */ #undef HAVE_NETINET_IP6_H /* Define to 1 if you have the header file. */ #undef HAVE_NETINET_IP_COMPAT_H /* Define to 1 if you have the header file. */ #undef HAVE_NETINET_IP_H /* Define to 1 if you have the header file. */ #undef HAVE_NETINET_UDP_H /* Define to 1 if you have the header file. */ #undef HAVE_NET_ETHERNET_H /* Define to 1 if you have the header file. */ #undef HAVE_NET_IF_H /* Define to 1 if you have the header file. */ #undef HAVE_OPENSSL_ERR_H /* Define to 1 if you have the header file. */ #undef HAVE_OPENSSL_RAND_H /* Define to 1 if you have the header file. */ #undef HAVE_OPENSSL_SSL_H /* Define to 1 if you have the header file. */ #undef HAVE_PCAP_H /* If available, contains the Python version number currently in use. */ #undef HAVE_PYTHON /* Define to 1 if you have the `random' function. */ #undef HAVE_RANDOM /* Define to 1 if your system has a GNU libc compatible `realloc' function, and to 0 otherwise. */ #undef HAVE_REALLOC /* Define to 1 if you have the `sleep' function. */ #undef HAVE_SLEEP /* Define to 1 if you have the `snprintf' function. */ #undef HAVE_SNPRINTF /* Define if you have the SSL libraries installed. */ #undef HAVE_SSL /* Define to 1 if you have the header file. */ #undef HAVE_STDARG_H /* Define to 1 if stdbool.h conforms to C99. */ #undef HAVE_STDBOOL_H /* Define to 1 if you have the header file. */ #undef HAVE_STDINT_H /* Define to 1 if you have the header file. */ #undef HAVE_STDLIB_H /* Define to 1 if you have the header file. */ #undef HAVE_STRINGS_H /* Define to 1 if you have the header file. */ #undef HAVE_STRING_H /* Define to 1 if you have the `strlcpy' function. */ #undef HAVE_STRLCPY /* Define to 1 if you have the `strtoul' function. */ #undef HAVE_STRTOUL /* Define if you have SWIG libraries and header files. */ #undef HAVE_SWIG /* Define to 1 if you have the header file. */ #undef HAVE_SYS_MOUNT_H /* Define to 1 if you have the header file. */ #undef HAVE_SYS_PARAM_H /* define if you have sys/socket.h */ #undef HAVE_SYS_SOCKET_H /* Define to 1 if you have the header file. */ #undef HAVE_SYS_STAT_H /* define if you have sys/types.h */ #undef HAVE_SYS_TYPES_H /* Define to 1 if you have the `timegm' function. */ #undef HAVE_TIMEGM /* Define to 1 if you have the header file. */ #undef HAVE_TIME_H /* define if you have unistd.h */ #undef HAVE_UNISTD_H /* Define to 1 if you have the `vfork' function. */ #undef HAVE_VFORK /* Define to 1 if you have the header file. */ #undef HAVE_VFORK_H /* Define to 1 if you have the header file. */ #undef HAVE_WINSOCK2_H /* Define to 1 if `fork' works. */ #undef HAVE_WORKING_FORK /* Define to 1 if `vfork' works. */ #undef HAVE_WORKING_VFORK /* Define to 1 if you have the header file. */ #undef HAVE_WS2TCPIP_H /* Define to 1 if the system has the type `_Bool'. */ #undef HAVE__BOOL /* Is a CAFILE given at configure time */ #undef LDNS_DANE_CA_FILE /* Is a CAPATH given at configure time */ #undef LDNS_DANE_CA_PATH /* Default trust anchor file */ #undef LDNS_TRUST_ANCHOR_FILE /* Define to the sub-directory in which libtool stores uninstalled libraries. */ #undef LT_OBJDIR /* Define to the address where bug reports for this package should be sent. */ #undef PACKAGE_BUGREPORT /* Define to the full name of this package. */ #undef PACKAGE_NAME /* Define to the full name and version of this package. */ #undef PACKAGE_STRING /* Define to the one symbol short name of this package. */ #undef PACKAGE_TARNAME /* Define to the home page for this package. */ #undef PACKAGE_URL /* Define to the version of this package. */ #undef PACKAGE_VERSION /* Define this to enable RR type CDS. */ #undef RRTYPE_CDS /* Define this to enable RR type NINFO. */ #undef RRTYPE_NINFO /* Define this to enable RR type RKEY. */ #undef RRTYPE_RKEY /* Define this to enable RR type TA. */ #undef RRTYPE_TA /* Define this to enable RR type URI. */ #undef RRTYPE_URI /* The size of `time_t', as computed by sizeof. */ #undef SIZEOF_TIME_T /* Define to 1 if you have the ANSI C header files. */ #undef STDC_HEADERS /* Define this to enable messages to stderr. */ #undef STDERR_MSGS /* System configuration dir */ #undef SYSCONFDIR /* Define this to enable DANE support. */ #undef USE_DANE /* Define this to enable ECDSA support. */ #undef USE_ECDSA /* Define this to enable GOST support. */ #undef USE_GOST /* Define this to enable SHA256 and SHA512 support. */ #undef USE_SHA2 /* Enable extensions on AIX 3, Interix. */ #ifndef _ALL_SOURCE # undef _ALL_SOURCE #endif /* Enable GNU extensions on systems that have them. */ #ifndef _GNU_SOURCE # undef _GNU_SOURCE #endif /* Enable threading extensions on Solaris. */ #ifndef _POSIX_PTHREAD_SEMANTICS # undef _POSIX_PTHREAD_SEMANTICS #endif /* Enable extensions on HP NonStop. */ #ifndef _TANDEM_SOURCE # undef _TANDEM_SOURCE #endif /* Enable general extensions on Solaris. */ #ifndef __EXTENSIONS__ # undef __EXTENSIONS__ #endif /* Whether the windows socket API is used */ #undef USE_WINSOCK /* the version of the windows API enabled */ #undef WINVER /* Define WORDS_BIGENDIAN to 1 if your processor stores words with the most significant byte first (like Motorola and SPARC, unlike Intel). */ #if defined AC_APPLE_UNIVERSAL_BUILD # if defined __BIG_ENDIAN__ # define WORDS_BIGENDIAN 1 # endif #else # ifndef WORDS_BIGENDIAN # undef WORDS_BIGENDIAN # endif #endif /* Define to 1 if on MINIX. */ #undef _MINIX /* Define to 2 if the system does not provide POSIX.1 features except with this defined. */ #undef _POSIX_1_SOURCE /* Define to 1 if you need to in order for `stat' and other things to work. */ #undef _POSIX_SOURCE /* Define to empty if `const' does not conform to ANSI C. */ #undef const /* in_addr_t */ #undef in_addr_t /* in_port_t */ #undef in_port_t /* Define to `__inline__' or `__inline' if that's what the C compiler calls it, or to nothing if 'inline' is not supported under any name. */ #ifndef __cplusplus #undef inline #endif /* Define to `short' if does not define. */ #undef int16_t /* Define to `int' if does not define. */ #undef int32_t /* Define to `long long' if does not define. */ #undef int64_t /* Define to `char' if does not define. */ #undef int8_t /* Define to `size_t' if does not define. */ #undef intptr_t /* Define to rpl_malloc if the replacement function should be used. */ #undef malloc /* Define to `int' if does not define. */ #undef pid_t /* Define to rpl_realloc if the replacement function should be used. */ #undef realloc /* Define to `unsigned int' if does not define. */ #undef size_t /* Define to 'int' if not defined */ #undef socklen_t /* Fallback member name for socket family in struct sockaddr_storage */ #undef ss_family /* Define to `int' if does not define. */ #undef ssize_t /* Define to `unsigned short' if does not define. */ #undef uint16_t /* Define to `unsigned int' if does not define. */ #undef uint32_t /* Define to `unsigned long long' if does not define. */ #undef uint64_t /* Define to `unsigned char' if does not define. */ #undef uint8_t /* Define as `fork' if `vfork' does not work. */ #undef vfork #include #include #include #include #ifndef LITTLE_ENDIAN #define LITTLE_ENDIAN 1234 #endif #ifndef BIG_ENDIAN #define BIG_ENDIAN 4321 #endif #ifndef BYTE_ORDER #ifdef WORDS_BIGENDIAN #define BYTE_ORDER BIG_ENDIAN #else #define BYTE_ORDER LITTLE_ENDIAN #endif /* WORDS_BIGENDIAN */ #endif /* BYTE_ORDER */ #if STDC_HEADERS #include #include #endif #ifdef HAVE_STDINT_H #include #endif #ifdef HAVE_SYS_SOCKET_H #include #endif #ifdef HAVE_NETINET_IN_H #include #endif #ifdef HAVE_ARPA_INET_H #include #endif #ifdef HAVE_WINSOCK2_H #include #endif #ifdef HAVE_WS2TCPIP_H #include #endif /* detect if we need to cast to unsigned int for FD_SET to avoid warnings */ #ifdef HAVE_WINSOCK2_H #define FD_SET_T (u_int) #else #define FD_SET_T #endif #ifdef __cplusplus extern "C" { #endif int ldns_b64_ntop(uint8_t const *src, size_t srclength, char *target, size_t targsize); /** * calculates the size needed to store the result of b64_ntop */ /*@unused@*/ static inline size_t ldns_b64_ntop_calculate_size(size_t srcsize) { return ((((srcsize + 2) / 3) * 4) + 1); } int ldns_b64_pton(char const *src, uint8_t *target, size_t targsize); /** * calculates the size needed to store the result of ldns_b64_pton */ /*@unused@*/ static inline size_t ldns_b64_pton_calculate_size(size_t srcsize) { return (((((srcsize + 3) / 4) * 3)) + 1); } /** * Given in dnssec_zone.c, also used in dnssec_sign.c:w */ int ldns_dname_compare_v(const void *a, const void *b); #ifndef HAVE_SLEEP /* use windows sleep, in millisecs, instead */ #define sleep(x) Sleep((x)*1000) #endif #ifndef HAVE_RANDOM #define srandom(x) srand(x) #define random(x) rand(x) #endif #ifndef HAVE_TIMEGM #include time_t timegm (struct tm *tm); #endif /* !TIMEGM */ #ifndef HAVE_GMTIME_R struct tm *gmtime_r(const time_t *timep, struct tm *result); #endif #ifndef HAVE_LOCALTIME_R struct tm *localtime_r(const time_t *timep, struct tm *result); #endif #ifndef HAVE_ISBLANK int isblank(int c); #endif /* !HAVE_ISBLANK */ #ifndef HAVE_ISASCII int isascii(int c); #endif /* !HAVE_ISASCII */ #ifndef HAVE_SNPRINTF #include int snprintf (char *str, size_t count, const char *fmt, ...); int vsnprintf (char *str, size_t count, const char *fmt, va_list arg); #endif /* HAVE_SNPRINTF */ #ifndef HAVE_INET_PTON int inet_pton(int af, const char* src, void* dst); #endif /* HAVE_INET_PTON */ #ifndef HAVE_INET_NTOP const char *inet_ntop(int af, const void *src, char *dst, size_t size); #endif #ifndef HAVE_INET_ATON int inet_aton(const char *cp, struct in_addr *addr); #endif #ifndef HAVE_MEMMOVE void *memmove(void *dest, const void *src, size_t n); #endif #ifndef HAVE_STRLCPY size_t strlcpy(char *dst, const char *src, size_t siz); #endif #ifdef __cplusplus } #endif #ifndef HAVE_GETADDRINFO #include "compat/fake-rfc2553.h" #endif #ifndef HAVE_STRTOUL #define strtoul (unsigned long)strtol #endif ldns-1.6.17/ldns/zone.h0000664000175100017510000001104512264060151014200 0ustar willemwillem/** * zone.h * * zone definitions * - what is it * - get_glue function * - search etc * * a Net::DNS like library for C * * (c) NLnet Labs, 2005-2006 * * See the file LICENSE for the license */ /** * \file * * Defines the ldns_zone structure and functions to manipulate it. */ #ifndef LDNS_ZONE_H #define LDNS_ZONE_H #include #include #include #include #ifdef __cplusplus extern "C" { #endif /** * DNS Zone * * A list of RR's with some * extra information which comes from the SOA RR * Note: nothing has been done to make this efficient (yet). */ struct ldns_struct_zone { /** the soa defines a zone */ ldns_rr *_soa; /* basicly a zone is a list of rr's */ ldns_rr_list *_rrs; /* we could change this to be a b-tree etc etc todo */ }; typedef struct ldns_struct_zone ldns_zone; /** * create a new ldns_zone structure * \return a pointer to a ldns_zone structure */ ldns_zone * ldns_zone_new(void); /** * Return the soa record of a zone * \param[in] z the zone to read from * \return the soa record in the zone */ ldns_rr * ldns_zone_soa(const ldns_zone *z); /** * Returns the number of resource records in the zone, NOT counting the SOA record * \param[in] z the zone to read from * \return the number of rr's in the zone */ size_t ldns_zone_rr_count(const ldns_zone *z); /** * Set the zone's soa record * \param[in] z the zone to put the new soa in * \param[in] soa the soa to set */ void ldns_zone_set_soa(ldns_zone *z, ldns_rr *soa); /** * Get a list of a zone's content. Note that the SOA * isn't included in this list. You need to get the * with ldns_zone_soa. * \param[in] z the zone to read from * \return the rrs from this zone */ ldns_rr_list * ldns_zone_rrs(const ldns_zone *z); /** * Set the zone's contents * \param[in] z the zone to put the new soa in * \param[in] rrlist the rrlist to use */ void ldns_zone_set_rrs(ldns_zone *z, ldns_rr_list *rrlist); /** * push an rrlist to a zone structure. This function use pointer * copying, so the rr_list structure inside z is modified! * \param[in] z the zone to add to * \param[in] list the list to add * \return a true on succes otherwise falsed */ bool ldns_zone_push_rr_list(ldns_zone *z, ldns_rr_list *list); /** * push an single rr to a zone structure. This function use pointer * copying, so the rr_list structure inside z is modified! * \param[in] z the zone to add to * \param[in] rr the rr to add * \return a true on succes otherwise falsed */ bool ldns_zone_push_rr(ldns_zone *z, ldns_rr *rr); /** * Retrieve all resource records from the zone that are glue * records. The resulting list does are pointer references * to the zone's data. * * Due to the current zone implementation (as a list of rr's), this * function is extremely slow. Another (probably better) way to do this * is to use an ldns_dnssec_zone structure and the * ldns_dnssec_mark_and_get_glue() function. * * \param[in] z the zone to look for glue * \return the rr_list with the glue */ ldns_rr_list *ldns_zone_glue_rr_list(const ldns_zone *z); /** * Create a new zone from a file * \param[out] z the new zone * \param[in] *fp the filepointer to use * \param[in] *origin the zones' origin * \param[in] ttl default ttl to use * \param[in] c default class to use (IN) * * \return ldns_status mesg with an error or LDNS_STATUS_OK */ ldns_status ldns_zone_new_frm_fp(ldns_zone **z, FILE *fp, ldns_rdf *origin, uint32_t ttl, ldns_rr_class c); /** * Create a new zone from a file, keep track of the line numbering * \param[out] z the new zone * \param[in] *fp the filepointer to use * \param[in] *origin the zones' origin * \param[in] ttl default ttl to use * \param[in] c default class to use (IN) * \param[out] line_nr used for error msg, to get to the line number * * \return ldns_status mesg with an error or LDNS_STATUS_OK */ ldns_status ldns_zone_new_frm_fp_l(ldns_zone **z, FILE *fp, ldns_rdf *origin, uint32_t ttl, ldns_rr_class c, int *line_nr); /** * Frees the allocated memory for the zone, and the rr_list structure in it * \param[in] zone the zone to free */ void ldns_zone_free(ldns_zone *zone); /** * Frees the allocated memory for the zone, the soa rr in it, * and the rr_list structure in it, including the rr's in that. etc. * \param[in] zone the zone to free */ void ldns_zone_deep_free(ldns_zone *zone); /** * Sort the rrs in a zone, with the current impl. this is slow * \param[in] zone the zone to sort */ void ldns_zone_sort(ldns_zone *zone); #ifdef __cplusplus } #endif #endif /* LDNS_ZONE_H */ ldns-1.6.17/ldns/net.h.in0000664000175100017510000001571012264060151014423 0ustar willemwillem/* * net.h * * DNS Resolver definitions * * a Net::DNS like library for C * * (c) NLnet Labs, 2005-2006 * * See the file LICENSE for the license */ #ifndef LDNS_NET_H #define LDNS_NET_H #include @include_sys_socket_h@ #ifdef __cplusplus extern "C" { #endif #define LDNS_DEFAULT_TIMEOUT_SEC 5 #define LDNS_DEFAULT_TIMEOUT_USEC 0 /** * \file * * Contains functions to send and receive packets over a network. */ /** * Sends a buffer to an ip using udp and return the respons as a ldns_pkt * \param[in] qbin the ldns_buffer to be send * \param[in] to the ip addr to send to * \param[in] tolen length of the ip addr * \param[in] timeout the timeout value for the network * \param[out] answersize size of the packet * \param[out] result packet with the answer * \return status */ ldns_status ldns_udp_send(uint8_t **result, ldns_buffer *qbin, const struct sockaddr_storage *to, socklen_t tolen, struct timeval timeout, size_t *answersize); /** * Send an udp query and don't wait for an answer but return * the socket * \param[in] qbin the ldns_buffer to be send * \param[in] to the ip addr to send to * \param[in] tolen length of the ip addr * \param[in] timeout *unused*, was the timeout value for the network * \return the socket used */ int ldns_udp_bgsend(ldns_buffer *qbin, const struct sockaddr_storage *to, socklen_t tolen, struct timeval timeout); /** * Send an tcp query and don't wait for an answer but return * the socket * \param[in] qbin the ldns_buffer to be send * \param[in] to the ip addr to send to * \param[in] tolen length of the ip addr * \param[in] timeout the timeout value for the connect attempt * \return the socket used */ int ldns_tcp_bgsend(ldns_buffer *qbin, const struct sockaddr_storage *to, socklen_t tolen, struct timeval timeout); /** * Sends a buffer to an ip using tcp and return the respons as a ldns_pkt * \param[in] qbin the ldns_buffer to be send * \param[in] qbin the ldns_buffer to be send * \param[in] to the ip addr to send to * \param[in] tolen length of the ip addr * \param[in] timeout the timeout value for the network * \param[out] answersize size of the packet * \param[out] result packet with the answer * \return status */ ldns_status ldns_tcp_send(uint8_t **result, ldns_buffer *qbin, const struct sockaddr_storage *to, socklen_t tolen, struct timeval timeout, size_t *answersize); /** * Sends ptk to the nameserver at the resolver object. Returns the data * as a ldns_pkt * * \param[out] pkt packet received from the nameserver * \param[in] r the resolver to use * \param[in] query_pkt the query to send * \return status */ ldns_status ldns_send(ldns_pkt **pkt, ldns_resolver *r, const ldns_pkt *query_pkt); /** * Sends and ldns_buffer (presumably containing a packet to the nameserver at the resolver object. Returns the data * as a ldns_pkt * * \param[out] pkt packet received from the nameserver * \param[in] r the resolver to use * \param[in] qb the buffer to send * \param[in] tsig_mac the tsig MAC to authenticate the response with (NULL to do no TSIG authentication) * \return status */ ldns_status ldns_send_buffer(ldns_pkt **pkt, ldns_resolver *r, ldns_buffer *qb, ldns_rdf *tsig_mac); /** * Create a tcp socket to the specified address * \param[in] to ip and family * \param[in] tolen length of to * \param[in] timeout timeout for the connect attempt * \return a socket descriptor */ int ldns_tcp_connect(const struct sockaddr_storage *to, socklen_t tolen, struct timeval timeout); /** * Create a udp socket to the specified address * \param[in] to ip and family * \param[in] timeout *unused*, was timeout for the socket * \return a socket descriptor */ int ldns_udp_connect(const struct sockaddr_storage *to, struct timeval timeout); /** * send a query via tcp to a server. Don't want for the answer * * \param[in] qbin the buffer to send * \param[in] sockfd the socket to use * \param[in] to which ip to send it * \param[in] tolen socketlen * \return number of bytes sent */ ssize_t ldns_tcp_send_query(ldns_buffer *qbin, int sockfd, const struct sockaddr_storage *to, socklen_t tolen); /** * send a query via udp to a server. Don;t want for the answer * * \param[in] qbin the buffer to send * \param[in] sockfd the socket to use * \param[in] to which ip to send it * \param[in] tolen socketlen * \return number of bytes sent */ ssize_t ldns_udp_send_query(ldns_buffer *qbin, int sockfd, const struct sockaddr_storage *to, socklen_t tolen); /** * Gives back a raw packet from the wire and reads the header data from the given * socket. Allocates the data (of size size) itself, so don't forget to free * * \param[in] sockfd the socket to read from * \param[out] size the number of bytes that are read * \param[in] timeout the time allowed between packets. * \return the data read */ uint8_t *ldns_tcp_read_wire_timeout(int sockfd, size_t *size, struct timeval timeout); /** * This routine may block. Use ldns_tcp_read_wire_timeout, it checks timeouts. * Gives back a raw packet from the wire and reads the header data from the given * socket. Allocates the data (of size size) itself, so don't forget to free * * \param[in] sockfd the socket to read from * \param[out] size the number of bytes that are read * \return the data read */ uint8_t *ldns_tcp_read_wire(int sockfd, size_t *size); /** * Gives back a raw packet from the wire and reads the header data from the given * socket. Allocates the data (of size size) itself, so don't forget to free * * \param[in] sockfd the socket to read from * \param[in] fr the address of the client (if applicable) * \param[in] *frlen the lenght of the client's addr (if applicable) * \param[out] size the number of bytes that are read * \return the data read */ uint8_t *ldns_udp_read_wire(int sockfd, size_t *size, struct sockaddr_storage *fr, socklen_t *frlen); /** * returns the native sockaddr representation from the rdf. * \param[in] rd the ldns_rdf to operate on * \param[in] port what port to use. 0 means; use default (53) * \param[out] size what is the size of the sockaddr_storage * \return struct sockaddr* the address in the format so other * functions can use it (sendto) */ struct sockaddr_storage * ldns_rdf2native_sockaddr_storage(const ldns_rdf *rd, uint16_t port, size_t *size); /** * returns an rdf with the sockaddr info. works for ip4 and ip6 * \param[in] sock the struct sockaddr_storage to convert * \param[in] port what port was used. When NULL this is not set * \return ldns_rdf* wth the address */ ldns_rdf * ldns_sockaddr_storage2rdf(struct sockaddr_storage *sock, uint16_t *port); /** * Prepares the resolver for an axfr query * The query is sent and the answers can be read with ldns_axfr_next * \param[in] resolver the resolver to use * \param[in] domain the domain to exfr * \param[in] c the class to use * \return ldns_status the status of the transfer */ ldns_status ldns_axfr_start(ldns_resolver *resolver, ldns_rdf *domain, ldns_rr_class c); #ifdef __cplusplus } #endif #endif /* LDNS_NET_H */ ldns-1.6.17/ldns/keys.h0000664000175100017510000004156412264060151014211 0ustar willemwillem/* * * keys.h * * priv key definitions * * a Net::DNS like library for C * * (c) NLnet Labs, 2005-2006 * * See the file LICENSE for the license */ /** * \file * * Addendum to \ref dnssec.h, this module contains key and algorithm definitions and functions. */ #ifndef LDNS_KEYS_H #define LDNS_KEYS_H #include #if LDNS_BUILD_CONFIG_HAVE_SSL #include #endif /* LDNS_BUILD_CONFIG_HAVE_SSL */ #include #include #ifdef __cplusplus extern "C" { #endif extern ldns_lookup_table ldns_signing_algorithms[]; #define LDNS_KEY_ZONE_KEY 0x0100 /* rfc 4034 */ #define LDNS_KEY_SEP_KEY 0x0001 /* rfc 4034 */ #define LDNS_KEY_REVOKE_KEY 0x0080 /* rfc 5011 */ /** * Algorithms used in dns */ enum ldns_enum_algorithm { LDNS_RSAMD5 = 1, /* RFC 4034,4035 */ LDNS_DH = 2, LDNS_DSA = 3, LDNS_ECC = 4, LDNS_RSASHA1 = 5, LDNS_DSA_NSEC3 = 6, LDNS_RSASHA1_NSEC3 = 7, LDNS_RSASHA256 = 8, /* RFC 5702 */ LDNS_RSASHA512 = 10, /* RFC 5702 */ LDNS_ECC_GOST = 12, /* RFC 5933 */ LDNS_ECDSAP256SHA256 = 13, /* RFC 6605 */ LDNS_ECDSAP384SHA384 = 14, /* RFC 6605 */ LDNS_INDIRECT = 252, LDNS_PRIVATEDNS = 253, LDNS_PRIVATEOID = 254 }; typedef enum ldns_enum_algorithm ldns_algorithm; /** * Hashing algorithms used in the DS record */ enum ldns_enum_hash { LDNS_SHA1 = 1, /* RFC 4034 */ LDNS_SHA256 = 2, /* RFC 4509 */ LDNS_HASH_GOST = 3, /* RFC 5933 */ LDNS_SHA384 = 4 /* RFC 6605 */ }; typedef enum ldns_enum_hash ldns_hash; /** * Algorithms used in dns for signing */ enum ldns_enum_signing_algorithm { LDNS_SIGN_RSAMD5 = LDNS_RSAMD5, LDNS_SIGN_RSASHA1 = LDNS_RSASHA1, LDNS_SIGN_DSA = LDNS_DSA, LDNS_SIGN_RSASHA1_NSEC3 = LDNS_RSASHA1_NSEC3, LDNS_SIGN_RSASHA256 = LDNS_RSASHA256, LDNS_SIGN_RSASHA512 = LDNS_RSASHA512, LDNS_SIGN_DSA_NSEC3 = LDNS_DSA_NSEC3, LDNS_SIGN_ECC_GOST = LDNS_ECC_GOST, LDNS_SIGN_ECDSAP256SHA256 = LDNS_ECDSAP256SHA256, LDNS_SIGN_ECDSAP384SHA384 = LDNS_ECDSAP384SHA384, LDNS_SIGN_HMACMD5 = 157, /* not official! This type is for TSIG, not DNSSEC */ LDNS_SIGN_HMACSHA1 = 158, /* not official! This type is for TSIG, not DNSSEC */ LDNS_SIGN_HMACSHA256 = 159 /* ditto */ }; typedef enum ldns_enum_signing_algorithm ldns_signing_algorithm; /** * General key structure, can contain all types of keys that * are used in DNSSEC. Mostly used to store private keys, since * public keys can also be stored in a \ref ldns_rr with type * \ref LDNS_RR_TYPE_DNSKEY. * * This structure can also store some variables that influence the * signatures generated by signing with this key, for instance the * inception date. */ struct ldns_struct_key { ldns_signing_algorithm _alg; /** Whether to use this key when signing */ bool _use; /** Storage pointers for the types of keys supported */ /* TODO remove unions? */ struct { #if LDNS_BUILD_CONFIG_HAVE_SSL #ifndef S_SPLINT_S /* The key can be an OpenSSL EVP Key */ EVP_PKEY *key; #endif #endif /* LDNS_BUILD_CONFIG_HAVE_SSL */ /** * The key can be an HMAC key */ struct { unsigned char *key; size_t size; } hmac; /** the key structure can also just point to some external * key data */ void *external_key; } _key; /** Depending on the key we can have extra data */ union { /** Some values that influence generated signatures */ struct { /** The TTL of the rrset that is currently signed */ uint32_t orig_ttl; /** The inception date of signatures made with this key. */ uint32_t inception; /** The expiration date of signatures made with this key. */ uint32_t expiration; /** The keytag of this key. */ uint16_t keytag; /** The dnssec key flags as specified in RFC4035, like ZSK and KSK */ uint16_t flags; } dnssec; } _extra; /** Owner name of the key */ ldns_rdf *_pubkey_owner; }; typedef struct ldns_struct_key ldns_key; /** * Same as rr_list, but now for keys */ struct ldns_struct_key_list { size_t _key_count; ldns_key **_keys; }; typedef struct ldns_struct_key_list ldns_key_list; /** * Creates a new empty key list * \return a new ldns_key_list structure pointer */ ldns_key_list *ldns_key_list_new(void); /** * Creates a new empty key structure * \return a new ldns_key * structure */ ldns_key *ldns_key_new(void); /** * Creates a new key based on the algorithm * * \param[in] a The algorithm to use * \param[in] size the number of bytes for the keysize * \return a new ldns_key structure with the key */ ldns_key *ldns_key_new_frm_algorithm(ldns_signing_algorithm a, uint16_t size); /** * Creates a new priv key based on the * contents of the file pointed by fp. * * The file should be in Private-key-format v1.x. * * \param[out] k the new ldns_key structure * \param[in] fp the file pointer to use * \return an error or LDNS_STATUS_OK */ ldns_status ldns_key_new_frm_fp(ldns_key **k, FILE *fp); /** * Creates a new private key based on the * contents of the file pointed by fp * * The file should be in Private-key-format v1.x. * * \param[out] k the new ldns_key structure * \param[in] fp the file pointer to use * \param[in] line_nr pointer to an integer containing the current line number (for debugging purposes) * \return an error or LDNS_STATUS_OK */ ldns_status ldns_key_new_frm_fp_l(ldns_key **k, FILE *fp, int *line_nr); #if LDNS_BUILD_CONFIG_HAVE_SSL /** * Read the key with the given id from the given engine and store it * in the given ldns_key structure. The algorithm type is set */ ldns_status ldns_key_new_frm_engine(ldns_key **key, ENGINE *e, char *key_id, ldns_algorithm); /** * frm_fp helper function. This function parses the * remainder of the (RSA) priv. key file generated from bind9 * \param[in] fp the file to parse * \return NULL on failure otherwise a RSA structure */ RSA *ldns_key_new_frm_fp_rsa(FILE *fp); #endif /* LDNS_BUILD_CONFIG_HAVE_SSL */ #if LDNS_BUILD_CONFIG_HAVE_SSL /** * frm_fp helper function. This function parses the * remainder of the (RSA) priv. key file generated from bind9 * \param[in] fp the file to parse * \param[in] line_nr pointer to an integer containing the current line number (for debugging purposes) * \return NULL on failure otherwise a RSA structure */ RSA *ldns_key_new_frm_fp_rsa_l(FILE *fp, int *line_nr); #endif /* LDNS_BUILD_CONFIG_HAVE_SSL */ #if LDNS_BUILD_CONFIG_HAVE_SSL /** * frm_fp helper function. This function parses the * remainder of the (DSA) priv. key file * \param[in] fp the file to parse * \return NULL on failure otherwise a RSA structure */ DSA *ldns_key_new_frm_fp_dsa(FILE *fp); #endif /* LDNS_BUILD_CONFIG_HAVE_SSL */ #if LDNS_BUILD_CONFIG_HAVE_SSL /** * frm_fp helper function. This function parses the * remainder of the (DSA) priv. key file * \param[in] fp the file to parse * \param[in] line_nr pointer to an integer containing the current line number (for debugging purposes) * \return NULL on failure otherwise a RSA structure */ DSA *ldns_key_new_frm_fp_dsa_l(FILE *fp, int *line_nr); #endif /* LDNS_BUILD_CONFIG_HAVE_SSL */ #if LDNS_BUILD_CONFIG_HAVE_SSL /** * frm_fp helper function. This function parses the * remainder of the (HMAC-MD5) key file * This function allocated a buffer that needs to be freed * \param[in] fp the file to parse * \param[out] hmac_size the number of bits in the resulting buffer * \return NULL on failure otherwise a newly allocated char buffer */ unsigned char *ldns_key_new_frm_fp_hmac(FILE *fp, size_t *hmac_size); #endif #if LDNS_BUILD_CONFIG_HAVE_SSL /** * frm_fp helper function. This function parses the * remainder of the (HMAC-MD5) key file * This function allocated a buffer that needs to be freed * \param[in] fp the file to parse * \param[in] line_nr pointer to an integer containing the current line number (for error reporting purposes) * \param[out] hmac_size the number of bits in the resulting buffer * \return NULL on failure otherwise a newly allocated char buffer */ unsigned char *ldns_key_new_frm_fp_hmac_l(FILE *fp, int *line_nr, size_t *hmac_size); #endif /* LDNS_BUILD_CONFIG_HAVE_SSL */ /* acces write functions */ /** * Set the key's algorithm * \param[in] k the key * \param[in] l the algorithm */ void ldns_key_set_algorithm(ldns_key *k, ldns_signing_algorithm l); #if LDNS_BUILD_CONFIG_HAVE_SSL /** * Set the key's evp key * \param[in] k the key * \param[in] e the evp key */ void ldns_key_set_evp_key(ldns_key *k, EVP_PKEY *e); /** * Set the key's rsa data. * The rsa data should be freed by the user. * \param[in] k the key * \param[in] r the rsa data */ void ldns_key_set_rsa_key(ldns_key *k, RSA *r); /** * Set the key's dsa data * The dsa data should be freed by the user. * \param[in] k the key * \param[in] d the dsa data */ void ldns_key_set_dsa_key(ldns_key *k, DSA *d); /** * Assign the key's rsa data * The rsa data will be freed automatically when the key is freed. * \param[in] k the key * \param[in] r the rsa data */ void ldns_key_assign_rsa_key(ldns_key *k, RSA *r); /** * Assign the key's dsa data * The dsa data will be freed automatically when the key is freed. * \param[in] k the key * \param[in] d the dsa data */ void ldns_key_assign_dsa_key(ldns_key *k, DSA *d); /** * Get the PKEY id for GOST, loads GOST into openssl as a side effect. * Only available if GOST is compiled into the library and openssl. * \return the gost id for EVP_CTX creation. */ int ldns_key_EVP_load_gost_id(void); /** Release the engine reference held for the GOST engine. */ void ldns_key_EVP_unload_gost(void); #endif /* LDNS_BUILD_CONFIG_HAVE_SSL */ /** * Set the key's hmac data * \param[in] k the key * \param[in] hmac the raw key data */ void ldns_key_set_hmac_key(ldns_key *k, unsigned char *hmac); /** * Set the key id data. This is used if the key points to * some externally stored key data * * Only the pointer is set, the data there is not copied, * and must be freed manually; ldns_key_deep_free() does * *not* free this data * \param[in] key the key * \param[in] external_key key id data */ void ldns_key_set_external_key(ldns_key *key, void *external_key); /** * Set the key's hmac size * \param[in] k the key * \param[in] hmac_size the size of the hmac data */ void ldns_key_set_hmac_size(ldns_key *k, size_t hmac_size); /** * Set the key's original ttl * \param[in] k the key * \param[in] t the ttl */ void ldns_key_set_origttl(ldns_key *k, uint32_t t); /** * Set the key's inception date (seconds after epoch) * \param[in] k the key * \param[in] i the inception */ void ldns_key_set_inception(ldns_key *k, uint32_t i); /** * Set the key's expiration date (seconds after epoch) * \param[in] k the key * \param[in] e the expiration */ void ldns_key_set_expiration(ldns_key *k, uint32_t e); /** * Set the key's pubkey owner * \param[in] k the key * \param[in] r the owner */ void ldns_key_set_pubkey_owner(ldns_key *k, ldns_rdf *r); /** * Set the key's key tag * \param[in] k the key * \param[in] tag the keytag */ void ldns_key_set_keytag(ldns_key *k, uint16_t tag); /** * Set the key's flags * \param[in] k the key * \param[in] flags the flags */ void ldns_key_set_flags(ldns_key *k, uint16_t flags); /** * Set the keylist's key count to count * \param[in] key the key * \param[in] count the cuont */ void ldns_key_list_set_key_count(ldns_key_list *key, size_t count); /** * pushes a key to a keylist * \param[in] key_list the key_list to push to * \param[in] key the key to push * \return false on error, otherwise true */ bool ldns_key_list_push_key(ldns_key_list *key_list, ldns_key *key); /** * returns the number of keys in the key list * \param[in] key_list the key_list * \return the numbers of keys in the list */ size_t ldns_key_list_key_count(const ldns_key_list *key_list); /** * returns a pointer to the key in the list at the given position * \param[in] key the key * \param[in] nr the position in the list * \return the key */ ldns_key *ldns_key_list_key(const ldns_key_list *key, size_t nr); #if LDNS_BUILD_CONFIG_HAVE_SSL /** * returns the (openssl) RSA struct contained in the key * \param[in] k the key to look in * \return the RSA * structure in the key */ RSA *ldns_key_rsa_key(const ldns_key *k); /** * returns the (openssl) EVP struct contained in the key * \param[in] k the key to look in * \return the RSA * structure in the key */ EVP_PKEY *ldns_key_evp_key(const ldns_key *k); #endif /* LDNS_BUILD_CONFIG_HAVE_SSL */ /** * returns the (openssl) DSA struct contained in the key */ #if LDNS_BUILD_CONFIG_HAVE_SSL DSA *ldns_key_dsa_key(const ldns_key *k); #endif /* LDNS_BUILD_CONFIG_HAVE_SSL */ /** * return the signing alg of the key * \param[in] k the key * \return the algorithm */ ldns_signing_algorithm ldns_key_algorithm(const ldns_key *k); /** * set the use flag * \param[in] k the key * \param[in] v the boolean value to set the _use field to */ void ldns_key_set_use(ldns_key *k, bool v); /** * return the use flag * \param[in] k the key * \return the boolean value of the _use field */ bool ldns_key_use(const ldns_key *k); /** * return the hmac key data * \param[in] k the key * \return the hmac key data */ unsigned char *ldns_key_hmac_key(const ldns_key *k); /** * return the key id key data * \param[in] k the key * \return the key id data */ void *ldns_key_external_key(const ldns_key *k); /** * return the hmac key size * \param[in] k the key * \return the hmac key size */ size_t ldns_key_hmac_size(const ldns_key *k); /** * return the original ttl of the key * \param[in] k the key * \return the original ttl */ uint32_t ldns_key_origttl(const ldns_key *k); /** * return the key's inception date * \param[in] k the key * \return the inception date */ uint32_t ldns_key_inception(const ldns_key *k); /** * return the key's expiration date * \param[in] k the key * \return the experiration date */ uint32_t ldns_key_expiration(const ldns_key *k); /** * return the keytag * \param[in] k the key * \return the keytag */ uint16_t ldns_key_keytag(const ldns_key *k); /** * return the public key's owner * \param[in] k the key * \return the owner */ ldns_rdf *ldns_key_pubkey_owner(const ldns_key *k); /** * Set the 'use' flag for all keys in the list * \param[in] keys The key_list * \param[in] v The value to set the use flags to */ void ldns_key_list_set_use(ldns_key_list *keys, bool v); /** * return the flag of the key * \param[in] k the key * \return the flag */ uint16_t ldns_key_flags(const ldns_key *k); /** * pops the last rr from a keylist * \param[in] key_list the rr_list to pop from * \return NULL if nothing to pop. Otherwise the popped RR */ ldns_key *ldns_key_list_pop_key(ldns_key_list *key_list); /** * converts a ldns_key to a public key rr * If the key data exists at an external point, the corresponding * rdata field must still be added with ldns_rr_rdf_push() to the * result rr of this function * * \param[in] k the ldns_key to convert * \return ldns_rr representation of the key */ ldns_rr *ldns_key2rr(const ldns_key *k); /** * print a private key to the file ouput * * \param[in] output the FILE descriptor where to print to * \param[in] k the ldns_key to print */ void ldns_key_print(FILE *output, const ldns_key *k); /** * frees a key structure, but not its internal data structures * * \param[in] key the key object to free */ void ldns_key_free(ldns_key *key); /** * frees a key structure and all its internal data structures, except * the data set by ldns_key_set_external_key() * * \param[in] key the key object to free */ void ldns_key_deep_free(ldns_key *key); /** * Frees a key list structure * \param[in] key_list the key list object to free */ void ldns_key_list_free(ldns_key_list *key_list); /** * Instantiates a DNSKEY or DS RR from file. * \param[in] filename the file to read the record from * \return the corresponding RR, or NULL if the parsing failed */ ldns_rr * ldns_read_anchor_file(const char *filename); /** * Returns the 'default base name' for key files; * IE. K\+\+\ * (without the .key or .private) * The memory for this is allocated by this function, * and should be freed by the caller * * \param[in] key the key to get the file name from * \returns A string containing the file base name */ char *ldns_key_get_file_base_name(ldns_key *key); /** * See if a key algorithm is supported * \param[in] algo the signing algorithm number. * \returns true if supported. */ int ldns_key_algo_supported(int algo); /** * Get signing algorithm by name. Comparison is case insensitive. * \param[in] name string with the name. * \returns 0 on parse failure or the algorithm number. */ ldns_signing_algorithm ldns_get_signing_algorithm_by_name(const char* name); #ifdef __cplusplus } #endif #endif /* LDNS_KEYS_H */ ldns-1.6.17/ldns/buffer.h0000664000175100017510000004041112264060151014475 0ustar willemwillem/* * buffer.h -- generic memory buffer. * * Copyright (c) 2005-2008, NLnet Labs. All rights reserved. * * See LICENSE for the license. * * * The buffer module implements a generic buffer. The API is based on * the java.nio.Buffer interface. */ #ifndef LDNS_BUFFER_H #define LDNS_BUFFER_H #include #include #include #include #include #include "ldns/util.h" #ifdef __cplusplus extern "C" { #endif /** * number of initial bytes in buffer of * which we cannot tell the size before hand */ #define LDNS_MIN_BUFLEN 512 /** * \file buffer.h * * This file contains the definition of ldns_buffer, and functions to manipulate those. */ /** * implementation of buffers to ease operations * * ldns_buffers can contain arbitrary information, per octet. You can write * to the current end of a buffer, read from the current position, and * access any data within it. * * Example use of buffers is in the source code of \ref host2str.c */ struct ldns_struct_buffer { /** The current position used for reading/writing */ size_t _position; /** The read/write limit */ size_t _limit; /** The amount of data the buffer can contain */ size_t _capacity; /** The data contained in the buffer */ uint8_t *_data; /** If the buffer is fixed it cannot be resized */ unsigned _fixed : 1; /** The current state of the buffer. If writing to the buffer fails * for any reason, this value is changed. This way, you can perform * multiple writes in sequence and check for success afterwards. */ ldns_status _status; }; typedef struct ldns_struct_buffer ldns_buffer; #ifdef NDEBUG INLINE void ldns_buffer_invariant(ldns_buffer *ATTR_UNUSED(buffer)) { } #else INLINE void ldns_buffer_invariant(ldns_buffer *buffer) { assert(buffer != NULL); assert(buffer->_position <= buffer->_limit); assert(buffer->_limit <= buffer->_capacity); assert(buffer->_data != NULL); } #endif /** * creates a new buffer with the specified capacity. * * \param[in] capacity the size (in bytes) to allocate for the buffer * \return the created buffer */ ldns_buffer *ldns_buffer_new(size_t capacity); /** * creates a buffer with the specified data. The data IS copied * and MEMORY allocations are done. The buffer is not fixed and can * be resized using buffer_reserve(). * * \param[in] buffer pointer to the buffer to put the data in * \param[in] data the data to encapsulate in the buffer * \param[in] size the size of the data */ void ldns_buffer_new_frm_data(ldns_buffer *buffer, void *data, size_t size); /** * clears the buffer and make it ready for writing. The buffer's limit * is set to the capacity and the position is set to 0. * \param[in] buffer the buffer to clear */ INLINE void ldns_buffer_clear(ldns_buffer *buffer) { ldns_buffer_invariant(buffer); /* reset status here? */ buffer->_position = 0; buffer->_limit = buffer->_capacity; } /** * makes the buffer ready for reading the data that has been written to * the buffer. The buffer's limit is set to the current position and * the position is set to 0. * * \param[in] buffer the buffer to flip * \return void */ INLINE void ldns_buffer_flip(ldns_buffer *buffer) { ldns_buffer_invariant(buffer); buffer->_limit = buffer->_position; buffer->_position = 0; } /** * make the buffer ready for re-reading the data. The buffer's * position is reset to 0. * \param[in] buffer the buffer to rewind */ INLINE void ldns_buffer_rewind(ldns_buffer *buffer) { ldns_buffer_invariant(buffer); buffer->_position = 0; } /** * returns the current position in the buffer (as a number of bytes) * \param[in] buffer the buffer * \return the current position */ INLINE size_t ldns_buffer_position(ldns_buffer *buffer) { return buffer->_position; } /** * sets the buffer's position to MARK. The position must be less than * or equal to the buffer's limit. * \param[in] buffer the buffer * \param[in] mark the mark to use */ INLINE void ldns_buffer_set_position(ldns_buffer *buffer, size_t mark) { assert(mark <= buffer->_limit); buffer->_position = mark; } /** * changes the buffer's position by COUNT bytes. The position must not * be moved behind the buffer's limit or before the beginning of the * buffer. * \param[in] buffer the buffer * \param[in] count the count to use */ INLINE void ldns_buffer_skip(ldns_buffer *buffer, ssize_t count) { assert(buffer->_position + count <= buffer->_limit); buffer->_position += count; } /** * returns the maximum size of the buffer * \param[in] buffer * \return the size */ INLINE size_t ldns_buffer_limit(ldns_buffer *buffer) { return buffer->_limit; } /** * changes the buffer's limit. If the buffer's position is greater * than the new limit the position is set to the limit. * \param[in] buffer the buffer * \param[in] limit the new limit */ INLINE void ldns_buffer_set_limit(ldns_buffer *buffer, size_t limit) { assert(limit <= buffer->_capacity); buffer->_limit = limit; if (buffer->_position > buffer->_limit) buffer->_position = buffer->_limit; } /** * returns the number of bytes the buffer can hold. * \param[in] buffer the buffer * \return the number of bytes */ INLINE size_t ldns_buffer_capacity(ldns_buffer *buffer) { return buffer->_capacity; } /** * changes the buffer's capacity. The data is reallocated so any * pointers to the data may become invalid. The buffer's limit is set * to the buffer's new capacity. * \param[in] buffer the buffer * \param[in] capacity the capacity to use * \return whether this failed or succeeded */ bool ldns_buffer_set_capacity(ldns_buffer *buffer, size_t capacity); /** * ensures BUFFER can contain at least AMOUNT more bytes. The buffer's * capacity is increased if necessary using buffer_set_capacity(). * * The buffer's limit is always set to the (possibly increased) * capacity. * \param[in] buffer the buffer * \param[in] amount amount to use * \return whether this failed or succeeded */ bool ldns_buffer_reserve(ldns_buffer *buffer, size_t amount); /** * returns a pointer to the data at the indicated position. * \param[in] buffer the buffer * \param[in] at position * \return the pointer to the data */ INLINE uint8_t * ldns_buffer_at(const ldns_buffer *buffer, size_t at) { assert(at <= buffer->_limit); return buffer->_data + at; } /** * returns a pointer to the beginning of the buffer (the data at * position 0). * \param[in] buffer the buffer * \return the pointer */ INLINE uint8_t * ldns_buffer_begin(const ldns_buffer *buffer) { return ldns_buffer_at(buffer, 0); } /** * returns a pointer to the end of the buffer (the data at the buffer's * limit). * \param[in] buffer the buffer * \return the pointer */ INLINE uint8_t * ldns_buffer_end(ldns_buffer *buffer) { return ldns_buffer_at(buffer, buffer->_limit); } /** * returns a pointer to the data at the buffer's current position. * \param[in] buffer the buffer * \return the pointer */ INLINE uint8_t * ldns_buffer_current(ldns_buffer *buffer) { return ldns_buffer_at(buffer, buffer->_position); } /** * returns the number of bytes remaining between the indicated position and * the limit. * \param[in] buffer the buffer * \param[in] at indicated position * \return number of bytes */ INLINE size_t ldns_buffer_remaining_at(ldns_buffer *buffer, size_t at) { ldns_buffer_invariant(buffer); assert(at <= buffer->_limit); return buffer->_limit - at; } /** * returns the number of bytes remaining between the buffer's position and * limit. * \param[in] buffer the buffer * \return the number of bytes */ INLINE size_t ldns_buffer_remaining(ldns_buffer *buffer) { return ldns_buffer_remaining_at(buffer, buffer->_position); } /** * checks if the buffer has at least COUNT more bytes available. * Before reading or writing the caller needs to ensure enough space * is available! * \param[in] buffer the buffer * \param[in] at indicated position * \param[in] count how much is available * \return true or false (as int?) */ INLINE int ldns_buffer_available_at(ldns_buffer *buffer, size_t at, size_t count) { return count <= ldns_buffer_remaining_at(buffer, at); } /** * checks if the buffer has count bytes available at the current position * \param[in] buffer the buffer * \param[in] count how much is available * \return true or false (as int?) */ INLINE int ldns_buffer_available(ldns_buffer *buffer, size_t count) { return ldns_buffer_available_at(buffer, buffer->_position, count); } /** * writes the given data to the buffer at the specified position * \param[in] buffer the buffer * \param[in] at the position (in number of bytes) to write the data at * \param[in] data pointer to the data to write to the buffer * \param[in] count the number of bytes of data to write */ INLINE void ldns_buffer_write_at(ldns_buffer *buffer, size_t at, const void *data, size_t count) { assert(ldns_buffer_available_at(buffer, at, count)); memcpy(buffer->_data + at, data, count); } /** * writes count bytes of data to the current position of the buffer * \param[in] buffer the buffer * \param[in] data the data to write * \param[in] count the lenght of the data to write */ INLINE void ldns_buffer_write(ldns_buffer *buffer, const void *data, size_t count) { ldns_buffer_write_at(buffer, buffer->_position, data, count); buffer->_position += count; } /** * copies the given (null-delimited) string to the specified position at the buffer * \param[in] buffer the buffer * \param[in] at the position in the buffer * \param[in] str the string to write */ INLINE void ldns_buffer_write_string_at(ldns_buffer *buffer, size_t at, const char *str) { ldns_buffer_write_at(buffer, at, str, strlen(str)); } /** * copies the given (null-delimited) string to the current position at the buffer * \param[in] buffer the buffer * \param[in] str the string to write */ INLINE void ldns_buffer_write_string(ldns_buffer *buffer, const char *str) { ldns_buffer_write(buffer, str, strlen(str)); } /** * writes the given byte of data at the given position in the buffer * \param[in] buffer the buffer * \param[in] at the position in the buffer * \param[in] data the 8 bits to write */ INLINE void ldns_buffer_write_u8_at(ldns_buffer *buffer, size_t at, uint8_t data) { assert(ldns_buffer_available_at(buffer, at, sizeof(data))); buffer->_data[at] = data; } /** * writes the given byte of data at the current position in the buffer * \param[in] buffer the buffer * \param[in] data the 8 bits to write */ INLINE void ldns_buffer_write_u8(ldns_buffer *buffer, uint8_t data) { ldns_buffer_write_u8_at(buffer, buffer->_position, data); buffer->_position += sizeof(data); } /** * writes the given 2 byte integer at the given position in the buffer * \param[in] buffer the buffer * \param[in] at the position in the buffer * \param[in] data the 16 bits to write */ INLINE void ldns_buffer_write_u16_at(ldns_buffer *buffer, size_t at, uint16_t data) { assert(ldns_buffer_available_at(buffer, at, sizeof(data))); ldns_write_uint16(buffer->_data + at, data); } /** * writes the given 2 byte integer at the current position in the buffer * \param[in] buffer the buffer * \param[in] data the 16 bits to write */ INLINE void ldns_buffer_write_u16(ldns_buffer *buffer, uint16_t data) { ldns_buffer_write_u16_at(buffer, buffer->_position, data); buffer->_position += sizeof(data); } /** * writes the given 4 byte integer at the given position in the buffer * \param[in] buffer the buffer * \param[in] at the position in the buffer * \param[in] data the 32 bits to write */ INLINE void ldns_buffer_write_u32_at(ldns_buffer *buffer, size_t at, uint32_t data) { assert(ldns_buffer_available_at(buffer, at, sizeof(data))); ldns_write_uint32(buffer->_data + at, data); } /** * writes the given 4 byte integer at the current position in the buffer * \param[in] buffer the buffer * \param[in] data the 32 bits to write */ INLINE void ldns_buffer_write_u32(ldns_buffer *buffer, uint32_t data) { ldns_buffer_write_u32_at(buffer, buffer->_position, data); buffer->_position += sizeof(data); } /** * copies count bytes of data at the given position to the given data-array * \param[in] buffer the buffer * \param[in] at the position in the buffer to start * \param[out] data buffer to copy to * \param[in] count the length of the data to copy */ INLINE void ldns_buffer_read_at(ldns_buffer *buffer, size_t at, void *data, size_t count) { assert(ldns_buffer_available_at(buffer, at, count)); memcpy(data, buffer->_data + at, count); } /** * copies count bytes of data at the current position to the given data-array * \param[in] buffer the buffer * \param[out] data buffer to copy to * \param[in] count the length of the data to copy */ INLINE void ldns_buffer_read(ldns_buffer *buffer, void *data, size_t count) { ldns_buffer_read_at(buffer, buffer->_position, data, count); buffer->_position += count; } /** * returns the byte value at the given position in the buffer * \param[in] buffer the buffer * \param[in] at the position in the buffer * \return 1 byte integer */ INLINE uint8_t ldns_buffer_read_u8_at(ldns_buffer *buffer, size_t at) { assert(ldns_buffer_available_at(buffer, at, sizeof(uint8_t))); return buffer->_data[at]; } /** * returns the byte value at the current position in the buffer * \param[in] buffer the buffer * \return 1 byte integer */ INLINE uint8_t ldns_buffer_read_u8(ldns_buffer *buffer) { uint8_t result = ldns_buffer_read_u8_at(buffer, buffer->_position); buffer->_position += sizeof(uint8_t); return result; } /** * returns the 2-byte integer value at the given position in the buffer * \param[in] buffer the buffer * \param[in] at position in the buffer * \return 2 byte integer */ INLINE uint16_t ldns_buffer_read_u16_at(ldns_buffer *buffer, size_t at) { assert(ldns_buffer_available_at(buffer, at, sizeof(uint16_t))); return ldns_read_uint16(buffer->_data + at); } /** * returns the 2-byte integer value at the current position in the buffer * \param[in] buffer the buffer * \return 2 byte integer */ INLINE uint16_t ldns_buffer_read_u16(ldns_buffer *buffer) { uint16_t result = ldns_buffer_read_u16_at(buffer, buffer->_position); buffer->_position += sizeof(uint16_t); return result; } /** * returns the 4-byte integer value at the given position in the buffer * \param[in] buffer the buffer * \param[in] at position in the buffer * \return 4 byte integer */ INLINE uint32_t ldns_buffer_read_u32_at(ldns_buffer *buffer, size_t at) { assert(ldns_buffer_available_at(buffer, at, sizeof(uint32_t))); return ldns_read_uint32(buffer->_data + at); } /** * returns the 4-byte integer value at the current position in the buffer * \param[in] buffer the buffer * \return 4 byte integer */ INLINE uint32_t ldns_buffer_read_u32(ldns_buffer *buffer) { uint32_t result = ldns_buffer_read_u32_at(buffer, buffer->_position); buffer->_position += sizeof(uint32_t); return result; } /** * returns the status of the buffer * \param[in] buffer * \return the status */ INLINE ldns_status ldns_buffer_status(ldns_buffer *buffer) { return buffer->_status; } /** * returns true if the status of the buffer is LDNS_STATUS_OK, false otherwise * \param[in] buffer the buffer * \return true or false */ INLINE bool ldns_buffer_status_ok(ldns_buffer *buffer) { if (buffer) { return ldns_buffer_status(buffer) == LDNS_STATUS_OK; } else { return false; } } /** * prints to the buffer, increasing the capacity if required using * buffer_reserve(). The buffer's position is set to the terminating '\\0' * Returns the number of characters written (not including the * terminating '\\0') or -1 on failure. */ int ldns_buffer_printf(ldns_buffer *buffer, const char *format, ...); /* ATTR_FORMAT(printf, 2, 3);*/ /** * frees the buffer. * \param[in] *buffer the buffer to be freed * \return void */ void ldns_buffer_free(ldns_buffer *buffer); /** * Makes the buffer fixed and returns a pointer to the data. The * caller is responsible for free'ing the result. * \param[in] *buffer the buffer to be exported * \return void */ void *ldns_buffer_export(ldns_buffer *buffer); /** * Copy contents of the from buffer to the result buffer and then flips * the result buffer. Data will be silently truncated if the result buffer is * too small. * \param[out] *result resulting buffer which is copied to. * \param[in] *from what to copy to result. */ void ldns_buffer_copy(ldns_buffer* result, ldns_buffer* from); #ifdef __cplusplus } #endif #endif /* LDNS_BUFFER_H */ ldns-1.6.17/ldns/util.h.in0000664000175100017510000002465012264060151014615 0ustar willemwillem/* * util.h * * helper function header file * * a Net::DNS like library for C * * (c) NLnet Labs, 2004 * * See the file LICENSE for the license */ #ifndef _UTIL_H #define _UTIL_H @include_inttypes_h@ @include_systypes_h@ @include_unistd_h@ #include #include #include #ifdef __cplusplus extern "C" { #endif #define dprintf(X,Y) fprintf(stderr, (X), (Y)) /* #define dprintf(X, Y) */ #define LDNS_VERSION "@PACKAGE_VERSION@" #define LDNS_REVISION ((@LDNS_VERSION_MAJOR@<<16)|(@LDNS_VERSION_MINOR@<<8)|(@LDNS_VERSION_MICRO@)) /** * splint static inline workaround */ #ifdef S_SPLINT_S # define INLINE #else # ifdef SWIG # define INLINE static # else # define INLINE static inline # endif #endif /** * Memory management macros */ #define LDNS_MALLOC(type) LDNS_XMALLOC(type, 1) #define LDNS_XMALLOC(type, count) ((type *) malloc((count) * sizeof(type))) #define LDNS_CALLOC(type, count) ((type *) calloc((count), sizeof(type))) #define LDNS_REALLOC(ptr, type) LDNS_XREALLOC((ptr), type, 1) #define LDNS_XREALLOC(ptr, type, count) \ ((type *) realloc((ptr), (count) * sizeof(type))) #define LDNS_FREE(ptr) \ do { free((ptr)); (ptr) = NULL; } while (0) #define LDNS_DEP printf("DEPRECATED FUNCTION!\n"); /* * Copy data allowing for unaligned accesses in network byte order * (big endian). */ INLINE uint16_t ldns_read_uint16(const void *src) { #ifdef ALLOW_UNALIGNED_ACCESSES return ntohs(*(uint16_t *) src); #else uint8_t *p = (uint8_t *) src; return ((uint16_t) p[0] << 8) | (uint16_t) p[1]; #endif } INLINE uint32_t ldns_read_uint32(const void *src) { #ifdef ALLOW_UNALIGNED_ACCESSES return ntohl(*(uint32_t *) src); #else uint8_t *p = (uint8_t *) src; return ( ((uint32_t) p[0] << 24) | ((uint32_t) p[1] << 16) | ((uint32_t) p[2] << 8) | (uint32_t) p[3]); #endif } /* * Copy data allowing for unaligned accesses in network byte order * (big endian). */ INLINE void ldns_write_uint16(void *dst, uint16_t data) { #ifdef ALLOW_UNALIGNED_ACCESSES * (uint16_t *) dst = htons(data); #else uint8_t *p = (uint8_t *) dst; p[0] = (uint8_t) ((data >> 8) & 0xff); p[1] = (uint8_t) (data & 0xff); #endif } INLINE void ldns_write_uint32(void *dst, uint32_t data) { #ifdef ALLOW_UNALIGNED_ACCESSES * (uint32_t *) dst = htonl(data); #else uint8_t *p = (uint8_t *) dst; p[0] = (uint8_t) ((data >> 24) & 0xff); p[1] = (uint8_t) ((data >> 16) & 0xff); p[2] = (uint8_t) ((data >> 8) & 0xff); p[3] = (uint8_t) (data & 0xff); #endif } /* warning. */ INLINE void ldns_write_uint64_as_uint48(void *dst, uint64_t data) { uint8_t *p = (uint8_t *) dst; p[0] = (uint8_t) ((data >> 40) & 0xff); p[1] = (uint8_t) ((data >> 32) & 0xff); p[2] = (uint8_t) ((data >> 24) & 0xff); p[3] = (uint8_t) ((data >> 16) & 0xff); p[4] = (uint8_t) ((data >> 8) & 0xff); p[5] = (uint8_t) (data & 0xff); } /** * Structure to do a Schwartzian-like transformation, for instance when * sorting. If you need a transformation on the objects that are sorted, * you can sue this to store the transformed values, so you do not * need to do the transformation again for each comparison */ struct ldns_schwartzian_compare_struct { void *original_object; void *transformed_object; }; /** A general purpose lookup table * * Lookup tables are arrays of (id, name) pairs, * So you can for instance lookup the RCODE 3, which is "NXDOMAIN", * and vice versa. The lookup tables themselves are defined wherever needed, * for instance in \ref host2str.c */ struct ldns_struct_lookup_table { int id; const char *name; }; typedef struct ldns_struct_lookup_table ldns_lookup_table; /** * Looks up the table entry by name, returns NULL if not found. * \param[in] table the lookup table to search in * \param[in] name what to search for * \return the item found */ ldns_lookup_table *ldns_lookup_by_name(ldns_lookup_table table[], const char *name); /** * Looks up the table entry by id, returns NULL if not found. * \param[in] table the lookup table to search in * \param[in] id what to search for * \return the item found */ ldns_lookup_table *ldns_lookup_by_id(ldns_lookup_table table[], int id); /** * Returns the value of the specified bit * The bits are counted from left to right, so bit #0 is the * left most bit. * \param[in] bits array holding the bits * \param[in] index to the wanted bit * \return */ int ldns_get_bit(uint8_t bits[], size_t index); /** * Returns the value of the specified bit * The bits are counted from right to left, so bit #0 is the * right most bit. * \param[in] bits array holding the bits * \param[in] index to the wanted bit * \return 1 or 0 depending no the bit state */ int ldns_get_bit_r(uint8_t bits[], size_t index); /** * sets the specified bit in the specified byte to * 1 if value is true, 0 if false * The bits are counted from right to left, so bit #0 is the * right most bit. * \param[in] byte the bit to set the bit in * \param[in] bit_nr the bit to set (0 <= n <= 7) * \param[in] value whether to set the bit to 1 or 0 * \return 1 or 0 depending no the bit state */ void ldns_set_bit(uint8_t *byte, int bit_nr, bool value); /** * Returns the value of a to the power of b * (or 1 of b < 1) */ /*@unused@*/ INLINE long ldns_power(long a, long b) { long result = 1; while (b > 0) { if (b & 1) { result *= a; if (b == 1) { return result; } } a *= a; b /= 2; } return result; } /** * Returns the int value of the given (hex) digit * \param[in] ch the hex char to convert * \return the converted decimal value */ int ldns_hexdigit_to_int(char ch); /** * Returns the char (hex) representation of the given int * \param[in] ch the int to convert * \return the converted hex char */ char ldns_int_to_hexdigit(int ch); /** * Converts a hex string to binary data * * \param[out] data The binary result is placed here. * At least strlen(str)/2 bytes should be allocated * \param[in] str The hex string to convert. * This string should not contain spaces * \return The number of bytes of converted data, or -1 if one of the arguments * is NULL, or -2 if the string length is not an even number */ int ldns_hexstring_to_data(uint8_t *data, const char *str); /** * Show the internal library version * \return a string with the version in it */ const char * ldns_version(void); /** * Convert TM to seconds since epoch (midnight, January 1st, 1970). * Like timegm(3), which is not always available. * \param[in] tm a struct tm* with the date * \return the seconds since epoch */ time_t ldns_mktime_from_utc(const struct tm *tm); time_t mktime_from_utc(const struct tm *tm); /** * The function interprets time as the number of seconds since epoch * with respect to now using serial arithmitics (rfc1982). * That number of seconds is then converted to broken-out time information. * This is especially usefull when converting the inception and expiration * fields of RRSIG records. * * \param[in] time number of seconds since epoch (midnight, January 1st, 1970) * to be intepreted as a serial arithmitics number relative to now. * \param[in] now number of seconds since epoch (midnight, January 1st, 1970) * to which the time value is compared to determine the final value. * \param[out] result the struct with the broken-out time information * \return result on success or NULL on error */ struct tm * ldns_serial_arithmitics_gmtime_r(int32_t time, time_t now, struct tm *result); /** * Seed the random function. * If the file descriptor is specified, the random generator is seeded with * data from that file. If not, /dev/urandom is used. * * applications should call this if they need entropy data within ldns * If openSSL is available, it is automatically seeded from /dev/urandom * or /dev/random. * * If you need more entropy, or have no openssl available, this function * MUST be called at the start of the program * * If openssl *is* available, this function just adds more entropy * * \param[in] fd a file providing entropy data for the seed * \param[in] size the number of bytes to use as entropy data. If this is 0, * only the minimal amount is taken (usually 4 bytes) * \return 0 if seeding succeeds, 1 if it fails */ int ldns_init_random(FILE *fd, unsigned int size); /** * Get random number. * \return random number. * */ uint16_t ldns_get_random(void); /** * Encode data as BubbleBabble * * \param[in] data a pointer to data to be encoded * \param[in] len size the number of bytes of data * \return a string of BubbleBabble */ char *ldns_bubblebabble(uint8_t *data, size_t len); INLINE time_t ldns_time(time_t *t) { return time(t); } /** * calculates the size needed to store the result of b32_ntop */ /*@unused@*/ INLINE size_t ldns_b32_ntop_calculate_size(size_t src_data_length) { return src_data_length == 0 ? 0 : ((src_data_length - 1) / 5 + 1) * 8; } INLINE size_t ldns_b32_ntop_calculate_size_no_padding(size_t src_data_length) { return ((src_data_length + 3) * 8 / 5) - 4; } int ldns_b32_ntop(const uint8_t* src_data, size_t src_data_length, char* target_text_buffer, size_t target_text_buffer_size); int ldns_b32_ntop_extended_hex(const uint8_t* src_data, size_t src_data_length, char* target_text_buffer, size_t target_text_buffer_size); #if ! LDNS_BUILD_CONFIG_HAVE_B32_NTOP int b32_ntop(const uint8_t* src_data, size_t src_data_length, char* target_text_buffer, size_t target_text_buffer_size); int b32_ntop_extended_hex(const uint8_t* src_data, size_t src_data_length, char* target_text_buffer, size_t target_text_buffer_size); #endif /* ! LDNS_BUILD_CONFIG_HAVE_B32_NTOP */ /** * calculates the size needed to store the result of b32_pton */ /*@unused@*/ INLINE size_t ldns_b32_pton_calculate_size(size_t src_text_length) { return src_text_length * 5 / 8; } int ldns_b32_pton(const char* src_text, size_t src_text_length, uint8_t* target_data_buffer, size_t target_data_buffer_size); int ldns_b32_pton_extended_hex(const char* src_text, size_t src_text_length, uint8_t* target_data_buffer, size_t target_data_buffer_size); #if ! LDNS_BUILD_CONFIG_HAVE_B32_PTON int b32_pton(const char* src_text, size_t src_text_length, uint8_t* target_data_buffer, size_t target_data_buffer_size); int b32_pton_extended_hex(const char* src_text, size_t src_text_length, uint8_t* target_data_buffer, size_t target_data_buffer_size); #endif /* ! LDNS_BUILD_CONFIG_HAVE_B32_PTON */ #ifdef __cplusplus } #endif #endif /* !_UTIL_H */ ldns-1.6.17/ldns/ldns.h0000664000175100017510000001104212264060151014162 0ustar willemwillem/* * dns.h -- defines for the Domain Name System * * Copyright (c) 2005-2008, NLnet Labs. All rights reserved. * * See LICENSE for the license. * * This library was created by: * Jelte Jansen, Erik Rozendaal and Miek Gieben * * A bunch of defines that are used in the DNS. */ /** \mainpage LDNS Documentation \section introduction Introduction The goal of ldns is to simplify DNS programming, it supports recent RFCs like the DNSSEC documents, and allow developers to easily create software conforming to current RFCs, and experimental software for current Internet drafts. A secondary benefit of using ldns is speed, because ldns is written in C, and although it is not optimized for performance, it should be a lot faster than Perl. The first main tool to use ldns is Drill, from which part of the library was derived. From version 1.0.0 on, drill is included in the ldns release and will not be distributed separately anymore. The library also includes some other examples and tools to show how it can be used. These can be found in the examples/ directory in the tarball. ldns depends on OpenSSL for it's cryptographic functions. Feature list - Transparent IPv4 and IPv6 support (overridable if necessary), - TSIG support, - DNSSEC support; signing and verification, - small size, - online documentation as well as manual pages. If you want to send us patches please use the code from git. \section using_ldns Using ldns Almost all interaction between an application and ldns goes through the ldns data structures (\ref ldns_rr, \ref ldns_pkt, etc.). These are input or output to the functions of ldns. For example, \ref ldns_zone_new_frm_fp reads a zone from a \c FILE pointer, and returns an \ref ldns_zone structure. Let's use Drill as an example. Drill is a tool much like dig, whose most basic function is to send 1 query to a nameserver and print the response. To be able to do this, drill uses the resolver module of ldns, which acts as a stub resolver. The resolver module uses the net module to actually send the query that drill requested. It then uses the wire2host module to translate the response and place it in ldns' internal structures. These are passed back to drill, which then uses the host2str module to print the response in presentation format. \section gettingstarted Getting Started See the \ref design page for a very high level description of the design choices made for ldns. For an overview of the functions and types ldns provides, you can check out the \ref ldns ldns header file descriptions. If you want to see some libdns action, you can read our tutorials: - \ref tutorial1_mx - \ref tutorial2_zone - \ref tutorial3_signzone Or you can just use the menu above to browse through the API docs.
\image html LogoInGradientBar2-y100.png
*/ /** * \file ldns.h * * Including this file will include all ldns files, and define some lookup tables. */ #ifndef LDNS_DNS_H #define LDNS_DNS_H #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifdef __cplusplus extern "C" { #endif #define LDNS_IP4ADDRLEN (32/8) #define LDNS_IP6ADDRLEN (128/8) #define LDNS_PORT 53 #define LDNS_ROOT_LABEL_STR "." #define LDNS_DEFAULT_TTL 3600 /* lookup tables for standard DNS stuff */ /** Taken from RFC 2538, section 2.1. */ extern ldns_lookup_table ldns_certificate_types[]; /** Taken from RFC 2535, section 7. */ extern ldns_lookup_table ldns_algorithms[]; /** Taken from RFC 2538. */ extern ldns_lookup_table ldns_cert_algorithms[]; /** rr types */ extern ldns_lookup_table ldns_rr_classes[]; /** Response codes */ extern ldns_lookup_table ldns_rcodes[]; /** Operation codes */ extern ldns_lookup_table ldns_opcodes[]; /** EDNS flags */ extern ldns_lookup_table ldns_edns_flags[]; #ifdef __cplusplus } #endif #endif /* LDNS_DNS_H */ ldns-1.6.17/ldns/dnssec_verify.h0000664000175100017510000007372112264060151016101 0ustar willemwillem/** dnssec_verify */ #ifndef LDNS_DNSSEC_VERIFY_H #define LDNS_DNSSEC_VERIFY_H #define LDNS_DNSSEC_TRUST_TREE_MAX_PARENTS 10 #include #include #ifdef __cplusplus extern "C" { #endif /** * Chain structure that contains all DNSSEC data needed to * verify an rrset */ typedef struct ldns_dnssec_data_chain_struct ldns_dnssec_data_chain; struct ldns_dnssec_data_chain_struct { ldns_rr_list *rrset; ldns_rr_list *signatures; ldns_rr_type parent_type; ldns_dnssec_data_chain *parent; ldns_pkt_rcode packet_rcode; ldns_rr_type packet_qtype; bool packet_nodata; }; /** * Creates a new dnssec_chain structure * \return ldns_dnssec_data_chain * */ ldns_dnssec_data_chain *ldns_dnssec_data_chain_new(void); /** * Frees a dnssec_data_chain structure * * \param[in] *chain The chain to free */ void ldns_dnssec_data_chain_free(ldns_dnssec_data_chain *chain); /** * Frees a dnssec_data_chain structure, and all data * contained therein * * \param[in] *chain The dnssec_data_chain to free */ void ldns_dnssec_data_chain_deep_free(ldns_dnssec_data_chain *chain); /** * Prints the dnssec_data_chain to the given file stream * * \param[in] *out The file stream to print to * \param[in] *chain The dnssec_data_chain to print */ void ldns_dnssec_data_chain_print(FILE *out, const ldns_dnssec_data_chain *chain); /** * Prints the dnssec_data_chain to the given file stream * * \param[in] *out The file stream to print to * \param[in] *fmt The format of the textual representation * \param[in] *chain The dnssec_data_chain to print */ void ldns_dnssec_data_chain_print_fmt(FILE *out, const ldns_output_format *fmt, const ldns_dnssec_data_chain *chain); /** * Build an ldns_dnssec_data_chain, which contains all * DNSSEC data that is needed to derive the trust tree later * * The data_set will be cloned * * \param[in] *res resolver structure for further needed queries * \param[in] qflags resolution flags * \param[in] *data_set The original rrset where the chain ends * \param[in] *pkt optional, can contain the original packet * (and hence the sigs and maybe the key) * \param[in] *orig_rr The original Resource Record * * \return the DNSSEC data chain */ ldns_dnssec_data_chain *ldns_dnssec_build_data_chain(ldns_resolver *res, const uint16_t qflags, const ldns_rr_list *data_set, const ldns_pkt *pkt, ldns_rr *orig_rr); /** * Tree structure that contains the relation of DNSSEC data, * and their cryptographic status. * * This tree is derived from a data_chain, and can be used * to look whether there is a connection between an RRSET * and a trusted key. The tree only contains pointers to the * data_chain, and therefore one should *never* free() the * data_chain when there is still a trust tree derived from * that chain. * * Example tree: * key key key * \ | / * \ | / * \ | / * ds * | * key * | * key * | * rr * * For each signature there is a parent; if the parent * pointer is null, it couldn't be found and there was no * denial; otherwise is a tree which contains either a * DNSKEY, a DS, or a NSEC rr */ typedef struct ldns_dnssec_trust_tree_struct ldns_dnssec_trust_tree; struct ldns_dnssec_trust_tree_struct { ldns_rr *rr; /* the complete rrset this rr was in */ ldns_rr_list *rrset; ldns_dnssec_trust_tree *parents[LDNS_DNSSEC_TRUST_TREE_MAX_PARENTS]; ldns_status parent_status[LDNS_DNSSEC_TRUST_TREE_MAX_PARENTS]; /** for debugging, add signatures too (you might want those if they contain errors) */ ldns_rr *parent_signature[LDNS_DNSSEC_TRUST_TREE_MAX_PARENTS]; size_t parent_count; }; /** * Creates a new (empty) dnssec_trust_tree structure * * \return ldns_dnssec_trust_tree * */ ldns_dnssec_trust_tree *ldns_dnssec_trust_tree_new(void); /** * Frees the dnssec_trust_tree recursively * * There is no deep free; all data in the trust tree * consists of pointers to a data_chain * * \param[in] tree The tree to free */ void ldns_dnssec_trust_tree_free(ldns_dnssec_trust_tree *tree); /** * returns the depth of the trust tree * * \param[in] tree tree to calculate the depth of * \return The depth of the tree */ size_t ldns_dnssec_trust_tree_depth(ldns_dnssec_trust_tree *tree); /** * Prints the dnssec_trust_tree structure to the given file * stream. * * If a link status is not LDNS_STATUS_OK; the status and * relevant signatures are printed too * * \param[in] *out The file stream to print to * \param[in] tree The trust tree to print * \param[in] tabs Prepend each line with tabs*2 spaces * \param[in] extended If true, add little explanation lines to the output */ void ldns_dnssec_trust_tree_print(FILE *out, ldns_dnssec_trust_tree *tree, size_t tabs, bool extended); /** * Prints the dnssec_trust_tree structure to the given file * stream. * * If a link status is not LDNS_STATUS_OK; the status and * relevant signatures are printed too * * \param[in] *out The file stream to print to * \param[in] *fmt The format of the textual representation * \param[in] tree The trust tree to print * \param[in] tabs Prepend each line with tabs*2 spaces * \param[in] extended If true, add little explanation lines to the output */ void ldns_dnssec_trust_tree_print_fmt(FILE *out, const ldns_output_format *fmt, ldns_dnssec_trust_tree *tree, size_t tabs, bool extended); /** * Adds a trust tree as a parent for the given trust tree * * \param[in] *tree The tree to add the parent to * \param[in] *parent The parent tree to add * \param[in] *parent_signature The RRSIG relevant to this parent/child * connection * \param[in] parent_status The DNSSEC status for this parent, child and RRSIG * \return LDNS_STATUS_OK if the addition succeeds, error otherwise */ ldns_status ldns_dnssec_trust_tree_add_parent(ldns_dnssec_trust_tree *tree, const ldns_dnssec_trust_tree *parent, const ldns_rr *parent_signature, const ldns_status parent_status); /** * Generates a dnssec_trust_tree for the given rr from the * given data_chain * * This does not clone the actual data; Don't free the * data_chain before you are done with this tree * * \param[in] *data_chain The chain to derive the trust tree from * \param[in] *rr The RR this tree will be about * \return ldns_dnssec_trust_tree * */ ldns_dnssec_trust_tree *ldns_dnssec_derive_trust_tree( ldns_dnssec_data_chain *data_chain, ldns_rr *rr); /** * Generates a dnssec_trust_tree for the given rr from the * given data_chain * * This does not clone the actual data; Don't free the * data_chain before you are done with this tree * * \param[in] *data_chain The chain to derive the trust tree from * \param[in] *rr The RR this tree will be about * \param[in] check_time the time for which the validation is performed * \return ldns_dnssec_trust_tree * */ ldns_dnssec_trust_tree *ldns_dnssec_derive_trust_tree_time( ldns_dnssec_data_chain *data_chain, ldns_rr *rr, time_t check_time); /** * Sub function for derive_trust_tree that is used for a 'normal' rrset * * \param[in] new_tree The trust tree that we are building * \param[in] data_chain The data chain containing the data for the trust tree * \param[in] cur_sig_rr The currently relevant signature */ void ldns_dnssec_derive_trust_tree_normal_rrset( ldns_dnssec_trust_tree *new_tree, ldns_dnssec_data_chain *data_chain, ldns_rr *cur_sig_rr); /** * Sub function for derive_trust_tree that is used for a 'normal' rrset * * \param[in] new_tree The trust tree that we are building * \param[in] data_chain The data chain containing the data for the trust tree * \param[in] cur_sig_rr The currently relevant signature * \param[in] check_time the time for which the validation is performed */ void ldns_dnssec_derive_trust_tree_normal_rrset_time( ldns_dnssec_trust_tree *new_tree, ldns_dnssec_data_chain *data_chain, ldns_rr *cur_sig_rr, time_t check_time); /** * Sub function for derive_trust_tree that is used for DNSKEY rrsets * * \param[in] new_tree The trust tree that we are building * \param[in] data_chain The data chain containing the data for the trust tree * \param[in] cur_rr The currently relevant DNSKEY RR * \param[in] cur_sig_rr The currently relevant signature */ void ldns_dnssec_derive_trust_tree_dnskey_rrset( ldns_dnssec_trust_tree *new_tree, ldns_dnssec_data_chain *data_chain, ldns_rr *cur_rr, ldns_rr *cur_sig_rr); /** * Sub function for derive_trust_tree that is used for DNSKEY rrsets * * \param[in] new_tree The trust tree that we are building * \param[in] data_chain The data chain containing the data for the trust tree * \param[in] cur_rr The currently relevant DNSKEY RR * \param[in] cur_sig_rr The currently relevant signature * \param[in] check_time the time for which the validation is performed */ void ldns_dnssec_derive_trust_tree_dnskey_rrset_time( ldns_dnssec_trust_tree *new_tree, ldns_dnssec_data_chain *data_chain, ldns_rr *cur_rr, ldns_rr *cur_sig_rr, time_t check_time); /** * Sub function for derive_trust_tree that is used for DNSKEY rrsets * * \param[in] new_tree The trust tree that we are building * \param[in] data_chain The data chain containing the data for the trust tree * \param[in] cur_rr The currently relevant DNSKEY RR * \param[in] cur_sig_rr The currently relevant signature * \param[in] check_time the time for which the validation is performed */ void ldns_dnssec_derive_trust_tree_dnskey_rrset_time( ldns_dnssec_trust_tree *new_tree, ldns_dnssec_data_chain *data_chain, ldns_rr *cur_rr, ldns_rr *cur_sig_rr, time_t check_time); /** * Sub function for derive_trust_tree that is used for DS rrsets * * \param[in] new_tree The trust tree that we are building * \param[in] data_chain The data chain containing the data for the trust tree * \param[in] cur_rr The currently relevant DS RR */ void ldns_dnssec_derive_trust_tree_ds_rrset( ldns_dnssec_trust_tree *new_tree, ldns_dnssec_data_chain *data_chain, ldns_rr *cur_rr); /** * Sub function for derive_trust_tree that is used for DS rrsets * * \param[in] new_tree The trust tree that we are building * \param[in] data_chain The data chain containing the data for the trust tree * \param[in] cur_rr The currently relevant DS RR * \param[in] check_time the time for which the validation is performed */ void ldns_dnssec_derive_trust_tree_ds_rrset_time( ldns_dnssec_trust_tree *new_tree, ldns_dnssec_data_chain *data_chain, ldns_rr *cur_rr, time_t check_time); /** * Sub function for derive_trust_tree that is used when there are no * signatures * * \param[in] new_tree The trust tree that we are building * \param[in] data_chain The data chain containing the data for the trust tree */ void ldns_dnssec_derive_trust_tree_no_sig( ldns_dnssec_trust_tree *new_tree, ldns_dnssec_data_chain *data_chain); /** * Sub function for derive_trust_tree that is used when there are no * signatures * * \param[in] new_tree The trust tree that we are building * \param[in] data_chain The data chain containing the data for the trust tree * \param[in] check_time the time for which the validation is performed */ void ldns_dnssec_derive_trust_tree_no_sig_time( ldns_dnssec_trust_tree *new_tree, ldns_dnssec_data_chain *data_chain, time_t check_time); /** * Returns OK if there is a trusted path in the tree to one of * the DNSKEY or DS RRs in the given list * * \param *tree The trust tree so search * \param *keys A ldns_rr_list of DNSKEY and DS rrs to look for * * \return LDNS_STATUS_OK if there is a trusted path to one of * the keys, or the *first* error encountered * if there were no paths */ ldns_status ldns_dnssec_trust_tree_contains_keys( ldns_dnssec_trust_tree *tree, ldns_rr_list *keys); /** * Verifies a list of signatures for one rrset. * * \param[in] rrset the rrset to verify * \param[in] rrsig a list of signatures to check * \param[in] keys a list of keys to check with * \param[out] good_keys if this is a (initialized) list, the pointer to keys * from keys that validate one of the signatures * are added to it * \return status LDNS_STATUS_OK if there is at least one correct key */ ldns_status ldns_verify(ldns_rr_list *rrset, ldns_rr_list *rrsig, const ldns_rr_list *keys, ldns_rr_list *good_keys); /** * Verifies a list of signatures for one rrset. * * \param[in] rrset the rrset to verify * \param[in] rrsig a list of signatures to check * \param[in] keys a list of keys to check with * \param[in] check_time the time for which the validation is performed * \param[out] good_keys if this is a (initialized) list, the pointer to keys * from keys that validate one of the signatures * are added to it * \return status LDNS_STATUS_OK if there is at least one correct key */ ldns_status ldns_verify_time(ldns_rr_list *rrset, ldns_rr_list *rrsig, const ldns_rr_list *keys, time_t check_time, ldns_rr_list *good_keys); /** * Verifies a list of signatures for one rrset, but disregard the time. * Inception and Expiration are not checked. * * \param[in] rrset the rrset to verify * \param[in] rrsig a list of signatures to check * \param[in] keys a list of keys to check with * \param[out] good_keys if this is a (initialized) list, the pointer to keys * from keys that validate one of the signatures * are added to it * \return status LDNS_STATUS_OK if there is at least one correct key */ ldns_status ldns_verify_notime(ldns_rr_list *rrset, ldns_rr_list *rrsig, const ldns_rr_list *keys, ldns_rr_list *good_keys); /** * Tries to build an authentication chain from the given * keys down to the queried domain. * * If we find a valid trust path, return the valid keys for the domain. * * \param[in] res the current resolver * \param[in] domain the domain we want valid keys for * \param[in] keys the current set of trusted keys * \param[out] status pointer to the status variable where the result * code will be stored * \return the set of trusted keys for the domain, or NULL if no * trust path could be built. */ ldns_rr_list *ldns_fetch_valid_domain_keys(const ldns_resolver * res, const ldns_rdf * domain, const ldns_rr_list * keys, ldns_status *status); /** * Tries to build an authentication chain from the given * keys down to the queried domain. * * If we find a valid trust path, return the valid keys for the domain. * * \param[in] res the current resolver * \param[in] domain the domain we want valid keys for * \param[in] keys the current set of trusted keys * \param[in] check_time the time for which the validation is performed * \param[out] status pointer to the status variable where the result * code will be stored * \return the set of trusted keys for the domain, or NULL if no * trust path could be built. */ 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); /** * Validates the DNSKEY RRset for the given domain using the provided * trusted keys. * * \param[in] res the current resolver * \param[in] domain the domain we want valid keys for * \param[in] keys the current set of trusted keys * \return the set of trusted keys for the domain, or NULL if the RRSET * could not be validated */ ldns_rr_list *ldns_validate_domain_dnskey (const ldns_resolver *res, const ldns_rdf *domain, const ldns_rr_list *keys); /** * Validates the DNSKEY RRset for the given domain using the provided * trusted keys. * * \param[in] res the current resolver * \param[in] domain the domain we want valid keys for * \param[in] keys the current set of trusted keys * \param[in] check_time the time for which the validation is performed * \return the set of trusted keys for the domain, or NULL if the RRSET * could not be validated */ 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); /** * Validates the DS RRset for the given domain using the provided trusted keys. * * \param[in] res the current resolver * \param[in] domain the domain we want valid keys for * \param[in] keys the current set of trusted keys * \return the set of trusted keys for the domain, or NULL if the RRSET could not be validated */ ldns_rr_list *ldns_validate_domain_ds(const ldns_resolver *res, const ldns_rdf * domain, const ldns_rr_list * keys); /** * Validates the DS RRset for the given domain using the provided trusted keys. * * \param[in] res the current resolver * \param[in] domain the domain we want valid keys for * \param[in] keys the current set of trusted keys * \param[in] check_time the time for which the validation is performed * \return the set of trusted keys for the domain, or NULL if the RRSET could not be validated */ 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); /** * Verifies a list of signatures for one RRset using a valid trust path. * * \param[in] res the current resolver * \param[in] rrset the rrset to verify * \param[in] rrsigs a list of signatures to check * \param[out] validating_keys if this is a (initialized) list, the * keys from keys that validate one of * the signatures are added to it * \return status LDNS_STATUS_OK if there is at least one correct key */ ldns_status ldns_verify_trusted(ldns_resolver *res, ldns_rr_list *rrset, ldns_rr_list *rrsigs, ldns_rr_list *validating_keys); /** * Verifies a list of signatures for one RRset using a valid trust path. * * \param[in] res the current resolver * \param[in] rrset the rrset to verify * \param[in] rrsigs a list of signatures to check * \param[in] check_time the time for which the validation is performed * \param[out] validating_keys if this is a (initialized) list, the * keys from keys that validate one of * the signatures are added to it * \return status LDNS_STATUS_OK if there is at least one correct key */ ldns_status ldns_verify_trusted_time( ldns_resolver *res, ldns_rr_list *rrset, ldns_rr_list *rrsigs, time_t check_time, ldns_rr_list *validating_keys); /** * denial is not just a river in egypt * * \param[in] rr The (query) RR to check the denial of existence for * \param[in] nsecs The list of NSEC RRs that are supposed to deny the * existence of the RR * \param[in] rrsigs The RRSIG RR covering the NSEC RRs * \return LDNS_STATUS_OK if the NSEC RRs deny the existence, error code * containing the reason they do not otherwise */ ldns_status ldns_dnssec_verify_denial(ldns_rr *rr, ldns_rr_list *nsecs, ldns_rr_list *rrsigs); /** * Denial of existence using NSEC3 records * Since NSEC3 is a bit more complicated than normal denial, some * context arguments are needed * * \param[in] rr The (query) RR to check the denial of existence for * \param[in] nsecs The list of NSEC3 RRs that are supposed to deny the * existence of the RR * \param[in] rrsigs The RRSIG rr covering the NSEC RRs * \param[in] packet_rcode The RCODE value of the packet that provided the * NSEC3 RRs * \param[in] packet_qtype The original query RR type * \param[in] packet_nodata True if the providing packet had an empty ANSWER * section * \return LDNS_STATUS_OK if the NSEC3 RRs deny the existence, error code * containing the reason they do not otherwise */ ldns_status ldns_dnssec_verify_denial_nsec3(ldns_rr *rr, ldns_rr_list *nsecs, ldns_rr_list *rrsigs, ldns_pkt_rcode packet_rcode, ldns_rr_type packet_qtype, bool packet_nodata); /** * Same as ldns_status ldns_dnssec_verify_denial_nsec3 but also returns * the nsec rr that matched. * * \param[in] rr The (query) RR to check the denial of existence for * \param[in] nsecs The list of NSEC3 RRs that are supposed to deny the * existence of the RR * \param[in] rrsigs The RRSIG rr covering the NSEC RRs * \param[in] packet_rcode The RCODE value of the packet that provided the * NSEC3 RRs * \param[in] packet_qtype The original query RR type * \param[in] packet_nodata True if the providing packet had an empty ANSWER * section * \param[in] match On match, the given (reference to a) pointer will be set * to point to the matching nsec resource record. * \return LDNS_STATUS_OK if the NSEC3 RRs deny the existence, error code * containing the reason they do not otherwise */ ldns_status ldns_dnssec_verify_denial_nsec3_match(ldns_rr *rr, ldns_rr_list *nsecs, ldns_rr_list *rrsigs, ldns_pkt_rcode packet_rcode, ldns_rr_type packet_qtype, bool packet_nodata, ldns_rr **match); /** * Verifies the already processed data in the buffers * This function should probably not be used directly. * * \param[in] rawsig_buf Buffer containing signature data to use * \param[in] verify_buf Buffer containing data to verify * \param[in] key_buf Buffer containing key data to use * \param[in] algo Signing algorithm * \return status LDNS_STATUS_OK if the data verifies. Error if not. */ ldns_status ldns_verify_rrsig_buffers(ldns_buffer *rawsig_buf, ldns_buffer *verify_buf, ldns_buffer *key_buf, uint8_t algo); /** * Like ldns_verify_rrsig_buffers, but uses raw data. * * \param[in] sig signature data to use * \param[in] siglen length of signature data to use * \param[in] verify_buf Buffer containing data to verify * \param[in] key key data to use * \param[in] keylen length of key data to use * \param[in] algo Signing algorithm * \return status LDNS_STATUS_OK if the data verifies. Error if not. */ ldns_status ldns_verify_rrsig_buffers_raw(unsigned char* sig, size_t siglen, ldns_buffer *verify_buf, unsigned char* key, size_t keylen, uint8_t algo); /** * Verifies an rrsig. All keys in the keyset are tried. * \param[in] rrset the rrset to check * \param[in] rrsig the signature of the rrset * \param[in] keys the keys to try * \param[out] good_keys if this is a (initialized) list, the pointer to keys * from keys that validate one of the signatures * are added to it * \return a list of keys which validate the rrsig + rrset. Returns * status LDNS_STATUS_OK if at least one key matched. Else an error. */ ldns_status ldns_verify_rrsig_keylist(ldns_rr_list *rrset, ldns_rr *rrsig, const ldns_rr_list *keys, ldns_rr_list *good_keys); /** * Verifies an rrsig. All keys in the keyset are tried. * \param[in] rrset the rrset to check * \param[in] rrsig the signature of the rrset * \param[in] keys the keys to try * \param[in] check_time the time for which the validation is performed * \param[out] good_keys if this is a (initialized) list, the pointer to keys * from keys that validate one of the signatures * are added to it * \return a list of keys which validate the rrsig + rrset. Returns * status LDNS_STATUS_OK if at least one key matched. Else an error. */ ldns_status ldns_verify_rrsig_keylist_time( ldns_rr_list *rrset, ldns_rr *rrsig, const ldns_rr_list *keys, time_t check_time, ldns_rr_list *good_keys); /** * Verifies an rrsig. All keys in the keyset are tried. Time is not checked. * \param[in] rrset the rrset to check * \param[in] rrsig the signature of the rrset * \param[in] keys the keys to try * \param[out] good_keys if this is a (initialized) list, the pointer to keys * from keys that validate one of the signatures * are added to it * \return a list of keys which validate the rrsig + rrset. Returns * status LDNS_STATUS_OK if at least one key matched. Else an error. */ ldns_status ldns_verify_rrsig_keylist_notime(ldns_rr_list *rrset, ldns_rr *rrsig, const ldns_rr_list *keys, ldns_rr_list *good_keys); /** * verify an rrsig with 1 key * \param[in] rrset the rrset * \param[in] rrsig the rrsig to verify * \param[in] key the key to use * \return status message wether verification succeeded. */ ldns_status ldns_verify_rrsig(ldns_rr_list *rrset, ldns_rr *rrsig, ldns_rr *key); /** * verify an rrsig with 1 key * \param[in] rrset the rrset * \param[in] rrsig the rrsig to verify * \param[in] key the key to use * \param[in] check_time the time for which the validation is performed * \return status message wether verification succeeded. */ ldns_status ldns_verify_rrsig_time( ldns_rr_list *rrset, ldns_rr *rrsig, ldns_rr *key, time_t check_time); #if LDNS_BUILD_CONFIG_HAVE_SSL /** * verifies a buffer with signature data for a buffer with rrset data * with an EVP_PKEY * * \param[in] sig the signature data * \param[in] rrset the rrset data, sorted and processed for verification * \param[in] key the EVP key structure * \param[in] digest_type The digest type of the signature */ ldns_status ldns_verify_rrsig_evp(ldns_buffer *sig, ldns_buffer *rrset, EVP_PKEY *key, const EVP_MD *digest_type); /** * Like ldns_verify_rrsig_evp, but uses raw signature data. * \param[in] sig the signature data, wireformat uncompressed * \param[in] siglen length of the signature data * \param[in] rrset the rrset data, sorted and processed for verification * \param[in] key the EVP key structure * \param[in] digest_type The digest type of the signature */ ldns_status ldns_verify_rrsig_evp_raw(unsigned char *sig, size_t siglen, ldns_buffer *rrset, EVP_PKEY *key, const EVP_MD *digest_type); #endif /** * verifies a buffer with signature data (DSA) for a buffer with rrset data * with a buffer with key data. * * \param[in] sig the signature data * \param[in] rrset the rrset data, sorted and processed for verification * \param[in] key the key data */ ldns_status ldns_verify_rrsig_dsa(ldns_buffer *sig, ldns_buffer *rrset, ldns_buffer *key); /** * verifies a buffer with signature data (RSASHA1) for a buffer with rrset data * with a buffer with key data. * * \param[in] sig the signature data * \param[in] rrset the rrset data, sorted and processed for verification * \param[in] key the key data */ ldns_status ldns_verify_rrsig_rsasha1(ldns_buffer *sig, ldns_buffer *rrset, ldns_buffer *key); /** * verifies a buffer with signature data (RSAMD5) for a buffer with rrset data * with a buffer with key data. * * \param[in] sig the signature data * \param[in] rrset the rrset data, sorted and processed for verification * \param[in] key the key data */ ldns_status ldns_verify_rrsig_rsamd5(ldns_buffer *sig, ldns_buffer *rrset, ldns_buffer *key); /** * Like ldns_verify_rrsig_dsa, but uses raw signature and key data. * \param[in] sig raw uncompressed wireformat signature data * \param[in] siglen length of signature data * \param[in] rrset ldns buffer with prepared rrset data. * \param[in] key raw uncompressed wireformat key data * \param[in] keylen length of key data */ ldns_status ldns_verify_rrsig_dsa_raw(unsigned char* sig, size_t siglen, ldns_buffer* rrset, unsigned char* key, size_t keylen); /** * Like ldns_verify_rrsig_rsasha1, but uses raw signature and key data. * \param[in] sig raw uncompressed wireformat signature data * \param[in] siglen length of signature data * \param[in] rrset ldns buffer with prepared rrset data. * \param[in] key raw uncompressed wireformat key data * \param[in] keylen length of key data */ ldns_status ldns_verify_rrsig_rsasha1_raw(unsigned char* sig, size_t siglen, ldns_buffer* rrset, unsigned char* key, size_t keylen); /** * Like ldns_verify_rrsig_rsasha256, but uses raw signature and key data. * \param[in] sig raw uncompressed wireformat signature data * \param[in] siglen length of signature data * \param[in] rrset ldns buffer with prepared rrset data. * \param[in] key raw uncompressed wireformat key data * \param[in] keylen length of key data */ ldns_status ldns_verify_rrsig_rsasha256_raw(unsigned char* sig, size_t siglen, ldns_buffer* rrset, unsigned char* key, size_t keylen); /** * Like ldns_verify_rrsig_rsasha512, but uses raw signature and key data. * \param[in] sig raw uncompressed wireformat signature data * \param[in] siglen length of signature data * \param[in] rrset ldns buffer with prepared rrset data. * \param[in] key raw uncompressed wireformat key data * \param[in] keylen length of key data */ ldns_status ldns_verify_rrsig_rsasha512_raw(unsigned char* sig, size_t siglen, ldns_buffer* rrset, unsigned char* key, size_t keylen); /** * Like ldns_verify_rrsig_rsamd5, but uses raw signature and key data. * \param[in] sig raw uncompressed wireformat signature data * \param[in] siglen length of signature data * \param[in] rrset ldns buffer with prepared rrset data. * \param[in] key raw uncompressed wireformat key data * \param[in] keylen length of key data */ ldns_status ldns_verify_rrsig_rsamd5_raw(unsigned char* sig, size_t siglen, ldns_buffer* rrset, unsigned char* key, size_t keylen); #ifdef __cplusplus } #endif #endif ldns-1.6.17/ldns/packet.h0000664000175100017510000006204512264060151014502 0ustar willemwillem/* * packet.h * * DNS packet definitions * * a Net::DNS like library for C * * (c) NLnet Labs, 2005-2006 * * See the file LICENSE for the license */ /** * \file * * Contains the definition of ldns_pkt and its parts, as well * as functions to manipulate those. */ #ifndef LDNS_PACKET_H #define LDNS_PACKET_H #define LDNS_MAX_PACKETLEN 65535 /* allow flags to be given to mk_query */ #define LDNS_QR 1 /* QueRy - query flag */ #define LDNS_AA 2 /* Authoritative Answer - server flag */ #define LDNS_TC 4 /* TrunCated - server flag */ #define LDNS_RD 8 /* Recursion Desired - query flag */ #define LDNS_CD 16 /* Checking Disabled - query flag */ #define LDNS_RA 32 /* Recursion Available - server flag */ #define LDNS_AD 64 /* Authenticated Data - server flag */ #include #include #include #include #ifdef __cplusplus extern "C" { #endif /* opcodes for pkt's */ enum ldns_enum_pkt_opcode { LDNS_PACKET_QUERY = 0, LDNS_PACKET_IQUERY = 1, LDNS_PACKET_STATUS = 2, /* there is no 3?? DNS is weird */ LDNS_PACKET_NOTIFY = 4, LDNS_PACKET_UPDATE = 5 }; typedef enum ldns_enum_pkt_opcode ldns_pkt_opcode; /* rcodes for pkts */ enum ldns_enum_pkt_rcode { LDNS_RCODE_NOERROR = 0, LDNS_RCODE_FORMERR = 1, LDNS_RCODE_SERVFAIL = 2, LDNS_RCODE_NXDOMAIN = 3, LDNS_RCODE_NOTIMPL = 4, LDNS_RCODE_REFUSED = 5, LDNS_RCODE_YXDOMAIN = 6, LDNS_RCODE_YXRRSET = 7, LDNS_RCODE_NXRRSET = 8, LDNS_RCODE_NOTAUTH = 9, LDNS_RCODE_NOTZONE = 10 }; typedef enum ldns_enum_pkt_rcode ldns_pkt_rcode; /** * Header of a dns packet * * Contains the information about the packet itself, as specified in RFC1035
4.1.1. Header section format

The header contains the following fields:

                                    1  1  1  1  1  1
      0  1  2  3  4  5  6  7  8  9  0  1  2  3  4  5
    +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
    |                      ID                       |
    +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
    |QR|   Opcode  |AA|TC|RD|RA|   Z    |   RCODE   |
    +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
    |                    QDCOUNT                    |
    +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
    |                    ANCOUNT                    |
    +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
    |                    NSCOUNT                    |
    +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
    |                    ARCOUNT                    |
    +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+

where:

ID              A 16 bit identifier assigned by the program that
                generates any kind of query.  This identifier is copied
                the corresponding reply and can be used by the requester
                to match up replies to outstanding queries.

QR              A one bit field that specifies whether this message is a
                query (0), or a response (1).

OPCODE          A four bit field that specifies kind of query in this
                message.  This value is set by the originator of a query
                and copied into the response.  The values are:

                0               a standard query (QUERY)

                1               an inverse query (IQUERY)

                2               a server status request (STATUS)

                3-15            reserved for future use

AA              Authoritative Answer - this bit is valid in responses,
                and specifies that the responding name server is an
                authority for the domain name in question section.

                Note that the contents of the answer section may have
                multiple owner names because of aliases.  The AA bit

                corresponds to the name which matches the query name, or
                the first owner name in the answer section.

TC              TrunCation - specifies that this message was truncated
                due to length greater than that permitted on the
                transmission channel.

RD              Recursion Desired - this bit may be set in a query and
                is copied into the response.  If RD is set, it directs
                the name server to pursue the query recursively.
                Recursive query support is optional.

RA              Recursion Available - this be is set or cleared in a
                response, and denotes whether recursive query support is
                available in the name server.

Z               Reserved for future use.  Must be zero in all queries
                and responses.

RCODE           Response code - this 4 bit field is set as part of
                responses.  The values have the following
                interpretation:

                0               No error condition

                1               Format error - The name server was
                                unable to interpret the query.

                2               Server failure - The name server was
                                unable to process this query due to a
                                problem with the name server.

                3               Name Error - Meaningful only for
                                responses from an authoritative name
                                server, this code signifies that the
                                domain name referenced in the query does
                                not exist.

                4               Not Implemented - The name server does
                                not support the requested kind of query.

                5               Refused - The name server refuses to
                                perform the specified operation for
                                policy reasons.  For example, a name
                                server may not wish to provide the
                                information to the particular requester,
                                or a name server may not wish to perform
                                a particular operation (e.g., zone

                                transfer) for particular data.

                6-15            Reserved for future use.

QDCOUNT         an unsigned 16 bit integer specifying the number of
                entries in the question section.

ANCOUNT         an unsigned 16 bit integer specifying the number of
                resource records in the answer section.

NSCOUNT         an unsigned 16 bit integer specifying the number of name
                server resource records in the authority records
                section.

ARCOUNT         an unsigned 16 bit integer specifying the number of
                resource records in the additional records section.

*/ struct ldns_struct_hdr { /** Id of a packet */ uint16_t _id; /** Query bit (0=query, 1=answer) */ bool _qr; /** Authoritative answer */ bool _aa; /** Packet truncated */ bool _tc; /** Recursion desired */ bool _rd; /** Checking disabled */ bool _cd; /** Recursion available */ bool _ra; /** Authentic data */ bool _ad; /** Query type */ ldns_pkt_opcode _opcode; /* XXX 8 bits? */ /** Response code */ uint8_t _rcode; /** question sec */ uint16_t _qdcount; /** answer sec */ uint16_t _ancount; /** auth sec */ uint16_t _nscount; /** add sec */ uint16_t _arcount; }; typedef struct ldns_struct_hdr ldns_hdr; /** * DNS packet * * This structure contains a complete DNS packet (either a query or an answer) * * It is the complete representation of what you actually send to a * nameserver, and what it sends back (assuming you are the client here). */ struct ldns_struct_pkt { /** Header section */ ldns_hdr *_header; /* extra items needed in a packet */ /** The size of the wire format of the packet in octets */ ldns_rdf *_answerfrom; /** Timestamp of the time the packet was sent or created */ struct timeval timestamp; /** The duration of the query this packet is an answer to */ uint32_t _querytime; /** The size of the wire format of the packet in octets */ size_t _size; /** Optional tsig rr */ ldns_rr *_tsig_rr; /** EDNS0 available buffer size, see RFC2671 */ uint16_t _edns_udp_size; /** EDNS0 Extended rcode */ uint8_t _edns_extended_rcode; /** EDNS Version */ uint8_t _edns_version; /** Reserved EDNS data bits */ uint16_t _edns_z; /** Arbitrary EDNS rdata */ ldns_rdf *_edns_data; /** Question section */ ldns_rr_list *_question; /** Answer section */ ldns_rr_list *_answer; /** Authority section */ ldns_rr_list *_authority; /** Additional section */ ldns_rr_list *_additional; }; typedef struct ldns_struct_pkt ldns_pkt; /** * The sections of a packet */ enum ldns_enum_pkt_section { LDNS_SECTION_QUESTION = 0, LDNS_SECTION_ANSWER = 1, LDNS_SECTION_AUTHORITY = 2, LDNS_SECTION_ADDITIONAL = 3, /** bogus section, if not interested */ LDNS_SECTION_ANY = 4, /** used to get all non-question rrs from a packet */ LDNS_SECTION_ANY_NOQUESTION = 5 }; typedef enum ldns_enum_pkt_section ldns_pkt_section; /** * The different types of packets */ enum ldns_enum_pkt_type { LDNS_PACKET_QUESTION, LDNS_PACKET_REFERRAL, LDNS_PACKET_ANSWER, LDNS_PACKET_NXDOMAIN, LDNS_PACKET_NODATA, LDNS_PACKET_UNKNOWN }; typedef enum ldns_enum_pkt_type ldns_pkt_type; /* prototypes */ /* read */ /** * Read the packet id * \param[in] p the packet * \return the packet id */ uint16_t ldns_pkt_id(const ldns_pkt *p); /** * Read the packet's qr bit * \param[in] p the packet * \return value of the bit */ bool ldns_pkt_qr(const ldns_pkt *p); /** * Read the packet's aa bit * \param[in] p the packet * \return value of the bit */ bool ldns_pkt_aa(const ldns_pkt *p); /** * Read the packet's tc bit * \param[in] p the packet * \return value of the bit */ bool ldns_pkt_tc(const ldns_pkt *p); /** * Read the packet's rd bit * \param[in] p the packet * \return value of the bit */ bool ldns_pkt_rd(const ldns_pkt *p); /** * Read the packet's cd bit * \param[in] p the packet * \return value of the bit */ bool ldns_pkt_cd(const ldns_pkt *p); /** * Read the packet's ra bit * \param[in] p the packet * \return value of the bit */ bool ldns_pkt_ra(const ldns_pkt *p); /** * Read the packet's ad bit * \param[in] p the packet * \return value of the bit */ bool ldns_pkt_ad(const ldns_pkt *p); /** * Read the packet's code * \param[in] p the packet * \return the opcode */ ldns_pkt_opcode ldns_pkt_get_opcode(const ldns_pkt *p); /** * Return the packet's respons code * \param[in] p the packet * \return the respons code */ ldns_pkt_rcode ldns_pkt_get_rcode(const ldns_pkt *p); /** * Return the packet's qd count * \param[in] p the packet * \return the qd count */ uint16_t ldns_pkt_qdcount(const ldns_pkt *p); /** * Return the packet's an count * \param[in] p the packet * \return the an count */ uint16_t ldns_pkt_ancount(const ldns_pkt *p); /** * Return the packet's ns count * \param[in] p the packet * \return the ns count */ uint16_t ldns_pkt_nscount(const ldns_pkt *p); /** * Return the packet's ar count * \param[in] p the packet * \return the ar count */ uint16_t ldns_pkt_arcount(const ldns_pkt *p); /** * Return the packet's answerfrom * \param[in] p packet * \return the name of the server */ ldns_rdf *ldns_pkt_answerfrom(const ldns_pkt *p); /** * Return the packet's timestamp * \param[in] p the packet * \return the timestamp */ struct timeval ldns_pkt_timestamp(const ldns_pkt *p); /** * Return the packet's querytime * \param[in] p the packet * \return the querytime */ uint32_t ldns_pkt_querytime(const ldns_pkt *p); /** * Return the packet's size in bytes * \param[in] p the packet * \return the size */ size_t ldns_pkt_size(const ldns_pkt *p); /** * Return the number of RRs in the given section. * Returns the sum of all RRs when LDNS_SECTION_ANY is given. * Returns the sum of all non-question RRs when LDNS_SECTION_ANY_NOQUESTION * is given. * \param[in] p the packet * \param[in] s the section * \return the number of RRs in the given section */ uint16_t ldns_pkt_section_count(const ldns_pkt *p, ldns_pkt_section s); /** * Return the packet's tsig pseudo rr's * \param[in] p the packet * \return the tsig rr */ ldns_rr *ldns_pkt_tsig(const ldns_pkt *p); /** * Return the packet's question section * \param[in] p the packet * \return the section */ ldns_rr_list *ldns_pkt_question(const ldns_pkt *p); /** * Return the packet's answer section * \param[in] p the packet * \return the section */ ldns_rr_list *ldns_pkt_answer(const ldns_pkt *p); /** * Return the packet's authority section * \param[in] p the packet * \return the section */ ldns_rr_list *ldns_pkt_authority(const ldns_pkt *p); /** * Return the packet's additional section * \param[in] p the packet * \return the section */ ldns_rr_list *ldns_pkt_additional(const ldns_pkt *p); /** * Return the packet's question, answer, authority and additional sections * concatenated, in a new rr_list clone. * \param[in] p the packet * \return the rrs */ ldns_rr_list *ldns_pkt_all(const ldns_pkt *p); /** * Return the packet's answer, authority and additional sections concatenated, * in a new rr_list clone. Like ldns_pkt_all but without the questions. * \param[in] p the packet * \return the rrs except the question rrs */ ldns_rr_list *ldns_pkt_all_noquestion(const ldns_pkt *p); /** * return all the rr_list's in the packet. Clone the lists, instead * of returning pointers. * \param[in] p the packet to look in * \param[in] s what section(s) to return * \return ldns_rr_list with the rr's or NULL if none were found */ ldns_rr_list *ldns_pkt_get_section_clone(const ldns_pkt *p, ldns_pkt_section s); /** * return all the rr with a specific name from a packet. Optionally * specify from which section in the packet * \param[in] p the packet * \param[in] r the name * \param[in] s the packet's section * \return a list with the rr's or NULL if none were found */ ldns_rr_list *ldns_pkt_rr_list_by_name(ldns_pkt *p, ldns_rdf *r, ldns_pkt_section s); /** * return all the rr with a specific type from a packet. Optionally * specify from which section in the packet * \param[in] p the packet * \param[in] t the type * \param[in] s the packet's section * \return a list with the rr's or NULL if none were found */ ldns_rr_list *ldns_pkt_rr_list_by_type(const ldns_pkt *p, ldns_rr_type t, ldns_pkt_section s); /** * return all the rr with a specific type and type from a packet. Optionally * specify from which section in the packet * \param[in] packet the packet * \param[in] ownername the name * \param[in] type the type * \param[in] sec the packet's section * \return a list with the rr's or NULL if none were found */ ldns_rr_list *ldns_pkt_rr_list_by_name_and_type(const ldns_pkt *packet, const ldns_rdf *ownername, ldns_rr_type type, ldns_pkt_section sec); /** * check to see if an rr exist in the packet * \param[in] pkt the packet to examine * \param[in] sec in which section to look * \param[in] rr the rr to look for */ bool ldns_pkt_rr(ldns_pkt *pkt, ldns_pkt_section sec, ldns_rr *rr); /** * sets the flags in a packet. * \param[in] pkt the packet to operate on * \param[in] flags ORed values: LDNS_QR| LDNS_AR for instance * \return true on success otherwise false */ bool ldns_pkt_set_flags(ldns_pkt *pkt, uint16_t flags); /** * Set the packet's id * \param[in] p the packet * \param[in] id the id to set */ void ldns_pkt_set_id(ldns_pkt *p, uint16_t id); /** * Set the packet's id to a random value * \param[in] p the packet */ void ldns_pkt_set_random_id(ldns_pkt *p); /** * Set the packet's qr bit * \param[in] p the packet * \param[in] b the value to set (boolean) */ void ldns_pkt_set_qr(ldns_pkt *p, bool b); /** * Set the packet's aa bit * \param[in] p the packet * \param[in] b the value to set (boolean) */ void ldns_pkt_set_aa(ldns_pkt *p, bool b); /** * Set the packet's tc bit * \param[in] p the packet * \param[in] b the value to set (boolean) */ void ldns_pkt_set_tc(ldns_pkt *p, bool b); /** * Set the packet's rd bit * \param[in] p the packet * \param[in] b the value to set (boolean) */ void ldns_pkt_set_rd(ldns_pkt *p, bool b); /** * Set the packet's cd bit * \param[in] p the packet * \param[in] b the value to set (boolean) */ void ldns_pkt_set_cd(ldns_pkt *p, bool b); /** * Set the packet's ra bit * \param[in] p the packet * \param[in] b the value to set (boolean) */ void ldns_pkt_set_ra(ldns_pkt *p, bool b); /** * Set the packet's ad bit * \param[in] p the packet * \param[in] b the value to set (boolean) */ void ldns_pkt_set_ad(ldns_pkt *p, bool b); /** * Set the packet's opcode * \param[in] p the packet * \param[in] c the opcode */ void ldns_pkt_set_opcode(ldns_pkt *p, ldns_pkt_opcode c); /** * Set the packet's respons code * \param[in] p the packet * \param[in] c the rcode */ void ldns_pkt_set_rcode(ldns_pkt *p, uint8_t c); /** * Set the packet's qd count * \param[in] p the packet * \param[in] c the count */ void ldns_pkt_set_qdcount(ldns_pkt *p, uint16_t c); /** * Set the packet's an count * \param[in] p the packet * \param[in] c the count */ void ldns_pkt_set_ancount(ldns_pkt *p, uint16_t c); /** * Set the packet's ns count * \param[in] p the packet * \param[in] c the count */ void ldns_pkt_set_nscount(ldns_pkt *p, uint16_t c); /** * Set the packet's arcount * \param[in] p the packet * \param[in] c the count */ void ldns_pkt_set_arcount(ldns_pkt *p, uint16_t c); /** * Set the packet's answering server * \param[in] p the packet * \param[in] r the address */ void ldns_pkt_set_answerfrom(ldns_pkt *p, ldns_rdf *r); /** * Set the packet's query time * \param[in] p the packet * \param[in] t the querytime in msec */ void ldns_pkt_set_querytime(ldns_pkt *p, uint32_t t); /** * Set the packet's size * \param[in] p the packet * \param[in] s the size */ void ldns_pkt_set_size(ldns_pkt *p, size_t s); /** * Set the packet's timestamp * \param[in] p the packet * \param[in] timeval the timestamp */ void ldns_pkt_set_timestamp(ldns_pkt *p, struct timeval timeval); /** * Set a packet's section count to x * \param[in] p the packet * \param[in] s the section * \param[in] x the section count */ void ldns_pkt_set_section_count(ldns_pkt *p, ldns_pkt_section s, uint16_t x); /** * Set the packet's tsig rr * \param[in] p the packet * \param[in] t the tsig rr */ void ldns_pkt_set_tsig(ldns_pkt *p, ldns_rr *t); /** * looks inside the packet to determine * what kind of packet it is, AUTH, NXDOMAIN, REFERRAL, etc. * \param[in] p the packet to examine * \return the type of packet */ ldns_pkt_type ldns_pkt_reply_type(ldns_pkt *p); /** * return the packet's edns udp size * \param[in] packet the packet * \return the size */ uint16_t ldns_pkt_edns_udp_size(const ldns_pkt *packet); /** * return the packet's edns extended rcode * \param[in] packet the packet * \return the rcode */ uint8_t ldns_pkt_edns_extended_rcode(const ldns_pkt *packet); /** * return the packet's edns version * \param[in] packet the packet * \return the version */ uint8_t ldns_pkt_edns_version(const ldns_pkt *packet); /** * return the packet's edns z value * \param[in] packet the packet * \return the z value */ uint16_t ldns_pkt_edns_z(const ldns_pkt *packet); /** * return the packet's edns data * \param[in] packet the packet * \return the data */ ldns_rdf *ldns_pkt_edns_data(const ldns_pkt *packet); /** * return the packet's edns do bit * \param[in] packet the packet * \return the bit's value */ bool ldns_pkt_edns_do(const ldns_pkt *packet); /** * Set the packet's edns do bit * \param[in] packet the packet * \param[in] value the bit's new value */ void ldns_pkt_set_edns_do(ldns_pkt *packet, bool value); /** * returns true if this packet needs and EDNS rr to be sent. * At the moment the only reason is an expected packet * size larger than 512 bytes, but for instance dnssec would * be a good reason too. * * \param[in] packet the packet to check * \return true if packet needs edns rr */ bool ldns_pkt_edns(const ldns_pkt *packet); /** * Set the packet's edns udp size * \param[in] packet the packet * \param[in] s the size */ void ldns_pkt_set_edns_udp_size(ldns_pkt *packet, uint16_t s); /** * Set the packet's edns extended rcode * \param[in] packet the packet * \param[in] c the code */ void ldns_pkt_set_edns_extended_rcode(ldns_pkt *packet, uint8_t c); /** * Set the packet's edns version * \param[in] packet the packet * \param[in] v the version */ void ldns_pkt_set_edns_version(ldns_pkt *packet, uint8_t v); /** * Set the packet's edns z value * \param[in] packet the packet * \param[in] z the value */ void ldns_pkt_set_edns_z(ldns_pkt *packet, uint16_t z); /** * Set the packet's edns data * \param[in] packet the packet * \param[in] data the data */ void ldns_pkt_set_edns_data(ldns_pkt *packet, ldns_rdf *data); /** * allocates and initializes a ldns_pkt structure. * \return pointer to the new packet */ ldns_pkt *ldns_pkt_new(void); /** * frees the packet structure and all data that it contains. * \param[in] packet The packet structure to free * \return void */ void ldns_pkt_free(ldns_pkt *packet); /** * creates a query packet for the given name, type, class. * \param[out] p the packet to be returned * \param[in] rr_name the name to query for (as string) * \param[in] rr_type the type to query for * \param[in] rr_class the class to query for * \param[in] flags packet flags * \return LDNS_STATUS_OK or a ldns_status mesg with the error */ ldns_status ldns_pkt_query_new_frm_str(ldns_pkt **p, const char *rr_name, ldns_rr_type rr_type, ldns_rr_class rr_class , uint16_t flags); /** * creates an IXFR request packet for the given name, class. * adds the SOA record to the authority section. * \param[out] p the packet to be returned * \param[in] rr_name the name to query for (as string) * \param[in] rr_class the class to query for * \param[in] flags packet flags * \param[in] soa soa record to be added to the authority section * \return LDNS_STATUS_OK or a ldns_status mesg with the error */ ldns_status ldns_pkt_ixfr_request_new_frm_str(ldns_pkt **p, const char *rr_name, ldns_rr_class rr_class, uint16_t flags, ldns_rr* soa); /** * creates a packet with a query in it for the given name, type and class. * \param[in] rr_name the name to query for * \param[in] rr_type the type to query for * \param[in] rr_class the class to query for * \param[in] flags packet flags * \return ldns_pkt* a pointer to the new pkt */ ldns_pkt *ldns_pkt_query_new(ldns_rdf *rr_name, ldns_rr_type rr_type, ldns_rr_class rr_class, uint16_t flags); /** * creates an IXFR request packet for the given name, type and class. * adds the SOA record to the authority section. * \param[in] rr_name the name to query for * \param[in] rr_class the class to query for * \param[in] flags packet flags * \param[in] soa soa record to be added to the authority section * \return ldns_pkt* a pointer to the new pkt */ ldns_pkt *ldns_pkt_ixfr_request_new(ldns_rdf *rr_name, ldns_rr_class rr_class, uint16_t flags, ldns_rr* soa); /** * clones the given packet, creating a fully allocated copy * * \param[in] pkt the packet to clone * \return ldns_pkt* pointer to the new packet */ ldns_pkt *ldns_pkt_clone(ldns_pkt *pkt); /** * directly set the additional section * \param[in] p packet to operate on * \param[in] rr rrlist to set */ void ldns_pkt_set_additional(ldns_pkt *p, ldns_rr_list *rr); /** * directly set the answer section * \param[in] p packet to operate on * \param[in] rr rrlist to set */ void ldns_pkt_set_answer(ldns_pkt *p, ldns_rr_list *rr); /** * directly set the question section * \param[in] p packet to operate on * \param[in] rr rrlist to set */ void ldns_pkt_set_question(ldns_pkt *p, ldns_rr_list *rr); /** * directly set the auhority section * \param[in] p packet to operate on * \param[in] rr rrlist to set */ void ldns_pkt_set_authority(ldns_pkt *p, ldns_rr_list *rr); /** * push an rr on a packet * \param[in] packet packet to operate on * \param[in] section where to put it * \param[in] rr rr to push * \return a boolean which is true when the rr was added */ bool ldns_pkt_push_rr(ldns_pkt *packet, ldns_pkt_section section, ldns_rr *rr); /** * push an rr on a packet, provided the RR is not there. * \param[in] pkt packet to operate on * \param[in] sec where to put it * \param[in] rr rr to push * \return a boolean which is true when the rr was added */ bool ldns_pkt_safe_push_rr(ldns_pkt *pkt, ldns_pkt_section sec, ldns_rr *rr); /** * push a rr_list on a packet * \param[in] packet packet to operate on * \param[in] section where to put it * \param[in] list the rr_list to push * \return a boolean which is true when the rr was added */ bool ldns_pkt_push_rr_list(ldns_pkt *packet, ldns_pkt_section section, ldns_rr_list *list); /** * push an rr_list to a packet, provided the RRs are not already there. * \param[in] pkt packet to operate on * \param[in] sec where to put it * \param[in] list the rr_list to push * \return a boolean which is true when the rr was added */ bool ldns_pkt_safe_push_rr_list(ldns_pkt *pkt, ldns_pkt_section sec, ldns_rr_list *list); /** * check if a packet is empty * \param[in] p packet * \return true: empty, false: not empty */ bool ldns_pkt_empty(ldns_pkt *p); #ifdef __cplusplus } #endif #endif /* LDNS_PACKET_H */ ldns-1.6.17/ldns/resolver.h0000664000175100017510000005657212264060151015104 0ustar willemwillem/* * resolver.h * * DNS Resolver definitions * * a Net::DNS like library for C * * (c) NLnet Labs, 2005-2006 * * See the file LICENSE for the license */ /** * \file * * Defines the ldns_resolver structure, a stub resolver that can send queries and parse answers. * */ #ifndef LDNS_RESOLVER_H #define LDNS_RESOLVER_H #include #include #include #include #include #include #include #ifdef __cplusplus extern "C" { #endif /** Default location of the resolv.conf file */ #define LDNS_RESOLV_CONF "/etc/resolv.conf" /** Default location of the hosts file */ #define LDNS_RESOLV_HOSTS "/etc/hosts" #define LDNS_RESOLV_KEYWORD -1 #define LDNS_RESOLV_DEFDOMAIN 0 #define LDNS_RESOLV_NAMESERVER 1 #define LDNS_RESOLV_SEARCH 2 #define LDNS_RESOLV_SORTLIST 3 #define LDNS_RESOLV_OPTIONS 4 #define LDNS_RESOLV_ANCHOR 5 #define LDNS_RESOLV_KEYWORDS 6 #define LDNS_RESOLV_INETANY 0 #define LDNS_RESOLV_INET 1 #define LDNS_RESOLV_INET6 2 #define LDNS_RESOLV_RTT_INF 0 /* infinity */ #define LDNS_RESOLV_RTT_MIN 1 /* reachable */ /** * DNS stub resolver structure */ struct ldns_struct_resolver { /** Port to send queries to */ uint16_t _port; /** Array of nameservers to query (IP addresses or dnames) */ ldns_rdf **_nameservers; /** Number of nameservers in \c _nameservers */ size_t _nameserver_count; /* how many do we have */ /** Round trip time; 0 -> infinity. Unit: ms? */ size_t *_rtt; /** Wether or not to be recursive */ bool _recursive; /** Print debug information */ bool _debug; /** Default domain to add to non fully qualified domain names */ ldns_rdf *_domain; /** Searchlist array, add the names in this array if a query cannot be found */ ldns_rdf **_searchlist; /** Number of entries in the searchlist array */ size_t _searchlist_count; /** Number of times to retry before giving up */ uint8_t _retry; /** Time to wait before retrying */ uint8_t _retrans; /** Use new fallback mechanism (try EDNS, then do TCP) */ bool _fallback; /** Whether to do DNSSEC */ bool _dnssec; /** Whether to set the CD bit on DNSSEC requests */ bool _dnssec_cd; /** Optional trust anchors for complete DNSSEC validation */ ldns_rr_list * _dnssec_anchors; /** Whether to use tcp or udp (tcp if the value is true)*/ bool _usevc; /** Whether to ignore the tc bit */ bool _igntc; /** Whether to use ip6, 0->does not matter, 1 is IPv4, 2 is IPv6 */ uint8_t _ip6; /** If true append the default domain */ bool _defnames; /** If true apply the search list */ bool _dnsrch; /** Timeout for socket connections */ struct timeval _timeout; /** Only try the first nameserver, and return with an error directly if it fails */ bool _fail; /** Randomly choose a nameserver */ bool _random; /** Keep some things to make AXFR possible */ int _socket; /** Count the number of LDNS_RR_TYPE_SOA RRs we have seen so far * (the second one signifies the end of the AXFR) */ int _axfr_soa_count; /* when axfring we get complete packets from the server but we want to give the caller 1 rr at a time, so keep the current pkt */ /** Packet currently handled when doing part of an AXFR */ ldns_pkt *_cur_axfr_pkt; /** Counter for within the AXFR packets */ uint16_t _axfr_i; /* EDNS0 available buffer size */ uint16_t _edns_udp_size; /* Optional tsig key for signing queries, outgoing messages are signed if and only if both are set */ /** Name of the key to use with TSIG, if _tsig_keyname and _tsig_keydata both contain values, outgoing messages are automatically signed with TSIG. */ char *_tsig_keyname; /** Secret key data to use with TSIG, if _tsig_keyname and _tsig_keydata both contain values, outgoing messages are automatically signed with TSIG. */ char *_tsig_keydata; /** TSIG signing algorithm */ char *_tsig_algorithm; /** Source address to query from */ ldns_rdf *_source; }; typedef struct ldns_struct_resolver ldns_resolver; /* prototypes */ /* read access functions */ /** * Get the port the resolver should use * \param[in] r the resolver * \return the port number */ uint16_t ldns_resolver_port(const ldns_resolver *r); /** * Get the source address the resolver should use * \param[in] r the resolver * \return the source rdf */ ldns_rdf *ldns_resolver_source(const ldns_resolver *r); /** * Is the resolver set to recurse * \param[in] r the resolver * \return true if so, otherwise false */ bool ldns_resolver_recursive(const ldns_resolver *r); /** * Get the debug status of the resolver * \param[in] r the resolver * \return true if so, otherwise false */ bool ldns_resolver_debug(const ldns_resolver *r); /** * Get the number of retries * \param[in] r the resolver * \return the number of retries */ uint8_t ldns_resolver_retry(const ldns_resolver *r); /** * Get the retransmit interval * \param[in] r the resolver * \return the retransmit interval */ uint8_t ldns_resolver_retrans(const ldns_resolver *r); /** * Get the truncation fallback status * \param[in] r the resolver * \return whether the truncation fallback mechanism is used */ bool ldns_resolver_fallback(const ldns_resolver *r); /** * Does the resolver use ip6 or ip4 * \param[in] r the resolver * \return 0: both, 1: ip4, 2:ip6 */ uint8_t ldns_resolver_ip6(const ldns_resolver *r); /** * Get the resolver's udp size * \param[in] r the resolver * \return the udp mesg size */ uint16_t ldns_resolver_edns_udp_size(const ldns_resolver *r); /** * Does the resolver use tcp or udp * \param[in] r the resolver * \return true: tcp, false: udp */ bool ldns_resolver_usevc(const ldns_resolver *r); /** * Does the resolver only try the first nameserver * \param[in] r the resolver * \return true: yes, fail, false: no, try the others */ bool ldns_resolver_fail(const ldns_resolver *r); /** * Does the resolver apply default domain name * \param[in] r the resolver * \return true: yes, false: no */ bool ldns_resolver_defnames(const ldns_resolver *r); /** * Does the resolver apply search list * \param[in] r the resolver * \return true: yes, false: no */ bool ldns_resolver_dnsrch(const ldns_resolver *r); /** * Does the resolver do DNSSEC * \param[in] r the resolver * \return true: yes, false: no */ bool ldns_resolver_dnssec(const ldns_resolver *r); /** * Does the resolver set the CD bit * \param[in] r the resolver * \return true: yes, false: no */ bool ldns_resolver_dnssec_cd(const ldns_resolver *r); /** * Get the resolver's DNSSEC anchors * \param[in] r the resolver * \return an rr_list containg trusted DNSSEC anchors */ ldns_rr_list * ldns_resolver_dnssec_anchors(const ldns_resolver *r); /** * Does the resolver ignore the TC bit (truncated) * \param[in] r the resolver * \return true: yes, false: no */ bool ldns_resolver_igntc(const ldns_resolver *r); /** * Does the resolver randomize the nameserver before usage * \param[in] r the resolver * \return true: yes, false: no */ bool ldns_resolver_random(const ldns_resolver *r); /** * How many nameserver are configured in the resolver * \param[in] r the resolver * \return number of nameservers */ size_t ldns_resolver_nameserver_count(const ldns_resolver *r); /** * What is the default dname to add to relative queries * \param[in] r the resolver * \return the dname which is added */ ldns_rdf *ldns_resolver_domain(const ldns_resolver *r); /** * What is the timeout on socket connections * \param[in] r the resolver * \return the timeout as struct timeval */ struct timeval ldns_resolver_timeout(const ldns_resolver *r); /** * What is the searchlist as used by the resolver * \param[in] r the resolver * \return a ldns_rdf pointer to a list of the addresses */ ldns_rdf** ldns_resolver_searchlist(const ldns_resolver *r); /** * Return the configured nameserver ip address * \param[in] r the resolver * \return a ldns_rdf pointer to a list of the addresses */ ldns_rdf** ldns_resolver_nameservers(const ldns_resolver *r); /** * Return the used round trip times for the nameservers * \param[in] r the resolver * \return a size_t* pointer to the list. * yet) */ size_t * ldns_resolver_rtt(const ldns_resolver *r); /** * Return the used round trip time for a specific nameserver * \param[in] r the resolver * \param[in] pos the index to the nameserver * \return the rrt, 0: infinite, >0: undefined (as of * yet) */ size_t ldns_resolver_nameserver_rtt(const ldns_resolver *r, size_t pos); /** * Return the tsig keyname as used by the nameserver * \param[in] r the resolver * \return the name used. */ char *ldns_resolver_tsig_keyname(const ldns_resolver *r); /** * Return the tsig algorithm as used by the nameserver * \param[in] r the resolver * \return the algorithm used. */ char *ldns_resolver_tsig_algorithm(const ldns_resolver *r); /** * Return the tsig keydata as used by the nameserver * \param[in] r the resolver * \return the keydata used. */ char *ldns_resolver_tsig_keydata(const ldns_resolver *r); /** * pop the last nameserver from the resolver. * \param[in] r the resolver * \return the popped address or NULL if empty */ ldns_rdf* ldns_resolver_pop_nameserver(ldns_resolver *r); /** * Return the resolver's searchlist count * \param[in] r the resolver * \return the searchlist count */ size_t ldns_resolver_searchlist_count(const ldns_resolver *r); /* write access function */ /** * Set the port the resolver should use * \param[in] r the resolver * \param[in] p the port number */ void ldns_resolver_set_port(ldns_resolver *r, uint16_t p); /** * Set the source rdf (address) the resolver should use * \param[in] r the resolver * \param[in] s the source address */ void ldns_resolver_set_source(ldns_resolver *r, ldns_rdf *s); /** * Set the resolver recursion * \param[in] r the resolver * \param[in] b true: set to recurse, false: unset */ void ldns_resolver_set_recursive(ldns_resolver *r, bool b); /** * Set the resolver debugging * \param[in] r the resolver * \param[in] b true: debug on: false debug off */ void ldns_resolver_set_debug(ldns_resolver *r, bool b); /** * Incremental the resolver's nameserver count. * \param[in] r the resolver */ void ldns_resolver_incr_nameserver_count(ldns_resolver *r); /** * Decrement the resolver's nameserver count. * \param[in] r the resolver */ void ldns_resolver_dec_nameserver_count(ldns_resolver *r); /** * Set the resolver's nameserver count directly. * \param[in] r the resolver * \param[in] c the nameserver count */ void ldns_resolver_set_nameserver_count(ldns_resolver *r, size_t c); /** * Set the resolver's nameserver count directly by using an rdf list * \param[in] r the resolver * \param[in] rd the resolver addresses */ void ldns_resolver_set_nameservers(ldns_resolver *r, ldns_rdf **rd); /** * Set the resolver's default domain. This gets appended when no * absolute name is given * \param[in] r the resolver * \param[in] rd the name to append */ void ldns_resolver_set_domain(ldns_resolver *r, ldns_rdf *rd); /** * Set the resolver's socket time out when talking to remote hosts * \param[in] r the resolver * \param[in] timeout the timeout to use */ void ldns_resolver_set_timeout(ldns_resolver *r, struct timeval timeout); /** * Push a new rd to the resolver's searchlist * \param[in] r the resolver * \param[in] rd to push */ void ldns_resolver_push_searchlist(ldns_resolver *r, ldns_rdf *rd); /** * Whether the resolver uses the name set with _set_domain * \param[in] r the resolver * \param[in] b true: use the defaults, false: don't use them */ void ldns_resolver_set_defnames(ldns_resolver *r, bool b); /** * Whether the resolver uses a virtual circuit (TCP) * \param[in] r the resolver * \param[in] b true: use TCP, false: don't use TCP */ void ldns_resolver_set_usevc(ldns_resolver *r, bool b); /** * Whether the resolver uses the searchlist * \param[in] r the resolver * \param[in] b true: use the list, false: don't use the list */ void ldns_resolver_set_dnsrch(ldns_resolver *r, bool b); /** * Whether the resolver uses DNSSEC * \param[in] r the resolver * \param[in] b true: use DNSSEC, false: don't use DNSSEC */ void ldns_resolver_set_dnssec(ldns_resolver *r, bool b); /** * Whether the resolver uses the checking disable bit * \param[in] r the resolver * \param[in] b true: enable , false: don't use TCP */ void ldns_resolver_set_dnssec_cd(ldns_resolver *r, bool b); /** * Set the resolver's DNSSEC anchor list directly. RRs should be of type DS or DNSKEY. * \param[in] r the resolver * \param[in] l the list of RRs to use as trust anchors */ void ldns_resolver_set_dnssec_anchors(ldns_resolver *r, ldns_rr_list * l); /** * Push a new trust anchor to the resolver. It must be a DS or DNSKEY rr * \param[in] r the resolver. * \param[in] rr the RR to add as a trust anchor. * \return a status */ ldns_status ldns_resolver_push_dnssec_anchor(ldns_resolver *r, ldns_rr *rr); /** * Set the resolver retrans timeout (in seconds) * \param[in] r the resolver * \param[in] re the retransmission interval in seconds */ void ldns_resolver_set_retrans(ldns_resolver *r, uint8_t re); /** * Set whether the resolvers truncation fallback mechanism is used * when ldns_resolver_query() is called. * \param[in] r the resolver * \param[in] fallback whether to use the fallback mechanism */ void ldns_resolver_set_fallback(ldns_resolver *r, bool fallback); /** * Set the number of times a resolver should retry a nameserver before the * next one is tried. * \param[in] r the resolver * \param[in] re the number of retries */ void ldns_resolver_set_retry(ldns_resolver *r, uint8_t re); /** * Whether the resolver uses ip6 * \param[in] r the resolver * \param[in] i 0: no pref, 1: ip4, 2: ip6 */ void ldns_resolver_set_ip6(ldns_resolver *r, uint8_t i); /** * Whether or not to fail after one failed query * \param[in] r the resolver * \param[in] b true: yes fail, false: continue with next nameserver */ void ldns_resolver_set_fail(ldns_resolver *r, bool b); /** * Whether or not to ignore the TC bit * \param[in] r the resolver * \param[in] b true: yes ignore, false: don't ignore */ void ldns_resolver_set_igntc(ldns_resolver *r, bool b); /** * Set maximum udp size * \param[in] r the resolver * \param[in] s the udp max size */ void ldns_resolver_set_edns_udp_size(ldns_resolver *r, uint16_t s); /** * Set the tsig key name * \param[in] r the resolver * \param[in] tsig_keyname the tsig key name */ void ldns_resolver_set_tsig_keyname(ldns_resolver *r, char *tsig_keyname); /** * Set the tsig algorithm * \param[in] r the resolver * \param[in] tsig_algorithm the tsig algorithm */ void ldns_resolver_set_tsig_algorithm(ldns_resolver *r, char *tsig_algorithm); /** * Set the tsig key data * \param[in] r the resolver * \param[in] tsig_keydata the key data */ void ldns_resolver_set_tsig_keydata(ldns_resolver *r, char *tsig_keydata); /** * Set round trip time for all nameservers. Note this currently * differentiates between: unreachable and reachable. * \param[in] r the resolver * \param[in] rtt a list with the times */ void ldns_resolver_set_rtt(ldns_resolver *r, size_t *rtt); /** * Set round trip time for a specific nameserver. Note this * currently differentiates between: unreachable and reachable. * \param[in] r the resolver * \param[in] pos the nameserver position * \param[in] value the rtt */ void ldns_resolver_set_nameserver_rtt(ldns_resolver *r, size_t pos, size_t value); /** * Should the nameserver list be randomized before each use * \param[in] r the resolver * \param[in] b: true: randomize, false: don't */ void ldns_resolver_set_random(ldns_resolver *r, bool b); /** * Push a new nameserver to the resolver. It must be an IP * address v4 or v6. * \param[in] r the resolver * \param[in] n the ip address * \return ldns_status a status */ ldns_status ldns_resolver_push_nameserver(ldns_resolver *r, ldns_rdf *n); /** * Push a new nameserver to the resolver. It must be an * A or AAAA RR record type * \param[in] r the resolver * \param[in] rr the resource record * \return ldns_status a status */ ldns_status ldns_resolver_push_nameserver_rr(ldns_resolver *r, ldns_rr *rr); /** * Push a new nameserver rr_list to the resolver. * \param[in] r the resolver * \param[in] rrlist the rr_list to push * \return ldns_status a status */ ldns_status ldns_resolver_push_nameserver_rr_list(ldns_resolver *r, ldns_rr_list *rrlist); /** * Send the query for using the resolver and take the search list into account * The search algorithm is as follows: * If the name is absolute, try it as-is, otherwise apply the search list * \param[in] *r operate using this resolver * \param[in] *rdf query for this name * \param[in] t query for this type (may be 0, defaults to A) * \param[in] c query for this class (may be 0, default to IN) * \param[in] flags the query flags * * \return ldns_pkt* a packet with the reply from the nameserver */ ldns_pkt* ldns_resolver_search(const ldns_resolver *r, const ldns_rdf *rdf, ldns_rr_type t, ldns_rr_class c, uint16_t flags); /** * Send the query for using the resolver and take the search list into account * The search algorithm is as follows: * If the name is absolute, try it as-is, otherwise apply the search list * \param[out] pkt a packet with the reply from the nameserver * \param[in] *r operate using this resolver * \param[in] *rdf query for this name * \param[in] t query for this type (may be 0, defaults to A) * \param[in] c query for this class (may be 0, default to IN) * \param[in] flags the query flags * * \return ldns_status LDNS_STATUS_OK on success */ ldns_status ldns_resolver_search_status(ldns_pkt** pkt, ldns_resolver *r, const ldns_rdf *rdf, ldns_rr_type t, ldns_rr_class c, uint16_t flags); /** * Form a query packet from a resolver and name/type/class combo * \param[out] **q a pointer to a ldns_pkt pointer (initialized by this function) * \param[in] *r operate using this resolver * \param[in] *name query for this name * \param[in] t query for this type (may be 0, defaults to A) * \param[in] c query for this class (may be 0, default to IN) * \param[in] f the query flags * * \return ldns_pkt* a packet with the reply from the nameserver */ ldns_status ldns_resolver_prepare_query_pkt(ldns_pkt **q, ldns_resolver *r, const ldns_rdf *name, ldns_rr_type t, ldns_rr_class c, uint16_t f); /** * Send the query for name as-is * \param[out] **answer a pointer to a ldns_pkt pointer (initialized by this function) * \param[in] *r operate using this resolver * \param[in] *name query for this name * \param[in] t query for this type (may be 0, defaults to A) * \param[in] c query for this class (may be 0, default to IN) * \param[in] flags the query flags * * \return ldns_pkt* a packet with the reply from the nameserver */ ldns_status ldns_resolver_send(ldns_pkt **answer, ldns_resolver *r, const ldns_rdf *name, ldns_rr_type t, ldns_rr_class c, uint16_t flags); /** * Send the given packet to a nameserver * \param[out] **answer a pointer to a ldns_pkt pointer (initialized by this function) * \param[in] *r operate using this resolver * \param[in] *query_pkt query */ ldns_status ldns_resolver_send_pkt(ldns_pkt **answer, ldns_resolver *r, ldns_pkt *query_pkt); /** * Send a query to a nameserver * \param[out] pkt a packet with the reply from the nameserver * \param[in] *r operate using this resolver * \param[in] *name query for this name * \param[in] *t query for this type (may be 0, defaults to A) * \param[in] *c query for this class (may be 0, default to IN) * \param[in] flags the query flags * * \return ldns_status LDNS_STATUS_OK on success * if _defnames is true the default domain will be added */ ldns_status ldns_resolver_query_status(ldns_pkt** pkt, ldns_resolver *r, const ldns_rdf *name, ldns_rr_type t, ldns_rr_class c, uint16_t flags); /** * Send a query to a nameserver * \param[in] *r operate using this resolver * (despite the const in the declaration, * the struct is altered as a side-effect) * \param[in] *name query for this name * \param[in] *t query for this type (may be 0, defaults to A) * \param[in] *c query for this class (may be 0, default to IN) * \param[in] flags the query flags * * \return ldns_pkt* a packet with the reply from the nameserver * if _defnames is true the default domain will be added */ ldns_pkt* ldns_resolver_query(const ldns_resolver *r, const ldns_rdf *name, ldns_rr_type t, ldns_rr_class c, uint16_t flags); /** * Create a new resolver structure * \return ldns_resolver* pointer to new strcture */ ldns_resolver* ldns_resolver_new(void); /** * Create a resolver structure from a file like /etc/resolv.conf * \param[out] r the new resolver * \param[in] fp file pointer to create new resolver from * if NULL use /etc/resolv.conf * \return LDNS_STATUS_OK or the error */ ldns_status ldns_resolver_new_frm_fp(ldns_resolver **r, FILE *fp); /** * Create a resolver structure from a file like /etc/resolv.conf * \param[out] r the new resolver * \param[in] fp file pointer to create new resolver from * if NULL use /etc/resolv.conf * \param[in] line_nr pointer to an integer containing the current line number (for debugging purposes) * \return LDNS_STATUS_OK or the error */ ldns_status ldns_resolver_new_frm_fp_l(ldns_resolver **r, FILE *fp, int *line_nr); /** * Configure a resolver by means of a resolv.conf file * The file may be NULL in which case there will be * looked the RESOLV_CONF (defaults to /etc/resolv.conf * \param[out] r the new resolver * \param[in] filename the filename to use * \return LDNS_STATUS_OK or the error */ ldns_status ldns_resolver_new_frm_file(ldns_resolver **r, const char *filename); /** * Frees the allocated space for this resolver. Only frees the resolver pionter! You should probably be using _deep_free. * \param res resolver to free */ void ldns_resolver_free(ldns_resolver *res); /** * Frees the allocated space for this resolver and all it's data * \param res resolver to free */ void ldns_resolver_deep_free(ldns_resolver *res); /** * Get the next stream of RRs in a AXFR * \param[in] resolver the resolver to use. First ldns_axfr_start() must be * called * \return ldns_rr the next RR from the AXFR stream * After you get this returned RR (not NULL: on error), then check if * ldns_axfr_complete() is true to see if the zone transfer has completed. */ ldns_rr* ldns_axfr_next(ldns_resolver *resolver); /** * Returns true if the axfr transfer has completed (i.e. 2 SOA RRs and no errors were encountered * \param[in] resolver the resolver that is used * \return bool true if axfr transfer was completed without error */ bool ldns_axfr_complete(const ldns_resolver *resolver); /** * Returns a pointer to the last ldns_pkt that was sent by the server in the AXFR transfer * uasable for instance to get the error code on failure * \param[in] res the resolver that was used in the axfr transfer * \return ldns_pkt the last packet sent */ ldns_pkt *ldns_axfr_last_pkt(const ldns_resolver *res); /** * Randomize the nameserver list in the resolver * \param[in] r the resolver */ void ldns_resolver_nameservers_randomize(ldns_resolver *r); /** * Returns true if at least one of the provided keys is a trust anchor * \param[in] r the current resolver * \param[in] keys the keyset to check * \param[out] trusted_keys the subset of trusted keys in the 'keys' rrset * \return true if at least one of the provided keys is a configured trust anchor */ bool ldns_resolver_trusted_key(const ldns_resolver *r, ldns_rr_list * keys, ldns_rr_list * trusted_keys); #ifdef __cplusplus } #endif #endif /* LDNS_RESOLVER_H */ ldns-1.6.17/ldns/sha1.h0000664000175100017510000000221512264060151014060 0ustar willemwillem#ifndef LDNS_SHA1_H #define LDNS_SHA1_H #ifdef __cplusplus extern "C" { #endif #define LDNS_SHA1_BLOCK_LENGTH 64 #define LDNS_SHA1_DIGEST_LENGTH 20 typedef struct { uint32_t state[5]; uint64_t count; unsigned char buffer[LDNS_SHA1_BLOCK_LENGTH]; } ldns_sha1_ctx; void ldns_sha1_init(ldns_sha1_ctx * context); void ldns_sha1_transform(uint32_t state[5], const unsigned char buffer[LDNS_SHA1_BLOCK_LENGTH]); void ldns_sha1_update(ldns_sha1_ctx *context, const unsigned char *data, unsigned int len); void ldns_sha1_final(unsigned char digest[LDNS_SHA1_DIGEST_LENGTH], ldns_sha1_ctx *context); /** * Convenience function to digest a fixed block of data at once. * * \param[in] data the data to digest * \param[in] data_len the length of data in bytes * \param[out] digest the length of data in bytes * This pointer MUST have LDNS_SHA1_DIGEST_LENGTH bytes * available * \return the SHA1 digest of the given data */ unsigned char *ldns_sha1(unsigned char *data, unsigned int data_len, unsigned char *digest); #ifdef __cplusplus } #endif #endif /* LDNS_SHA1_H */ ldns-1.6.17/ldns/dnssec.h0000664000175100017510000004134412264060151014511 0ustar willemwillem/* * dnssec.h -- defines for the Domain Name System (SEC) (DNSSEC) * * Copyright (c) 2005-2008, NLnet Labs. All rights reserved. * * See LICENSE for the license. * * A bunch of defines that are used in the DNS */ /** * \file dnssec.h * * This module contains base functions for DNSSEC operations * (RFC4033 t/m RFC4035). * * Since those functions heavily rely op cryptographic operations, * this module is dependent on openssl. * */ #ifndef LDNS_DNSSEC_H #define LDNS_DNSSEC_H #include #if LDNS_BUILD_CONFIG_HAVE_SSL #include #include #endif /* LDNS_BUILD_CONFIG_HAVE_SSL */ #include #include #include #include #include #ifdef __cplusplus extern "C" { #endif #define LDNS_MAX_KEYLEN 2048 #define LDNS_DNSSEC_KEYPROTO 3 /* default time before sigs expire */ #define LDNS_DEFAULT_EXP_TIME 2419200 /* 4 weeks */ /** return values for the old-signature callback */ #define LDNS_SIGNATURE_LEAVE_ADD_NEW 0 #define LDNS_SIGNATURE_LEAVE_NO_ADD 1 #define LDNS_SIGNATURE_REMOVE_ADD_NEW 2 #define LDNS_SIGNATURE_REMOVE_NO_ADD 3 /** * Returns the first RRSIG rr that corresponds to the rrset * with the given name and type * * \param[in] name The dname of the RRset covered by the RRSIG to find * \param[in] type The type of the RRset covered by the RRSIG to find * \param[in] rrs List of rrs to search in * \returns Pointer to the first RRsig ldns_rr found, or NULL if it is * not present */ ldns_rr *ldns_dnssec_get_rrsig_for_name_and_type(const ldns_rdf *name, const ldns_rr_type type, const ldns_rr_list *rrs); /** * Returns the DNSKEY that corresponds to the given RRSIG rr from the list, if * any * * \param[in] rrsig The rrsig to find the DNSKEY for * \param[in] rrs The rr list to find the key in * \return The DNSKEY that corresponds to the given RRSIG, or NULL if it was * not found. */ ldns_rr *ldns_dnssec_get_dnskey_for_rrsig(const ldns_rr *rrsig, const ldns_rr_list *rrs); /** * Returns the rdata field that contains the bitmap of the covered types of * the given NSEC record * * \param[in] nsec The nsec to get the covered type bitmap of * \return An ldns_rdf containing the bitmap, or NULL on error */ ldns_rdf *ldns_nsec_get_bitmap(ldns_rr *nsec); #define LDNS_NSEC3_MAX_ITERATIONS 65535 /** * Returns the dname of the closest (provable) encloser */ ldns_rdf * ldns_dnssec_nsec3_closest_encloser(ldns_rdf *qname, ldns_rr_type qtype, ldns_rr_list *nsec3s); /** * Checks whether the packet contains rrsigs */ bool ldns_dnssec_pkt_has_rrsigs(const ldns_pkt *pkt); /** * Returns a ldns_rr_list containing the signatures covering the given name * and type */ ldns_rr_list *ldns_dnssec_pkt_get_rrsigs_for_name_and_type(const ldns_pkt *pkt, ldns_rdf *name, ldns_rr_type type); /** * Returns a ldns_rr_list containing the signatures covering the given type */ ldns_rr_list *ldns_dnssec_pkt_get_rrsigs_for_type(const ldns_pkt *pkt, ldns_rr_type type); /** * calculates a keytag of a key for use in DNSSEC. * * \param[in] key the key as an RR to use for the calc. * \return the keytag */ uint16_t ldns_calc_keytag(const ldns_rr *key); /** * Calculates keytag of DNSSEC key, operates on wireformat rdata. * \param[in] key the key as uncompressed wireformat rdata. * \param[in] keysize length of key data. * \return the keytag */ uint16_t ldns_calc_keytag_raw(uint8_t* key, size_t keysize); #if LDNS_BUILD_CONFIG_HAVE_SSL /** * converts a buffer holding key material to a DSA key in openssl. * * \param[in] key the key to convert * \return a DSA * structure with the key material */ DSA *ldns_key_buf2dsa(ldns_buffer *key); /** * Like ldns_key_buf2dsa, but uses raw buffer. * \param[in] key the uncompressed wireformat of the key. * \param[in] len length of key data * \return a DSA * structure with the key material */ DSA *ldns_key_buf2dsa_raw(unsigned char* key, size_t len); /** * Utility function to calculate hash using generic EVP_MD pointer. * \param[in] data the data to hash. * \param[in] len length of data. * \param[out] dest the destination of the hash, must be large enough. * \param[in] md the message digest to use. * \return true if worked, false on failure. */ int ldns_digest_evp(unsigned char* data, unsigned int len, unsigned char* dest, const EVP_MD* md); /** * Converts a holding buffer with key material to EVP PKEY in openssl. * Only available if ldns was compiled with GOST. * \param[in] key data to convert * \param[in] keylen length of the key data * \return the key or NULL on error. */ EVP_PKEY* ldns_gost2pkey_raw(unsigned char* key, size_t keylen); /** * Converts a holding buffer with key material to EVP PKEY in openssl. * Only available if ldns was compiled with ECDSA. * \param[in] key data to convert * \param[in] keylen length of the key data * \param[in] algo precise algorithm to initialize ECC group values. * \return the key or NULL on error. */ EVP_PKEY* ldns_ecdsa2pkey_raw(unsigned char* key, size_t keylen, uint8_t algo); #endif /* LDNS_BUILD_CONFIG_HAVE_SSL */ #if LDNS_BUILD_CONFIG_HAVE_SSL /** * converts a buffer holding key material to a RSA key in openssl. * * \param[in] key the key to convert * \return a RSA * structure with the key material */ RSA *ldns_key_buf2rsa(ldns_buffer *key); /** * Like ldns_key_buf2rsa, but uses raw buffer. * \param[in] key the uncompressed wireformat of the key. * \param[in] len length of key data * \return a RSA * structure with the key material */ RSA *ldns_key_buf2rsa_raw(unsigned char* key, size_t len); #endif /* LDNS_BUILD_CONFIG_HAVE_SSL */ /** * returns a new DS rr that represents the given key rr. * * \param[in] *key the key to convert * \param[in] h the hash to use LDNS_SHA1/LDNS_SHA256 * * \return ldns_rr* a new rr pointer to a DS */ ldns_rr *ldns_key_rr2ds(const ldns_rr *key, ldns_hash h); /** * Create the type bitmap for an NSEC(3) record */ ldns_rdf * ldns_dnssec_create_nsec_bitmap(ldns_rr_type rr_type_list[], size_t size, ldns_rr_type nsec_type); /** * returns whether a rrset of the given type is found in the rrsets. * * \param[in] rrsets the rrsets to be tested * \param[in] type the type to test for * \return int 1 if the type was found, 0 otherwise. */ int ldns_dnssec_rrsets_contains_type (ldns_dnssec_rrsets *rrsets, ldns_rr_type type); /** * Creates NSEC */ ldns_rr * ldns_dnssec_create_nsec(ldns_dnssec_name *from, ldns_dnssec_name *to, ldns_rr_type nsec_type); /** * Creates NSEC3 */ ldns_rr * ldns_dnssec_create_nsec3(ldns_dnssec_name *from, ldns_dnssec_name *to, ldns_rdf *zone_name, uint8_t algorithm, uint8_t flags, uint16_t iterations, uint8_t salt_length, uint8_t *salt); /** * Create a NSEC record * \param[in] cur_owner the current owner which should be taken as the starting point * \param[in] next_owner the rrlist which the nsec rr should point to * \param[in] rrs all rrs from the zone, to find all RR types of cur_owner in * \return a ldns_rr with the nsec record in it */ ldns_rr * ldns_create_nsec(ldns_rdf *cur_owner, ldns_rdf *next_owner, ldns_rr_list *rrs); /** * Calculates the hashed name using the given parameters * \param[in] *name The owner name to calculate the hash for * \param[in] algorithm The hash algorithm to use * \param[in] iterations The number of hash iterations to use * \param[in] salt_length The length of the salt in bytes * \param[in] salt The salt to use * \return The hashed owner name rdf, without the domain name */ ldns_rdf *ldns_nsec3_hash_name(ldns_rdf *name, uint8_t algorithm, uint16_t iterations, uint8_t salt_length, uint8_t *salt); /** * Sets all the NSEC3 options. The rr to set them in must be initialized with _new() and * type LDNS_RR_TYPE_NSEC3 * \param[in] *rr The RR to set the values in * \param[in] algorithm The NSEC3 hash algorithm * \param[in] flags The flags field * \param[in] iterations The number of hash iterations * \param[in] salt_length The length of the salt in bytes * \param[in] salt The salt bytes */ void ldns_nsec3_add_param_rdfs(ldns_rr *rr, uint8_t algorithm, uint8_t flags, uint16_t iterations, uint8_t salt_length, uint8_t *salt); /* this will NOT return the NSEC3 completed, you will have to run the finalize function on the rrlist later! */ ldns_rr * ldns_create_nsec3(ldns_rdf *cur_owner, ldns_rdf *cur_zone, ldns_rr_list *rrs, uint8_t algorithm, uint8_t flags, uint16_t iterations, uint8_t salt_length, uint8_t *salt, bool emptynonterminal); /** * Returns the hash algorithm used in the given NSEC3 RR * \param[in] *nsec3_rr The RR to read from * \return The algorithm identifier, or 0 on error */ uint8_t ldns_nsec3_algorithm(const ldns_rr *nsec3_rr); /** * Returns flags field */ uint8_t ldns_nsec3_flags(const ldns_rr *nsec3_rr); /** * Returns true if the opt-out flag has been set in the given NSEC3 RR * \param[in] *nsec3_rr The RR to read from * \return true if the RR has type NSEC3 and the opt-out bit has been set, false otherwise */ bool ldns_nsec3_optout(const ldns_rr *nsec3_rr); /** * Returns the number of hash iterations used in the given NSEC3 RR * \param[in] *nsec3_rr The RR to read from * \return The number of iterations */ uint16_t ldns_nsec3_iterations(const ldns_rr *nsec3_rr); /** * Returns the salt used in the given NSEC3 RR * \param[in] *nsec3_rr The RR to read from * \return The salt rdf, or NULL on error */ ldns_rdf *ldns_nsec3_salt(const ldns_rr *nsec3_rr); /** * Returns the length of the salt used in the given NSEC3 RR * \param[in] *nsec3_rr The RR to read from * \return The length of the salt in bytes */ uint8_t ldns_nsec3_salt_length(const ldns_rr *nsec3_rr); /** * Returns the salt bytes used in the given NSEC3 RR * \param[in] *nsec3_rr The RR to read from * \return The salt in bytes, this is alloced, so you need to free it */ uint8_t *ldns_nsec3_salt_data(const ldns_rr *nsec3_rr); /** * Returns the first label of the next ownername in the NSEC3 chain (ie. without the domain) * \param[in] nsec3_rr The RR to read from * \return The first label of the next owner name in the NSEC3 chain, or NULL on error */ ldns_rdf *ldns_nsec3_next_owner(const ldns_rr *nsec3_rr); /** * Returns the bitmap specifying the covered types of the given NSEC3 RR * \param[in] *nsec3_rr The RR to read from * \return The covered type bitmap rdf */ ldns_rdf *ldns_nsec3_bitmap(const ldns_rr *nsec3_rr); /** * Calculates the hashed name using the parameters of the given NSEC3 RR * \param[in] *nsec The RR to use the parameters from * \param[in] *name The owner name to calculate the hash for * \return The hashed owner name rdf, without the domain name */ ldns_rdf *ldns_nsec3_hash_name_frm_nsec3(const ldns_rr *nsec, ldns_rdf *name); /** * Check if RR type t is enumerated and set in the RR type bitmap rdf. * \param[in] bitmap the RR type bitmap rdf to look in * \param[in] type the type to check for * \return true when t is found and set, otherwise return false */ bool ldns_nsec_bitmap_covers_type(const ldns_rdf* bitmap, ldns_rr_type type); /** * Checks if RR type t is enumerated in the type bitmap rdf and sets the bit. * \param[in] bitmap the RR type bitmap rdf to look in * \param[in] type the type to for which the bit to set * \return LDNS_STATUS_OK on success. LDNS_STATUS_TYPE_NOT_IN_BITMAP is * returned when the bitmap does not contain the bit to set. */ ldns_status ldns_nsec_bitmap_set_type(ldns_rdf* bitmap, ldns_rr_type type); /** * Checks if RR type t is enumerated in the type bitmap rdf and clears the bit. * \param[in] bitmap the RR type bitmap rdf to look in * \param[in] type the type to for which the bit to clear * \return LDNS_STATUS_OK on success. LDNS_STATUS_TYPE_NOT_IN_BITMAP is * returned when the bitmap does not contain the bit to clear. */ ldns_status ldns_nsec_bitmap_clear_type(ldns_rdf* bitmap, ldns_rr_type type); /** * Checks coverage of NSEC(3) RR name span * Remember that nsec and name must both be in canonical form (ie use * \ref ldns_rr2canonical and \ref ldns_dname2canonical prior to calling this * function) * * \param[in] nsec The NSEC RR to check * \param[in] name The owner dname to check, if the nsec record is a NSEC3 record, this should be the hashed name * \return true if the NSEC RR covers the owner name */ bool ldns_nsec_covers_name(const ldns_rr *nsec, const ldns_rdf *name); #if LDNS_BUILD_CONFIG_HAVE_SSL /** * verify a packet * \param[in] p the packet * \param[in] t the rr set type to check * \param[in] o the rr set name to check * \param[in] k list of keys * \param[in] s list of sigs (may be null) * \param[out] good_keys keys which validated the packet * \return status * */ ldns_status ldns_pkt_verify(ldns_pkt *p, ldns_rr_type t, ldns_rdf *o, ldns_rr_list *k, ldns_rr_list *s, ldns_rr_list *good_keys); /** * verify a packet * \param[in] p the packet * \param[in] t the rr set type to check * \param[in] o the rr set name to check * \param[in] k list of keys * \param[in] s list of sigs (may be null) * \param[in] check_time the time for which the validation is performed * \param[out] good_keys keys which validated the packet * \return status * */ ldns_status ldns_pkt_verify_time(ldns_pkt *p, ldns_rr_type t, ldns_rdf *o, ldns_rr_list *k, ldns_rr_list *s, time_t check_time, ldns_rr_list *good_keys); #endif /** * chains nsec3 list */ ldns_status ldns_dnssec_chain_nsec3_list(ldns_rr_list *nsec3_rrs); /** * compare for nsec3 sort */ int qsort_rr_compare_nsec3(const void *a, const void *b); /** * sort nsec3 list */ void ldns_rr_list_sort_nsec3(ldns_rr_list *unsorted); /** * Default callback function to always leave present signatures, and * add new ones * \param[in] sig The signature to check for removal (unused) * \param[in] n Optional argument (unused) * \return LDNS_SIGNATURE_LEAVE_ADD_NEW */ int ldns_dnssec_default_add_to_signatures(ldns_rr *sig, void *n); /** * Default callback function to always leave present signatures, and * add no new ones for the keys of these signatures * \param[in] sig The signature to check for removal (unused) * \param[in] n Optional argument (unused) * \return LDNS_SIGNATURE_LEAVE_NO_ADD */ int ldns_dnssec_default_leave_signatures(ldns_rr *sig, void *n); /** * Default callback function to always remove present signatures, but * add no new ones * \param[in] sig The signature to check for removal (unused) * \param[in] n Optional argument (unused) * \return LDNS_SIGNATURE_REMOVE_NO_ADD */ int ldns_dnssec_default_delete_signatures(ldns_rr *sig, void *n); /** * Default callback function to always leave present signatures, and * add new ones * \param[in] sig The signature to check for removal (unused) * \param[in] n Optional argument (unused) * \return LDNS_SIGNATURE_REMOVE_ADD_NEW */ int ldns_dnssec_default_replace_signatures(ldns_rr *sig, void *n); #if LDNS_BUILD_CONFIG_HAVE_SSL /** * Converts the DSA signature from ASN1 representation (RFC2459, as * used by OpenSSL) to raw signature data as used in DNS (rfc2536) * * \param[in] sig The signature in RFC2459 format * \param[in] sig_len The length of the signature * \return a new rdf with the signature */ ldns_rdf * ldns_convert_dsa_rrsig_asn12rdf(const ldns_buffer *sig, const long sig_len); /** * Converts the RRSIG signature RDF (in rfc2536 format) to a buffer * with the signature in rfc2459 format * * \param[out] target_buffer buffer to place the signature data * \param[in] sig_rdf The signature rdf to convert * \return LDNS_STATUS_OK on success, error code otherwise */ ldns_status ldns_convert_dsa_rrsig_rdf2asn1(ldns_buffer *target_buffer, const ldns_rdf *sig_rdf); /** * Converts the ECDSA signature from ASN1 representation (as * used by OpenSSL) to raw signature data as used in DNS * This routine is only present if ldns is compiled with ecdsa support. * * \param[in] sig The signature in ASN1 format * \param[in] sig_len The length of the signature * \return a new rdf with the signature */ ldns_rdf * ldns_convert_ecdsa_rrsig_asn12rdf(const ldns_buffer *sig, const long sig_len); /** * Converts the RRSIG signature RDF (from DNS) to a buffer with the * signature in ASN1 format as openssl uses it. * This routine is only present if ldns is compiled with ecdsa support. * * \param[out] target_buffer buffer to place the signature data in ASN1. * \param[in] sig_rdf The signature rdf to convert * \return LDNS_STATUS_OK on success, error code otherwise */ ldns_status ldns_convert_ecdsa_rrsig_rdf2asn1(ldns_buffer *target_buffer, const ldns_rdf *sig_rdf); #endif /* LDNS_BUILD_CONFIG_HAVE_SSL */ #ifdef __cplusplus } #endif #endif /* LDNS_DNSSEC_H */ ldns-1.6.17/ldns/common.h.in0000664000175100017510000000454112264060151015125 0ustar willemwillem/** * \file common.h * * Common definitions for LDNS */ /** * a Net::DNS like library for C * * (c) NLnet Labs, 2004-2006 * * See the file LICENSE for the license */ #ifndef LDNS_COMMON_H #define LDNS_COMMON_H /* * The build configuration that is used in the distributed headers, * as detected and determined by the auto configure script. */ #define LDNS_BUILD_CONFIG_HAVE_SSL @ldns_build_config_have_ssl@ #define LDNS_BUILD_CONFIG_HAVE_INTTYPES_H @ldns_build_config_have_inttypes_h@ #define LDNS_BUILD_CONFIG_HAVE_ATTR_FORMAT @ldns_build_config_have_attr_format@ #define LDNS_BUILD_CONFIG_HAVE_ATTR_UNUSED @ldns_build_config_have_attr_unused@ #define LDNS_BUILD_CONFIG_HAVE_SOCKLEN_T @ldns_build_config_have_socklen_t@ #define LDNS_BUILD_CONFIG_USE_DANE @ldns_build_config_use_dane@ #define LDNS_BUILD_CONFIG_HAVE_B32_PTON @ldns_build_config_have_b32_pton@ #define LDNS_BUILD_CONFIG_HAVE_B32_NTOP @ldns_build_config_have_b32_ntop@ /* * HAVE_STDBOOL_H is not available when distributed as a library, but no build * configuration variables may be used (like those above) because the header * is sometimes only available when using special compiler flags to enable the * c99 environment. Because we cannot force the usage of this flag, we have to * provide a default type. Below what is suggested by the autoconf manual. */ /*@ignore@*/ /* splint barfs on this construct */ #ifdef HAVE_STDBOOL_H # include #else # ifndef HAVE__BOOL # ifdef __cplusplus typedef bool _Bool; # else # define _Bool signed char # endif # endif # define bool _Bool # define false 0 # define true 1 # define __bool_true_false_are_defined 1 #endif /*@end@*/ #if LDNS_BUILD_CONFIG_HAVE_ATTR_FORMAT #define ATTR_FORMAT(archetype, string_index, first_to_check) \ __attribute__ ((format (archetype, string_index, first_to_check))) #else /* !LDNS_BUILD_CONFIG_HAVE_ATTR_FORMAT */ #define ATTR_FORMAT(archetype, string_index, first_to_check) /* empty */ #endif /* !LDNS_BUILD_CONFIG_HAVE_ATTR_FORMAT */ #if defined(__cplusplus) #define ATTR_UNUSED(x) #elif LDNS_BUILD_CONFIG_HAVE_ATTR_UNUSED #define ATTR_UNUSED(x) x __attribute__((unused)) #else /* !LDNS_BUILD_CONFIG_HAVE_ATTR_UNUSED */ #define ATTR_UNUSED(x) x #endif /* !LDNS_BUILD_CONFIG_HAVE_ATTR_UNUSED */ #if !LDNS_BUILD_CONFIG_HAVE_SOCKLEN_T typedef int socklen_t; #endif #endif /* LDNS_COMMON_H */ ldns-1.6.17/ldns/radix.h0000664000175100017510000001416712264060151014344 0ustar willemwillem/* * radix.h -- generic radix tree * * Copyright (c) 2012, NLnet Labs. All rights reserved. * * This software is open source. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * Redistributions of source code must retain the above copyright notice, * this list of conditions and the following disclaimer. * * Redistributions in binary form must reproduce the above copyright notice, * this list of conditions and the following disclaimer in the documentation * and/or other materials provided with the distribution. * * Neither the name of the NLNET LABS nor the names of its contributors may * be used to endorse or promote products derived from this software without * specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. * */ /** * \file * Radix tree. Implementation taken from NSD 4, adjusted for use in ldns. * */ #ifndef LDNS_RADIX_H_ #define LDNS_RADIX_H_ #include #ifdef __cplusplus extern "C" { #endif typedef uint16_t radix_strlen_t; typedef struct ldns_radix_array_t ldns_radix_array_t; typedef struct ldns_radix_node_t ldns_radix_node_t; typedef struct ldns_radix_t ldns_radix_t; /** Radix node select edge array */ struct ldns_radix_array_t { /** Additional string after the selection byte for this edge. */ uint8_t* str; /** Length of additional string for this edge. */ radix_strlen_t len; /** Node that deals with byte+str. */ ldns_radix_node_t* edge; }; /** A node in a radix tree */ struct ldns_radix_node_t { /** Key corresponding to this node. */ uint8_t* key; /** Key length corresponding to this node. */ radix_strlen_t klen; /** Data corresponding to this node. */ void* data; /** Parent node. */ ldns_radix_node_t* parent; /** Index in the the parent node select edge array. */ uint8_t parent_index; /** Length of the array. */ uint16_t len; /** Offset of the array. */ uint16_t offset; /** Capacity of the array. */ uint16_t capacity; /** Select edge array. */ ldns_radix_array_t* array; }; /** An entire radix tree */ struct ldns_radix_t { /** Root. */ ldns_radix_node_t* root; /** Number of nodes in tree. */ size_t count; }; /** * Create a new radix tree. * @return: new radix tree. * */ ldns_radix_t* ldns_radix_create(void); /** * Initialize radix tree. * @param tree: uninitialized radix tree. * */ void ldns_radix_init(ldns_radix_t* tree); /** * Free the radix tree. * @param tree: radix tree. * */ void ldns_radix_free(ldns_radix_t* tree); /** * Insert data into the tree. * @param tree: tree to insert to. * @param key: key. * @param len: length of key. * @param data: data. * @return: status. * */ ldns_status ldns_radix_insert(ldns_radix_t* tree, uint8_t* key, radix_strlen_t len, void* data); /** * Delete data from the tree. * @param tree: tree to insert to. * @param key: key. * @param len: length of key. * @return: unlinked data or NULL if not present. * */ void* ldns_radix_delete(ldns_radix_t* tree, uint8_t* key, radix_strlen_t len); /** * Search data in the tree. * @param tree: tree to insert to. * @param key: key. * @param len: length of key. * @return: the radix node or NULL if not found. * */ ldns_radix_node_t* ldns_radix_search(ldns_radix_t* tree, uint8_t* key, radix_strlen_t len); /** * Search data in the tree, and if not found, find the closest smaller * element in the tree. * @param tree: tree to insert to. * @param key: key. * @param len: length of key. * @param result: the radix node with the exact or closest match. NULL if * the key is smaller than the smallest key in the tree. * @return 1 if exact match, 0 otherwise. * */ int ldns_radix_find_less_equal(ldns_radix_t* tree, uint8_t* key, radix_strlen_t len, ldns_radix_node_t** result); /** * Get the first element in the tree. * @param tree: tree. * @return: the radix node with the first element. * */ ldns_radix_node_t* ldns_radix_first(ldns_radix_t* tree); /** * Get the last element in the tree. * @param tree: tree. * @return: the radix node with the last element. * */ ldns_radix_node_t* ldns_radix_last(ldns_radix_t* tree); /** * Next element. * @param node: node. * @return: node with next element. * */ ldns_radix_node_t* ldns_radix_next(ldns_radix_node_t* node); /** * Previous element. * @param node: node. * @return: node with previous element. * */ ldns_radix_node_t* ldns_radix_prev(ldns_radix_node_t* node); /** * Split radix tree intwo. * @param tree1: one tree. * @param num: number of elements to split off. * @param tree2: another tree. * @return: status. * */ ldns_status ldns_radix_split(ldns_radix_t* tree1, size_t num, ldns_radix_t** tree2); /** * Join two radix trees. * @param tree1: one tree. * @param tree2: another tree. * @return: status. * */ ldns_status ldns_radix_join(ldns_radix_t* tree1, ldns_radix_t* tree2); /** * Call function for all nodes in the tree, such that leaf nodes are * called before parent nodes. * @param node: start node. * @param func: function. * @param arg: user argument. * */ void ldns_radix_traverse_postorder(ldns_radix_node_t* node, void (*func)(ldns_radix_node_t*, void*), void* arg); /** * Print radix tree (for debugging purposes). * @param fd: file descriptor. * @param tree: tree. * */ void ldns_radix_printf(FILE* fd, ldns_radix_t* tree); #ifdef __cplusplus } #endif #endif /* LDNS_RADIX_H_ */ ldns-1.6.17/ldns/tsig.h0000664000175100017510000000732412264060151014200 0ustar willemwillem/* * tsig.h -- defines for TSIG [RFC2845] * * Copyright (c) 2005-2008, NLnet Labs. All rights reserved. * * See LICENSE for the license. */ #ifndef LDNS_TSIG_H #define LDNS_TSIG_H #ifdef __cplusplus extern "C" { #endif /** * \file * * Defines functions for TSIG usage */ /** * Contains credentials for TSIG */ typedef struct ldns_tsig_credentials_struct { char *algorithm; char *keyname; char *keydata; /* XXX More eventually. */ } ldns_tsig_credentials; char *ldns_tsig_algorithm(ldns_tsig_credentials *); char *ldns_tsig_keyname(ldns_tsig_credentials *); char *ldns_tsig_keydata(ldns_tsig_credentials *); char *ldns_tsig_keyname_clone(ldns_tsig_credentials *); char *ldns_tsig_keydata_clone(ldns_tsig_credentials *); /** * verifies the tsig rr for the given packet and key. * The wire must be given too because tsig does not sign normalized packets. * \param[in] pkt the packet to verify * \param[in] wire needed to verify the mac * \param[in] wire_size size of wire * \param[in] key_name the name of the shared key * \param[in] key_data the key in base 64 format * \param[in] mac original mac * \return true if tsig is correct, false if not, or if tsig is not set */ bool ldns_pkt_tsig_verify(ldns_pkt *pkt, uint8_t *wire, size_t wire_size, const char *key_name, const char *key_data, ldns_rdf *mac); /** * verifies the tsig rr for the given packet and key. * The wire must be given too because tsig does not sign normalized packets. * \param[in] pkt the packet to verify * \param[in] wire needed to verify the mac * \param[in] wire_size size of wire * \param[in] key_name the name of the shared key * \param[in] key_data the key in base 64 format * \param[in] mac original mac * \param[in] tsig_timers_only must be zero for the first packet and positive for subsequent packets. If zero, all digest components are used to verify the _mac. If non-zero, only the TSIG timers are used to verify the mac. * \return true if tsig is correct, false if not, or if tsig is not set */ bool ldns_pkt_tsig_verify_next(ldns_pkt *pkt, uint8_t *wire, size_t wire_size, const char *key_name, const char *key_data, ldns_rdf *mac, int tsig_timers_only); /** * creates a tsig rr for the given packet and key. * \param[in] pkt the packet to sign * \param[in] key_name the name of the shared key * \param[in] key_data the key in base 64 format * \param[in] fudge seconds of error permitted in time signed * \param[in] algorithm_name the name of the algorithm used * \param[in] query_mac is added to the digest if not NULL (so NULL is for signing queries, not NULL is for signing answers) * \return status (OK if success) */ ldns_status ldns_pkt_tsig_sign(ldns_pkt *pkt, const char *key_name, const char *key_data, uint16_t fudge, const char *algorithm_name, ldns_rdf *query_mac); /** * creates a tsig rr for the given packet and key. * \param[in] pkt the packet to sign * \param[in] key_name the name of the shared key * \param[in] key_data the key in base 64 format * \param[in] fudge seconds of error permitted in time signed * \param[in] algorithm_name the name of the algorithm used * \param[in] query_mac is added to the digest if not NULL (so NULL is for signing queries, not NULL is for signing answers) * \param[in] tsig_timers_only must be zero for the first packet and positive for subsequent packets. If zero, all digest components are used to create the query_mac. If non-zero, only the TSIG timers are used to create the query_mac. * \return status (OK if success) */ ldns_status ldns_pkt_tsig_sign_next(ldns_pkt *pkt, const char *key_name, const char *key_data, uint16_t fudge, const char *algorithm_name, ldns_rdf *query_mac, int tsig_timers_only); #ifdef __cplusplus } #endif #endif /* LDNS_TSIG_H */ ldns-1.6.17/ldns/host2str.h0000664000175100017510000007543412264060151015031 0ustar willemwillem/** * host2str.h - txt presentation of RRs * * a Net::DNS like library for C * * (c) NLnet Labs, 2005-2006 * * See the file LICENSE for the license */ /** * \file * * Contains functions to translate the main structures to their text * representation, as well as functions to print them. */ #ifndef LDNS_HOST2STR_H #define LDNS_HOST2STR_H #include #include #include #include #include #include #include #include #include #include "ldns/util.h" #ifdef __cplusplus extern "C" { #endif #define LDNS_APL_IP4 1 #define LDNS_APL_IP6 2 #define LDNS_APL_MASK 0x7f #define LDNS_APL_NEGATION 0x80 /** * Represent a NULL pointer (instead of a pointer to a ldns_rr as "; (null)" * as opposed to outputting nothing at all in such a case. */ /* Flag Name Flag Nr. Has data associated ---------------------------------------------------------------------*/ #define LDNS_COMMENT_NULLS (1 << 0) /** Show key id with DNSKEY RR's as comment */ #define LDNS_COMMENT_KEY_ID (1 << 1) /** Show if a DNSKEY is a ZSK or KSK as comment */ #define LDNS_COMMENT_KEY_TYPE (1 << 2) /** Show DNSKEY key size as comment */ #define LDNS_COMMENT_KEY_SIZE (1 << 3) /** Provide bubblebabble representation for DS RR's as comment */ #define LDNS_COMMENT_BUBBLEBABBLE (1 << 4) /** Show when a NSEC3 RR has the optout flag set as comment */ #define LDNS_COMMENT_FLAGS (1 << 5) /** Show the unhashed owner and next owner names for NSEC3 RR's as comment */ #define LDNS_COMMENT_NSEC3_CHAIN (1 << 6) /* yes */ /** Print mark up */ #define LDNS_COMMENT_LAYOUT (1 << 7) /** Also comment KEY_ID with RRSIGS **/ #define LDNS_COMMENT_RRSIGS (1 << 8) #define LDNS_FMT_ZEROIZE_RRSIGS (1 << 9) #define LDNS_FMT_PAD_SOA_SERIAL (1 << 10) #define LDNS_FMT_RFC3597 (1 << 11) /* yes */ #define LDNS_FMT_FLAGS_WITH_DATA 2 /** Show key id, type and size as comment for DNSKEY RR's */ #define LDNS_COMMENT_KEY (LDNS_COMMENT_KEY_ID \ |LDNS_COMMENT_KEY_TYPE\ |LDNS_COMMENT_KEY_SIZE) /** * Output format specifier * * Determines how Packets, Resource Records and Resource record data fiels are * formatted when printing or converting to string. * Currently it is only used to specify what aspects of a Resource Record are * annotated in the comment section of the textual representation the record. * This is speciefed with flags and potential exra data (such as for example * a lookup map of hashes to real names for annotation NSEC3 records). */ struct ldns_struct_output_format { /** Specification of how RR's should be formatted in text */ int flags; /** Potential extra data to be used with formatting RR's in text */ void *data; }; typedef struct ldns_struct_output_format ldns_output_format; /** * Output format struct with additional data for flags that use them. * This struct may not be initialized directly. Use ldns_output_format_init * to initialize. */ struct ldns_struct_output_format_storage { int flags; ldns_rbtree_t* hashmap; /* for LDNS_COMMENT_NSEC3_CHAIN */ ldns_rdf* bitmap; /* for LDNS_FMT_RFC3597 */ }; typedef struct ldns_struct_output_format_storage ldns_output_format_storage; /** * Standard output format record that disables commenting in the textual * representation of Resource Records completely. */ extern const ldns_output_format *ldns_output_format_nocomments; /** * Standard output format record that annotated only DNSKEY RR's with commenti * text. */ extern const ldns_output_format *ldns_output_format_onlykeyids; /** * The default output format record. Same as ldns_output_format_onlykeyids. */ extern const ldns_output_format *ldns_output_format_default; /** * Standard output format record that shows all DNSKEY related information in * the comment text, plus the optout flag when set with NSEC3's, plus the * bubblebabble representation of DS RR's. */ extern const ldns_output_format *ldns_output_format_bubblebabble; /** * Initialize output format storage to the default value. * \param[in] fmt A reference to an output_format_ storage struct * \return The initialized storage struct typecasted to ldns_output_format */ INLINE ldns_output_format* ldns_output_format_init(ldns_output_format_storage* fmt) { fmt->flags = ldns_output_format_default->flags; fmt->hashmap = NULL; fmt->bitmap = NULL; return (ldns_output_format*)fmt; } /** * Set an ouput format flag. */ INLINE void ldns_output_format_set(ldns_output_format* fmt, int flag) { fmt->flags |= flag; } /** * Clear an ouput format flag. */ INLINE void ldns_output_format_clear(ldns_output_format* fmt, int flag) { fmt->flags &= !flag; } /** * Makes sure the LDNS_FMT_RFC3597 is set in the output format. * Marks the type to be printed in RFC3597 format. * /param[in] fmt the output format to update * /param[in] the type to be printed in RFC3597 format * /return LDNS_STATUS_OK on success */ ldns_status ldns_output_format_set_type(ldns_output_format* fmt, ldns_rr_type type); /** * Makes sure the LDNS_FMT_RFC3597 is set in the output format. * Marks the type to not be printed in RFC3597 format. When no other types * have been marked before, all known types (except the given one) will be * marked for printing in RFC3597 format. * /param[in] fmt the output format to update * /param[in] the type not to be printed in RFC3597 format * /return LDNS_STATUS_OK on success */ ldns_status ldns_output_format_clear_type(ldns_output_format* fmt, ldns_rr_type type); /** * Converts an ldns packet opcode value to its mnemonic, and adds that * to the output buffer * \param[in] *output the buffer to add the data to * \param[in] opcode to find the string representation of * \return LDNS_STATUS_OK on success, or a buffer failure mode on error */ ldns_status ldns_pkt_opcode2buffer_str(ldns_buffer *output, ldns_pkt_opcode opcode); /** * Converts an ldns packet rcode value to its mnemonic, and adds that * to the output buffer * \param[in] *output the buffer to add the data to * \param[in] rcode to find the string representation of * \return LDNS_STATUS_OK on success, or a buffer failure mode on error */ ldns_status ldns_pkt_rcode2buffer_str(ldns_buffer *output, ldns_pkt_rcode rcode); /** * Converts an ldns algorithm type to its mnemonic, and adds that * to the output buffer * \param[in] *output the buffer to add the data to * \param[in] algorithm to find the string representation of * \return LDNS_STATUS_OK on success, or a buffer failure mode on error */ ldns_status ldns_algorithm2buffer_str(ldns_buffer *output, ldns_algorithm algorithm); /** * Converts an ldns certificate algorithm type to its mnemonic, * and adds that to the output buffer * \param[in] *output the buffer to add the data to * \param[in] cert_algorithm to find the string representation of * \return LDNS_STATUS_OK on success, or a buffer failure mode on error */ ldns_status ldns_cert_algorithm2buffer_str(ldns_buffer *output, ldns_cert_algorithm cert_algorithm); /** * Converts a packet opcode to its mnemonic and returns that as * an allocated null-terminated string. * Remember to free it. * * \param[in] opcode the opcode to convert to text * \return null terminated char * data, or NULL on error */ char *ldns_pkt_opcode2str(ldns_pkt_opcode opcode); /** * Converts a packet rcode to its mnemonic and returns that as * an allocated null-terminated string. * Remember to free it. * * \param[in] rcode the rcode to convert to text * \return null terminated char * data, or NULL on error */ char *ldns_pkt_rcode2str(ldns_pkt_rcode rcode); /** * Converts a signing algorithms to its mnemonic and returns that as * an allocated null-terminated string. * Remember to free it. * * \param[in] algorithm the algorithm to convert to text * \return null terminated char * data, or NULL on error */ char *ldns_pkt_algorithm2str(ldns_algorithm algorithm); /** * Converts a cert algorithm to its mnemonic and returns that as * an allocated null-terminated string. * Remember to free it. * * \param[in] cert_algorithm to convert to text * \return null terminated char * data, or NULL on error */ char *ldns_pkt_cert_algorithm2str(ldns_cert_algorithm cert_algorithm); /** * Converts an LDNS_RDF_TYPE_A rdata element to string format and adds it to the output buffer * \param[in] *rdf The rdata to convert * \param[in] *output The buffer to add the data to * \return LDNS_STATUS_OK on success, and error status on failure */ ldns_status ldns_rdf2buffer_str_a(ldns_buffer *output, const ldns_rdf *rdf); /** * Converts an LDNS_RDF_TYPE_AAAA rdata element to string format and adds it to the output buffer * \param[in] *rdf The rdata to convert * \param[in] *output The buffer to add the data to * \return LDNS_STATUS_OK on success, and error status on failure */ ldns_status ldns_rdf2buffer_str_aaaa(ldns_buffer *output, const ldns_rdf *rdf); /** * Converts an LDNS_RDF_TYPE_STR rdata element to string format and adds it to the output buffer * \param[in] *rdf The rdata to convert * \param[in] *output The buffer to add the data to * \return LDNS_STATUS_OK on success, and error status on failure */ ldns_status ldns_rdf2buffer_str_str(ldns_buffer *output, const ldns_rdf *rdf); /** * Converts an LDNS_RDF_TYPE_B64 rdata element to string format and adds it to the output buffer * \param[in] *rdf The rdata to convert * \param[in] *output The buffer to add the data to * \return LDNS_STATUS_OK on success, and error status on failure */ ldns_status ldns_rdf2buffer_str_b64(ldns_buffer *output, const ldns_rdf *rdf); /** * Converts an LDNS_RDF_TYPE_B32_EXT rdata element to string format and adds it to the output buffer * \param[in] *rdf The rdata to convert * \param[in] *output The buffer to add the data to * \return LDNS_STATUS_OK on success, and error status on failure */ ldns_status ldns_rdf2buffer_str_b32_ext(ldns_buffer *output, const ldns_rdf *rdf); /** * Converts an LDNS_RDF_TYPE_HEX rdata element to string format and adds it to the output buffer * \param[in] *rdf The rdata to convert * \param[in] *output The buffer to add the data to * \return LDNS_STATUS_OK on success, and error status on failure */ ldns_status ldns_rdf2buffer_str_hex(ldns_buffer *output, const ldns_rdf *rdf); /** * Converts an LDNS_RDF_TYPE_TYPE rdata element to string format and adds it to the output buffer * \param[in] *rdf The rdata to convert * \param[in] *output The buffer to add the data to * \return LDNS_STATUS_OK on success, and error status on failure */ ldns_status ldns_rdf2buffer_str_type(ldns_buffer *output, const ldns_rdf *rdf); /** * Converts an LDNS_RDF_TYPE_CLASS rdata element to string format and adds it to the output buffer * \param[in] *rdf The rdata to convert * \param[in] *output The buffer to add the data to * \return LDNS_STATUS_OK on success, and error status on failure */ ldns_status ldns_rdf2buffer_str_class(ldns_buffer *output, const ldns_rdf *rdf); /** * Converts an LDNS_RDF_TYPE_ALG rdata element to string format and adds it to the output buffer * \param[in] *rdf The rdata to convert * \param[in] *output The buffer to add the data to * \return LDNS_STATUS_OK on success, and error status on failure */ ldns_status ldns_rdf2buffer_str_alg(ldns_buffer *output, const ldns_rdf *rdf); /** * Converts an ldns_rr_type value to its string representation, * and places it in the given buffer * \param[in] *output The buffer to add the data to * \param[in] type the ldns_rr_type to convert * \return LDNS_STATUS_OK on success, and error status on failure */ ldns_status ldns_rr_type2buffer_str(ldns_buffer *output, const ldns_rr_type type); /** * Converts an ldns_rr_type value to its string representation, * and returns that string. For unknown types, the string * "TYPE" is returned. This function allocates data that must be * freed by the caller * \param[in] type the ldns_rr_type to convert * \return a newly allocated string */ char *ldns_rr_type2str(const ldns_rr_type type); /** * Converts an ldns_rr_class value to its string representation, * and places it in the given buffer * \param[in] *output The buffer to add the data to * \param[in] klass the ldns_rr_class to convert * \return LDNS_STATUS_OK on success, and error status on failure */ ldns_status ldns_rr_class2buffer_str(ldns_buffer *output, const ldns_rr_class klass); /** * Converts an ldns_rr_class value to its string representation, * and returns that string. For unknown types, the string * "CLASS" is returned. This function allocates data that must be * freed by the caller * \param[in] klass the ldns_rr_class to convert * \return a newly allocated string */ char *ldns_rr_class2str(const ldns_rr_class klass); /** * Converts an LDNS_RDF_TYPE_CERT rdata element to string format and adds it to the output buffer * \param[in] *rdf The rdata to convert * \param[in] *output The buffer to add the data to * \return LDNS_STATUS_OK on success, and error status on failure */ ldns_status ldns_rdf2buffer_str_cert_alg(ldns_buffer *output, const ldns_rdf *rdf); /** * Converts an LDNS_RDF_TYPE_LOC rdata element to string format and adds it to the output buffer * \param[in] *rdf The rdata to convert * \param[in] *output The buffer to add the data to * \return LDNS_STATUS_OK on success, and error status on failure */ ldns_status ldns_rdf2buffer_str_loc(ldns_buffer *output, const ldns_rdf *rdf); /** * Converts an LDNS_RDF_TYPE_UNKNOWN rdata element to string format and adds it to the output buffer * \param[in] *rdf The rdata to convert * \param[in] *output The buffer to add the data to * \return LDNS_STATUS_OK on success, and error status on failure */ ldns_status ldns_rdf2buffer_str_unknown(ldns_buffer *output, const ldns_rdf *rdf); /** * Converts an LDNS_RDF_TYPE_NSAP rdata element to string format and adds it to the output buffer * \param[in] *rdf The rdata to convert * \param[in] *output The buffer to add the data to * \return LDNS_STATUS_OK on success, and error status on failure */ ldns_status ldns_rdf2buffer_str_nsap(ldns_buffer *output, const ldns_rdf *rdf); /** * Converts an LDNS_RDF_TYPE_ATMA rdata element to string format and adds it to the output buffer * \param[in] *rdf The rdata to convert * \param[in] *output The buffer to add the data to * \return LDNS_STATUS_OK on success, and error status on failure */ ldns_status ldns_rdf2buffer_str_atma(ldns_buffer *output, const ldns_rdf *rdf); /** * Converts an LDNS_RDF_TYPE_WKS rdata element to string format and adds it to the output buffer * \param[in] *rdf The rdata to convert * \param[in] *output The buffer to add the data to * \return LDNS_STATUS_OK on success, and error status on failure */ ldns_status ldns_rdf2buffer_str_wks(ldns_buffer *output, const ldns_rdf *rdf); /** * Converts an LDNS_RDF_TYPE_NSEC rdata element to string format and adds it to the output buffer * \param[in] *rdf The rdata to convert * \param[in] *output The buffer to add the data to * \return LDNS_STATUS_OK on success, and error status on failure */ ldns_status ldns_rdf2buffer_str_nsec(ldns_buffer *output, const ldns_rdf *rdf); /** * Converts an LDNS_RDF_TYPE_PERIOD rdata element to string format and adds it to the output buffer * \param[in] *rdf The rdata to convert * \param[in] *output The buffer to add the data to * \return LDNS_STATUS_OK on success, and error status on failure */ ldns_status ldns_rdf2buffer_str_period(ldns_buffer *output, const ldns_rdf *rdf); /** * Converts an LDNS_RDF_TYPE_TSIGTIME rdata element to string format and adds it to the output buffer * \param[in] *rdf The rdata to convert * \param[in] *output The buffer to add the data to * \return LDNS_STATUS_OK on success, and error status on failure */ ldns_status ldns_rdf2buffer_str_tsigtime(ldns_buffer *output, const ldns_rdf *rdf); /** * Converts an LDNS_RDF_TYPE_APL rdata element to string format and adds it to the output buffer * \param[in] *rdf The rdata to convert * \param[in] *output The buffer to add the data to * \return LDNS_STATUS_OK on success, and error status on failure */ ldns_status ldns_rdf2buffer_str_apl(ldns_buffer *output, const ldns_rdf *rdf); /** * Converts an LDNS_RDF_TYPE_INT16_DATA rdata element to string format and adds it to the output buffer * \param[in] *rdf The rdata to convert * \param[in] *output The buffer to add the data to * \return LDNS_STATUS_OK on success, and error status on failure */ ldns_status ldns_rdf2buffer_str_int16_data(ldns_buffer *output, const ldns_rdf *rdf); /** * Converts an LDNS_RDF_TYPE_IPSECKEY rdata element to string format and adds it to the output buffer * \param[in] *rdf The rdata to convert * \param[in] *output The buffer to add the data to * \return LDNS_STATUS_OK on success, and error status on failure */ ldns_status ldns_rdf2buffer_str_ipseckey(ldns_buffer *output, const ldns_rdf *rdf); /** * Converts the data in the rdata field to presentation * format (as char *) and appends it to the given buffer * * \param[in] output pointer to the buffer to append the data to * \param[in] rdf the pointer to the rdafa field containing the data * \return status */ ldns_status ldns_rdf2buffer_str(ldns_buffer *output, const ldns_rdf *rdf); /** * Converts the data in the resource record to presentation * format (as char *) and appends it to the given buffer. * The presentation format of DNSKEY record is annotated with comments giving * the id, type and size of the key. * * \param[in] output pointer to the buffer to append the data to * \param[in] rr the pointer to the rr field to convert * \return status */ ldns_status ldns_rr2buffer_str(ldns_buffer *output, const ldns_rr *rr); /** * Converts the data in the resource record to presentation * format (as char *) and appends it to the given buffer. * The presentation format is annotated with comments giving * additional information on the record. * * \param[in] output pointer to the buffer to append the data to * \param[in] fmt how to format the textual representation of the * resource record. * \param[in] rr the pointer to the rr field to convert * \return status */ ldns_status ldns_rr2buffer_str_fmt(ldns_buffer *output, const ldns_output_format *fmt, const ldns_rr *rr); /** * Converts the data in the DNS packet to presentation * format (as char *) and appends it to the given buffer * * \param[in] output pointer to the buffer to append the data to * \param[in] pkt the pointer to the packet to convert * \return status */ ldns_status ldns_pkt2buffer_str(ldns_buffer *output, const ldns_pkt *pkt); /** * Converts the data in the DNS packet to presentation * format (as char *) and appends it to the given buffer * * \param[in] output pointer to the buffer to append the data to * \param[in] fmt how to format the textual representation of the packet * \param[in] pkt the pointer to the packet to convert * \return status */ ldns_status ldns_pkt2buffer_str_fmt(ldns_buffer *output, const ldns_output_format *fmt, const ldns_pkt *pkt); /** * Converts an LDNS_RDF_TYPE_NSEC3_SALT rdata element to string format and adds it to the output buffer * \param[in] *rdf The rdata to convert * \param[in] *output The buffer to add the data to * \return LDNS_STATUS_OK on success, and error status on failure */ ldns_status ldns_rdf2buffer_str_nsec3_salt(ldns_buffer *output, const ldns_rdf *rdf); /** * Converts the data in the DNS packet to presentation * format (as char *) and appends it to the given buffer * * \param[in] output pointer to the buffer to append the data to * \param[in] k the pointer to the private key to convert * \return status */ ldns_status ldns_key2buffer_str(ldns_buffer *output, const ldns_key *k); /** * Converts an LDNS_RDF_TYPE_INT8 rdata element to string format and adds it to the output buffer * \param[in] *rdf The rdata to convert * \param[in] *output The buffer to add the data to * \return LDNS_STATUS_OK on success, and error status on failure */ ldns_status ldns_rdf2buffer_str_int8(ldns_buffer *output, const ldns_rdf *rdf); /** * Converts an LDNS_RDF_TYPE_INT16 rdata element to string format and adds it to the output buffer * \param[in] *rdf The rdata to convert * \param[in] *output The buffer to add the data to * \return LDNS_STATUS_OK on success, and error status on failure */ ldns_status ldns_rdf2buffer_str_int16(ldns_buffer *output, const ldns_rdf *rdf); /** * Converts an LDNS_RDF_TYPE_INT32 rdata element to string format and adds it to the output buffer * \param[in] *rdf The rdata to convert * \param[in] *output The buffer to add the data to * \return LDNS_STATUS_OK on success, and error status on failure */ ldns_status ldns_rdf2buffer_str_int32(ldns_buffer *output, const ldns_rdf *rdf); /** * Converts an LDNS_RDF_TYPE_TIME rdata element to string format and adds it to the output buffer * \param[in] *rdf The rdata to convert * \param[in] *output The buffer to add the data to * \return LDNS_STATUS_OK on success, and error status on failure */ ldns_status ldns_rdf2buffer_str_time(ldns_buffer *output, const ldns_rdf *rdf); /** * Converts an LDNS_RDF_TYPE_ILNP64 rdata element to 4 hexadecimal numbers * separated by colons and adds it to the output buffer * \param[in] *rdf The rdata to convert * \param[in] *output The buffer to add the data to * \return LDNS_STATUS_OK on success, and error status on failure */ ldns_status ldns_rdf2buffer_str_ilnp64(ldns_buffer *output, const ldns_rdf *rdf); /** * Converts an LDNS_RDF_TYPE_EUI48 rdata element to 6 hexadecimal numbers * separated by dashes and adds it to the output buffer * \param[in] *rdf The rdata to convert * \param[in] *output The buffer to add the data to * \return LDNS_STATUS_OK on success, and error status on failure */ ldns_status ldns_rdf2buffer_str_eui48(ldns_buffer *output, const ldns_rdf *rdf); /** * Converts an LDNS_RDF_TYPE_EUI64 rdata element to 8 hexadecimal numbers * separated by dashes and adds it to the output buffer * \param[in] *rdf The rdata to convert * \param[in] *output The buffer to add the data to * \return LDNS_STATUS_OK on success, and error status on failure */ ldns_status ldns_rdf2buffer_str_eui64(ldns_buffer *output, const ldns_rdf *rdf); /** * Adds the LDNS_RDF_TYPE_TAG rdata to the output buffer, * provided it contains only alphanumeric characters. * \param[in] *rdf The rdata to convert * \param[in] *output The buffer to add the data to * \return LDNS_STATUS_OK on success, and error status on failure */ ldns_status ldns_rdf2buffer_str_tag(ldns_buffer *output, const ldns_rdf *rdf); /** * Adds the LDNS_RDF_TYPE_LONG_STR rdata to the output buffer, in-between * double quotes and all non printable characters properly escaped. * \param[in] *rdf The rdata to convert * \param[in] *output The buffer to add the data to * \return LDNS_STATUS_OK on success, and error status on failure */ ldns_status ldns_rdf2buffer_str_long_str(ldns_buffer *output, const ldns_rdf *rdf); /** * Converts an LDNS_RDF_TYPE_HIP rdata element to presentation format for * the algorithm, HIT and Public Key and adds it the output buffer . * \param[in] *rdf The rdata to convert * \param[in] *output The buffer to add the data to * \return LDNS_STATUS_OK on success, and error status on failure */ ldns_status ldns_rdf2buffer_str_hip(ldns_buffer *output, const ldns_rdf *rdf); /** * Converts the data in the rdata field to presentation format and * returns that as a char *. * Remember to free it. * * \param[in] rdf The rdata field to convert * \return null terminated char * data, or NULL on error */ char *ldns_rdf2str(const ldns_rdf *rdf); /** * Converts the data in the resource record to presentation format and * returns that as a char *. * Remember to free it. * * \param[in] rr The rdata field to convert * \return null terminated char * data, or NULL on error */ char *ldns_rr2str(const ldns_rr *rr); /** * Converts the data in the resource record to presentation format and * returns that as a char *. * Remember to free it. * * \param[in] fmt how to format the resource record * \param[in] rr The rdata field to convert * \return null terminated char * data, or NULL on error */ char *ldns_rr2str_fmt(const ldns_output_format *fmt, const ldns_rr *rr); /** * Converts the data in the DNS packet to presentation format and * returns that as a char *. * Remember to free it. * * \param[in] pkt The rdata field to convert * \return null terminated char * data, or NULL on error */ char *ldns_pkt2str(const ldns_pkt *pkt); /** * Converts the data in the DNS packet to presentation format and * returns that as a char *. * Remember to free it. * * \param[in] fmt how to format the packet * \param[in] pkt The rdata field to convert * \return null terminated char * data, or NULL on error */ char *ldns_pkt2str_fmt(const ldns_output_format *fmt, const ldns_pkt *pkt); /** * Converts a private key to the test presentation fmt and * returns that as a char *. * Remember to free it. * * \param[in] k the key to convert to text * \return null terminated char * data, or NULL on error */ char *ldns_key2str(const ldns_key *k); /** * Converts a list of resource records to presentation format * and returns that as a char *. * Remember to free it. * * \param[in] rr_list the rr_list to convert to text * \return null terminated char * data, or NULL on error */ char *ldns_rr_list2str(const ldns_rr_list *rr_list); /** * Converts a list of resource records to presentation format * and returns that as a char *. * Remember to free it. * * \param[in] fmt how to format the list of resource records * \param[in] rr_list the rr_list to convert to text * \return null terminated char * data, or NULL on error */ char *ldns_rr_list2str_fmt( const ldns_output_format *fmt, const ldns_rr_list *rr_list); /** * Returns a copy of the data in the buffer as a null terminated * char * string. The returned string must be freed by the caller. * The buffer must be in write modus and may thus not have been flipped. * * \param[in] buffer buffer containing char * data * \return null terminated char * data, or NULL on error */ char *ldns_buffer2str(ldns_buffer *buffer); /** * Exports and returns the data in the buffer as a null terminated * char * string. The returned string must be freed by the caller. * The buffer must be in write modus and may thus not have been flipped. * The buffer is fixed after this function returns. * * \param[in] buffer buffer containing char * data * \return null terminated char * data, or NULL on error */ char *ldns_buffer_export2str(ldns_buffer *buffer); /** * Prints the data in the rdata field to the given file stream * (in presentation format) * * \param[in] output the file stream to print to * \param[in] rdf the rdata field to print * \return void */ void ldns_rdf_print(FILE *output, const ldns_rdf *rdf); /** * Prints the data in the resource record to the given file stream * (in presentation format) * * \param[in] output the file stream to print to * \param[in] rr the resource record to print * \return void */ void ldns_rr_print(FILE *output, const ldns_rr *rr); /** * Prints the data in the resource record to the given file stream * (in presentation format) * * \param[in] output the file stream to print to * \param[in] fmt format of the textual representation * \param[in] rr the resource record to print * \return void */ void ldns_rr_print_fmt(FILE *output, const ldns_output_format *fmt, const ldns_rr *rr); /** * Prints the data in the DNS packet to the given file stream * (in presentation format) * * \param[in] output the file stream to print to * \param[in] pkt the packet to print * \return void */ void ldns_pkt_print(FILE *output, const ldns_pkt *pkt); /** * Prints the data in the DNS packet to the given file stream * (in presentation format) * * \param[in] output the file stream to print to * \param[in] fmt format of the textual representation * \param[in] pkt the packet to print * \return void */ void ldns_pkt_print_fmt(FILE *output, const ldns_output_format *fmt, const ldns_pkt *pkt); /** * Converts a rr_list to presentation format and appends it to * the output buffer * \param[in] output the buffer to append output to * \param[in] list the ldns_rr_list to print * \return ldns_status */ ldns_status ldns_rr_list2buffer_str(ldns_buffer *output, const ldns_rr_list *list); /** * Converts a rr_list to presentation format and appends it to * the output buffer * \param[in] output the buffer to append output to * \param[in] fmt format of the textual representation * \param[in] list the ldns_rr_list to print * \return ldns_status */ ldns_status ldns_rr_list2buffer_str_fmt(ldns_buffer *output, const ldns_output_format *fmt, const ldns_rr_list *list); /** * Converts the header of a packet to presentation format and appends it to * the output buffer * \param[in] output the buffer to append output to * \param[in] pkt the packet to convert the header of * \return ldns_status */ ldns_status ldns_pktheader2buffer_str(ldns_buffer *output, const ldns_pkt *pkt); /** * print a rr_list to output * \param[in] output the fd to print to * \param[in] list the rr_list to print */ void ldns_rr_list_print(FILE *output, const ldns_rr_list *list); /** * print a rr_list to output * \param[in] output the fd to print to * \param[in] fmt format of the textual representation * \param[in] list the rr_list to print */ void ldns_rr_list_print_fmt(FILE *output, const ldns_output_format *fmt, const ldns_rr_list *list); /** * Print a resolver (in sofar that is possible) state * to output. * \param[in] output the fd to print to * \param[in] r the resolver to print */ void ldns_resolver_print(FILE *output, const ldns_resolver *r); /** * Print a resolver (in sofar that is possible) state * to output. * \param[in] output the fd to print to * \param[in] fmt format of the textual representation * \param[in] r the resolver to print */ void ldns_resolver_print_fmt(FILE *output, const ldns_output_format *fmt, const ldns_resolver *r); /** * Print a zone structure * to output. Note the SOA record * is included in this output * \param[in] output the fd to print to * \param[in] z the zone to print */ void ldns_zone_print(FILE *output, const ldns_zone *z); /** * Print a zone structure * to output. Note the SOA record * is included in this output * \param[in] output the fd to print to * \param[in] fmt format of the textual representation * \param[in] z the zone to print */ void ldns_zone_print_fmt(FILE *output, const ldns_output_format *fmt, const ldns_zone *z); /** * Print the ldns_rdf containing a dname to the buffer * \param[in] output the buffer to print to * \param[in] dname the dname to print * \return ldns_status message if the printing succeeded */ ldns_status ldns_rdf2buffer_str_dname(ldns_buffer *output, const ldns_rdf *dname); #ifdef __cplusplus } #endif #endif /* LDNS_HOST2STR_H */ ldns-1.6.17/ldns/update.h0000664000175100017510000000524512264060151014514 0ustar willemwillem/* * update.h * * Functions for RFC 2136 Dynamic Update * * Copyright (c) 2005-2008, NLnet Labs. All rights reserved. * * See LICENSE for the license. */ /** * \file * * Defines functions to perform UPDATE queries */ #ifndef LDNS_UPDATE_H #define LDNS_UPDATE_H #include #ifdef __cplusplus extern "C" { #endif /** * create an update packet from zone name, class and the rr lists * \param[in] zone_rdf name of the zone * \param[in] clas zone class * \param[in] pr_rrlist list of Prerequisite Section RRs * \param[in] up_rrlist list of Updates Section RRs * \param[in] ad_rrlist list of Additional Data Section RRs (currently unused) * \return the new packet */ ldns_pkt *ldns_update_pkt_new(ldns_rdf *zone_rdf, ldns_rr_class clas, ldns_rr_list *pr_rrlist, ldns_rr_list *up_rrlist, ldns_rr_list *ad_rrlist); /** * add tsig credentials to * a packet from a resolver * \param[in] p packet to copy to * \param[in] r resolver to copy from * * \return status wether successfull or not */ ldns_status ldns_update_pkt_tsig_add(ldns_pkt *p, ldns_resolver *r); /* access functions */ /** * Get the zo count * \param[in] p the packet * \return the zo count */ uint16_t ldns_update_zocount(const ldns_pkt *p); /** * Get the zo count * \param[in] p the packet * \return the pr count */ uint16_t ldns_update_prcount(const ldns_pkt *p); /** * Get the zo count * \param[in] p the packet * \return the up count */ uint16_t ldns_update_upcount(const ldns_pkt *p); /** * Get the zo count * \param[in] p the packet * \return the ad count */ uint16_t ldns_update_ad(const ldns_pkt *p); /** * Set the zo count * \param[in] p the packet * \param[in] c the zo count to set */ void ldns_update_set_zo(ldns_pkt *p, uint16_t c); /** * Set the pr count * \param[in] p the packet * \param[in] c the pr count to set */ void ldns_update_set_prcount(ldns_pkt *p, uint16_t c); /** * Set the up count * \param[in] p the packet * \param[in] c the up count to set */ void ldns_update_set_upcount(ldns_pkt *p, uint16_t c); /** * Set the ad count * \param[in] p the packet * \param[in] c the ad count to set */ void ldns_update_set_adcount(ldns_pkt *p, uint16_t c); /* soa functions that need to be configured */ /* * Not sure if we want to keep these like this, therefore * not documented */ ldns_status ldns_update_soa_mname(ldns_rdf *zone, ldns_resolver *r, ldns_rr_class c, ldns_rdf **mname); /* * Not sure if we want to keep these like this, therefore * not documented */ ldns_status ldns_update_soa_zone_mname(const char *fqdn, ldns_resolver *r, ldns_rr_class c, ldns_rdf **zone_rdf, ldns_rdf **mname_rdf); #ifdef __cplusplus } #endif #endif /* LDNS_UPDATE_H */ ldns-1.6.17/ldns/error.h0000664000175100017510000001000312264060151014347 0ustar willemwillem/** * \file error.h * * Defines error numbers and functions to translate those to a readable string. * */ /** * a Net::DNS like library for C * * (c) NLnet Labs, 2005-2006 * * See the file LICENSE for the license */ #ifndef LDNS_ERROR_H #define LDNS_ERROR_H #include #ifdef __cplusplus extern "C" { #endif enum ldns_enum_status { LDNS_STATUS_OK, LDNS_STATUS_EMPTY_LABEL, LDNS_STATUS_LABEL_OVERFLOW, LDNS_STATUS_DOMAINNAME_OVERFLOW, LDNS_STATUS_DOMAINNAME_UNDERFLOW, LDNS_STATUS_DDD_OVERFLOW, LDNS_STATUS_PACKET_OVERFLOW, LDNS_STATUS_INVALID_POINTER, LDNS_STATUS_MEM_ERR, LDNS_STATUS_INTERNAL_ERR, LDNS_STATUS_SSL_ERR, LDNS_STATUS_ERR, LDNS_STATUS_INVALID_INT, LDNS_STATUS_INVALID_IP4, LDNS_STATUS_INVALID_IP6, LDNS_STATUS_INVALID_STR, LDNS_STATUS_INVALID_B32_EXT, LDNS_STATUS_INVALID_B64, LDNS_STATUS_INVALID_HEX, LDNS_STATUS_INVALID_TIME, LDNS_STATUS_NETWORK_ERR, LDNS_STATUS_ADDRESS_ERR, LDNS_STATUS_FILE_ERR, LDNS_STATUS_UNKNOWN_INET, LDNS_STATUS_NOT_IMPL, LDNS_STATUS_NULL, LDNS_STATUS_CRYPTO_UNKNOWN_ALGO, LDNS_STATUS_CRYPTO_ALGO_NOT_IMPL, LDNS_STATUS_CRYPTO_NO_RRSIG, LDNS_STATUS_CRYPTO_NO_DNSKEY, LDNS_STATUS_CRYPTO_NO_TRUSTED_DNSKEY, LDNS_STATUS_CRYPTO_NO_DS, LDNS_STATUS_CRYPTO_NO_TRUSTED_DS, LDNS_STATUS_CRYPTO_NO_MATCHING_KEYTAG_DNSKEY, LDNS_STATUS_CRYPTO_VALIDATED, LDNS_STATUS_CRYPTO_BOGUS, LDNS_STATUS_CRYPTO_SIG_EXPIRED, LDNS_STATUS_CRYPTO_SIG_NOT_INCEPTED, LDNS_STATUS_CRYPTO_TSIG_BOGUS, LDNS_STATUS_CRYPTO_TSIG_ERR, LDNS_STATUS_CRYPTO_EXPIRATION_BEFORE_INCEPTION, LDNS_STATUS_CRYPTO_TYPE_COVERED_ERR, LDNS_STATUS_ENGINE_KEY_NOT_LOADED, LDNS_STATUS_NSEC3_ERR, LDNS_STATUS_RES_NO_NS, LDNS_STATUS_RES_QUERY, LDNS_STATUS_WIRE_INCOMPLETE_HEADER, LDNS_STATUS_WIRE_INCOMPLETE_QUESTION, LDNS_STATUS_WIRE_INCOMPLETE_ANSWER, LDNS_STATUS_WIRE_INCOMPLETE_AUTHORITY, LDNS_STATUS_WIRE_INCOMPLETE_ADDITIONAL, LDNS_STATUS_NO_DATA, LDNS_STATUS_CERT_BAD_ALGORITHM, LDNS_STATUS_SYNTAX_TYPE_ERR, LDNS_STATUS_SYNTAX_CLASS_ERR, LDNS_STATUS_SYNTAX_TTL_ERR, LDNS_STATUS_SYNTAX_INCLUDE_ERR_NOTIMPL, LDNS_STATUS_SYNTAX_RDATA_ERR, LDNS_STATUS_SYNTAX_DNAME_ERR, LDNS_STATUS_SYNTAX_VERSION_ERR, LDNS_STATUS_SYNTAX_ALG_ERR, LDNS_STATUS_SYNTAX_KEYWORD_ERR, LDNS_STATUS_SYNTAX_TTL, LDNS_STATUS_SYNTAX_ORIGIN, LDNS_STATUS_SYNTAX_INCLUDE, LDNS_STATUS_SYNTAX_EMPTY, LDNS_STATUS_SYNTAX_ITERATIONS_OVERFLOW, LDNS_STATUS_SYNTAX_MISSING_VALUE_ERR, LDNS_STATUS_SYNTAX_INTEGER_OVERFLOW, LDNS_STATUS_SYNTAX_BAD_ESCAPE, LDNS_STATUS_SOCKET_ERROR, LDNS_STATUS_SYNTAX_ERR, LDNS_STATUS_DNSSEC_EXISTENCE_DENIED, LDNS_STATUS_DNSSEC_NSEC_RR_NOT_COVERED, LDNS_STATUS_DNSSEC_NSEC_WILDCARD_NOT_COVERED, LDNS_STATUS_DNSSEC_NSEC3_ORIGINAL_NOT_FOUND, LDNS_STATUS_MISSING_RDATA_FIELDS_RRSIG, LDNS_STATUS_MISSING_RDATA_FIELDS_KEY, LDNS_STATUS_CRYPTO_SIG_EXPIRED_WITHIN_MARGIN, LDNS_STATUS_CRYPTO_SIG_NOT_INCEPTED_WITHIN_MARGIN, LDNS_STATUS_DANE_STATUS_MESSAGES, LDNS_STATUS_DANE_UNKNOWN_CERTIFICATE_USAGE, LDNS_STATUS_DANE_UNKNOWN_SELECTOR, LDNS_STATUS_DANE_UNKNOWN_MATCHING_TYPE, LDNS_STATUS_DANE_UNKNOWN_PROTOCOL, LDNS_STATUS_DANE_UNKNOWN_TRANSPORT, LDNS_STATUS_DANE_MISSING_EXTRA_CERTS, LDNS_STATUS_DANE_EXTRA_CERTS_NOT_USED, LDNS_STATUS_DANE_OFFSET_OUT_OF_RANGE, LDNS_STATUS_DANE_INSECURE, LDNS_STATUS_DANE_BOGUS, LDNS_STATUS_DANE_TLSA_DID_NOT_MATCH, LDNS_STATUS_DANE_NON_CA_CERTIFICATE, LDNS_STATUS_DANE_PKIX_DID_NOT_VALIDATE, LDNS_STATUS_DANE_PKIX_NO_SELF_SIGNED_TRUST_ANCHOR, LDNS_STATUS_EXISTS_ERR, LDNS_STATUS_INVALID_ILNP64, LDNS_STATUS_INVALID_EUI48, LDNS_STATUS_INVALID_EUI64, LDNS_STATUS_WIRE_RDATA_ERR, LDNS_STATUS_INVALID_TAG, LDNS_STATUS_TYPE_NOT_IN_BITMAP, LDNS_STATUS_INVALID_RDF_TYPE, LDNS_STATUS_RDATA_OVERFLOW, }; typedef enum ldns_enum_status ldns_status; extern ldns_lookup_table ldns_error_str[]; /** * look up a descriptive text by each error. This function * could use a better name * \param[in] err ldns_status number * \return the string for that error */ const char *ldns_get_errorstr_by_id(ldns_status err); #ifdef __cplusplus } #endif #endif /* LDNS_ERROR_H */ ldns-1.6.17/util.c0000664000175100017510000004322612264060151013243 0ustar willemwillem/* * util.c * * some general memory functions * * a Net::DNS like library for C * * (c) NLnet Labs, 2004-2006 * * See the file LICENSE for the license */ #include #include #include #include #include #include #include #include #include #include #ifdef HAVE_SSL #include #endif ldns_lookup_table * ldns_lookup_by_name(ldns_lookup_table *table, const char *name) { while (table->name != NULL) { if (strcasecmp(name, table->name) == 0) return table; table++; } return NULL; } ldns_lookup_table * ldns_lookup_by_id(ldns_lookup_table *table, int id) { while (table->name != NULL) { if (table->id == id) return table; table++; } return NULL; } int ldns_get_bit(uint8_t bits[], size_t index) { /* * The bits are counted from left to right, so bit #0 is the * left most bit. */ return (int) (bits[index / 8] & (1 << (7 - index % 8))); } int ldns_get_bit_r(uint8_t bits[], size_t index) { /* * The bits are counted from right to left, so bit #0 is the * right most bit. */ return (int) bits[index / 8] & (1 << (index % 8)); } void ldns_set_bit(uint8_t *byte, int bit_nr, bool value) { /* * The bits are counted from right to left, so bit #0 is the * right most bit. */ if (bit_nr >= 0 && bit_nr < 8) { if (value) { *byte = *byte | (0x01 << bit_nr); } else { *byte = *byte & ~(0x01 << bit_nr); } } } int ldns_hexdigit_to_int(char ch) { switch (ch) { case '0': return 0; case '1': return 1; case '2': return 2; case '3': return 3; case '4': return 4; case '5': return 5; case '6': return 6; case '7': return 7; case '8': return 8; case '9': return 9; case 'a': case 'A': return 10; case 'b': case 'B': return 11; case 'c': case 'C': return 12; case 'd': case 'D': return 13; case 'e': case 'E': return 14; case 'f': case 'F': return 15; default: return -1; } } char ldns_int_to_hexdigit(int i) { switch (i) { case 0: return '0'; case 1: return '1'; case 2: return '2'; case 3: return '3'; case 4: return '4'; case 5: return '5'; case 6: return '6'; case 7: return '7'; case 8: return '8'; case 9: return '9'; case 10: return 'a'; case 11: return 'b'; case 12: return 'c'; case 13: return 'd'; case 14: return 'e'; case 15: return 'f'; default: abort(); } } int ldns_hexstring_to_data(uint8_t *data, const char *str) { size_t i; if (!str || !data) { return -1; } if (strlen(str) % 2 != 0) { return -2; } for (i = 0; i < strlen(str) / 2; i++) { data[i] = 16 * (uint8_t) ldns_hexdigit_to_int(str[i*2]) + (uint8_t) ldns_hexdigit_to_int(str[i*2 + 1]); } return (int) i; } const char * ldns_version(void) { return (char*)LDNS_VERSION; } /* Number of days per month (except for February in leap years). */ static const int mdays[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }; #define LDNS_MOD(x,y) (((x) % (y) < 0) ? ((x) % (y) + (y)) : ((x) % (y))) #define LDNS_DIV(x,y) (((x) % (y) < 0) ? ((x) / (y) - 1 ) : ((x) / (y))) static int is_leap_year(int year) { return LDNS_MOD(year, 4) == 0 && (LDNS_MOD(year, 100) != 0 || LDNS_MOD(year, 400) == 0); } static int leap_days(int y1, int y2) { --y1; --y2; return (LDNS_DIV(y2, 4) - LDNS_DIV(y1, 4)) - (LDNS_DIV(y2, 100) - LDNS_DIV(y1, 100)) + (LDNS_DIV(y2, 400) - LDNS_DIV(y1, 400)); } /* * Code adapted from Python 2.4.1 sources (Lib/calendar.py). */ time_t ldns_mktime_from_utc(const struct tm *tm) { int year = 1900 + tm->tm_year; time_t days = 365 * ((time_t) year - 1970) + leap_days(1970, year); time_t hours; time_t minutes; time_t seconds; int i; for (i = 0; i < tm->tm_mon; ++i) { days += mdays[i]; } if (tm->tm_mon > 1 && is_leap_year(year)) { ++days; } days += tm->tm_mday - 1; hours = days * 24 + tm->tm_hour; minutes = hours * 60 + tm->tm_min; seconds = minutes * 60 + tm->tm_sec; return seconds; } time_t mktime_from_utc(const struct tm *tm) { return ldns_mktime_from_utc(tm); } #if SIZEOF_TIME_T <= 4 static void ldns_year_and_yday_from_days_since_epoch(int64_t days, struct tm *result) { int year = 1970; int new_year; while (days < 0 || days >= (int64_t) (is_leap_year(year) ? 366 : 365)) { new_year = year + (int) LDNS_DIV(days, 365); days -= (new_year - year) * 365; days -= leap_days(year, new_year); year = new_year; } result->tm_year = year; result->tm_yday = (int) days; } /* Number of days per month in a leap year. */ static const int leap_year_mdays[] = { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }; static void ldns_mon_and_mday_from_year_and_yday(struct tm *result) { int idays = result->tm_yday; const int *mon_lengths = is_leap_year(result->tm_year) ? leap_year_mdays : mdays; result->tm_mon = 0; while (idays >= mon_lengths[result->tm_mon]) { idays -= mon_lengths[result->tm_mon++]; } result->tm_mday = idays + 1; } static void ldns_wday_from_year_and_yday(struct tm *result) { result->tm_wday = 4 /* 1-1-1970 was a thursday */ + LDNS_MOD((result->tm_year - 1970), 7) * LDNS_MOD(365, 7) + leap_days(1970, result->tm_year) + result->tm_yday; result->tm_wday = LDNS_MOD(result->tm_wday, 7); if (result->tm_wday < 0) { result->tm_wday += 7; } } static struct tm * ldns_gmtime64_r(int64_t clock, struct tm *result) { result->tm_isdst = 0; result->tm_sec = (int) LDNS_MOD(clock, 60); clock = LDNS_DIV(clock, 60); result->tm_min = (int) LDNS_MOD(clock, 60); clock = LDNS_DIV(clock, 60); result->tm_hour = (int) LDNS_MOD(clock, 24); clock = LDNS_DIV(clock, 24); ldns_year_and_yday_from_days_since_epoch(clock, result); ldns_mon_and_mday_from_year_and_yday(result); ldns_wday_from_year_and_yday(result); result->tm_year -= 1900; return result; } #endif /* SIZEOF_TIME_T <= 4 */ static int64_t ldns_serial_arithmitics_time(int32_t time, time_t now) { int32_t offset = time - (int32_t) now; return (int64_t) now + offset; } struct tm * ldns_serial_arithmitics_gmtime_r(int32_t time, time_t now, struct tm *result) { #if SIZEOF_TIME_T <= 4 int64_t secs_since_epoch = ldns_serial_arithmitics_time(time, now); return ldns_gmtime64_r(secs_since_epoch, result); #else time_t secs_since_epoch = ldns_serial_arithmitics_time(time, now); return gmtime_r(&secs_since_epoch, result); #endif } /** * Init the random source * applications should call this if they need entropy data within ldns * If openSSL is available, it is automatically seeded from /dev/urandom * or /dev/random * * If you need more entropy, or have no openssl available, this function * MUST be called at the start of the program * * If openssl *is* available, this function just adds more entropy **/ int ldns_init_random(FILE *fd, unsigned int size) { /* if fp is given, seed srandom with data from file otherwise use /dev/urandom */ FILE *rand_f; uint8_t *seed; size_t read = 0; unsigned int seed_i; struct timeval tv; /* we'll need at least sizeof(unsigned int) bytes for the standard prng seed */ if (size < (unsigned int) sizeof(seed_i)){ size = (unsigned int) sizeof(seed_i); } seed = LDNS_XMALLOC(uint8_t, size); if(!seed) { return 1; } if (!fd) { if ((rand_f = fopen("/dev/urandom", "r")) == NULL) { /* no readable /dev/urandom, try /dev/random */ if ((rand_f = fopen("/dev/random", "r")) == NULL) { /* no readable /dev/random either, and no entropy source given. we'll have to improvise */ for (read = 0; read < size; read++) { gettimeofday(&tv, NULL); seed[read] = (uint8_t) (tv.tv_usec % 256); } } else { read = fread(seed, 1, size, rand_f); } } else { read = fread(seed, 1, size, rand_f); } } else { rand_f = fd; read = fread(seed, 1, size, rand_f); } if (read < size) { LDNS_FREE(seed); if (!fd) fclose(rand_f); return 1; } else { #ifdef HAVE_SSL /* Seed the OpenSSL prng (most systems have it seeded automatically, in that case this call just adds entropy */ RAND_seed(seed, (int) size); #else /* Seed the standard prng, only uses the first * unsigned sizeof(unsiged int) bytes found in the entropy pool */ memcpy(&seed_i, seed, sizeof(seed_i)); srandom(seed_i); #endif LDNS_FREE(seed); } if (!fd) { if (rand_f) fclose(rand_f); } return 0; } /** * Get random number. * */ uint16_t ldns_get_random(void) { uint16_t rid = 0; #ifdef HAVE_SSL if (RAND_bytes((unsigned char*)&rid, 2) != 1) { rid = (uint16_t) random(); } #else rid = (uint16_t) random(); #endif return rid; } /* * BubbleBabble code taken from OpenSSH * Copyright (c) 2001 Carsten Raskgaard. All rights reserved. */ char * ldns_bubblebabble(uint8_t *data, size_t len) { char vowels[] = { 'a', 'e', 'i', 'o', 'u', 'y' }; char consonants[] = { 'b', 'c', 'd', 'f', 'g', 'h', 'k', 'l', 'm', 'n', 'p', 'r', 's', 't', 'v', 'z', 'x' }; size_t i, j = 0, rounds, seed = 1; char *retval; rounds = (len / 2) + 1; retval = LDNS_XMALLOC(char, rounds * 6); if(!retval) return NULL; retval[j++] = 'x'; for (i = 0; i < rounds; i++) { size_t idx0, idx1, idx2, idx3, idx4; if ((i + 1 < rounds) || (len % 2 != 0)) { idx0 = (((((size_t)(data[2 * i])) >> 6) & 3) + seed) % 6; idx1 = (((size_t)(data[2 * i])) >> 2) & 15; idx2 = ((((size_t)(data[2 * i])) & 3) + (seed / 6)) % 6; retval[j++] = vowels[idx0]; retval[j++] = consonants[idx1]; retval[j++] = vowels[idx2]; if ((i + 1) < rounds) { idx3 = (((size_t)(data[(2 * i) + 1])) >> 4) & 15; idx4 = (((size_t)(data[(2 * i) + 1]))) & 15; retval[j++] = consonants[idx3]; retval[j++] = '-'; retval[j++] = consonants[idx4]; seed = ((seed * 5) + ((((size_t)(data[2 * i])) * 7) + ((size_t)(data[(2 * i) + 1])))) % 36; } } else { idx0 = seed % 6; idx1 = 16; idx2 = seed / 6; retval[j++] = vowels[idx0]; retval[j++] = consonants[idx1]; retval[j++] = vowels[idx2]; } } retval[j++] = 'x'; retval[j++] = '\0'; return retval; } /* * For backwards compatibility, because we have always exported this symbol. */ #ifdef HAVE_B64_NTOP int ldns_b64_ntop(const uint8_t* src, size_t srclength, char *target, size_t targsize); { return b64_ntop(src, srclength, target, targsize); } #endif /* * For backwards compatibility, because we have always exported this symbol. */ #ifdef HAVE_B64_PTON int ldns_b64_pton(const char* src, uint8_t *target, size_t targsize) { return b64_pton(src, target, targsize); } #endif static int ldns_b32_ntop_base(const uint8_t* src, size_t src_sz, char* dst, size_t dst_sz, bool extended_hex, bool add_padding) { size_t ret_sz; const char* b32 = extended_hex ? "0123456789abcdefghijklmnopqrstuv" : "abcdefghijklmnopqrstuvwxyz234567"; size_t c = 0; /* c is used to carry partial base32 character over * byte boundaries for sizes with a remainder. * (i.e. src_sz % 5 != 0) */ ret_sz = add_padding ? ldns_b32_ntop_calculate_size(src_sz) : ldns_b32_ntop_calculate_size_no_padding(src_sz); /* Do we have enough space? */ if (dst_sz < ret_sz + 1) return -1; /* We know the size; terminate the string */ dst[ret_sz] = '\0'; /* First process all chunks of five */ while (src_sz >= 5) { /* 00000... ........ ........ ........ ........ */ dst[0] = b32[(src[0] ) >> 3]; /* .....111 11...... ........ ........ ........ */ dst[1] = b32[(src[0] & 0x07) << 2 | src[1] >> 6]; /* ........ ..22222. ........ ........ ........ */ dst[2] = b32[(src[1] & 0x3e) >> 1]; /* ........ .......3 3333.... ........ ........ */ dst[3] = b32[(src[1] & 0x01) << 4 | src[2] >> 4]; /* ........ ........ ....4444 4....... ........ */ dst[4] = b32[(src[2] & 0x0f) << 1 | src[3] >> 7]; /* ........ ........ ........ .55555.. ........ */ dst[5] = b32[(src[3] & 0x7c) >> 2]; /* ........ ........ ........ ......66 666..... */ dst[6] = b32[(src[3] & 0x03) << 3 | src[4] >> 5]; /* ........ ........ ........ ........ ...77777 */ dst[7] = b32[(src[4] & 0x1f) ]; src_sz -= 5; src += 5; dst += 8; } /* Process what remains */ switch (src_sz) { case 4: /* ........ ........ ........ ......66 666..... */ dst[6] = b32[(src[3] & 0x03) << 3]; /* ........ ........ ........ .55555.. ........ */ dst[5] = b32[(src[3] & 0x7c) >> 2]; /* ........ ........ ....4444 4....... ........ */ c = src[3] >> 7 ; case 3: dst[4] = b32[(src[2] & 0x0f) << 1 | c]; /* ........ .......3 3333.... ........ ........ */ c = src[2] >> 4 ; case 2: dst[3] = b32[(src[1] & 0x01) << 4 | c]; /* ........ ..22222. ........ ........ ........ */ dst[2] = b32[(src[1] & 0x3e) >> 1]; /* .....111 11...... ........ ........ ........ */ c = src[1] >> 6 ; case 1: dst[1] = b32[(src[0] & 0x07) << 2 | c]; /* 00000... ........ ........ ........ ........ */ dst[0] = b32[ src[0] >> 3]; } /* Add padding */ if (add_padding) { switch (src_sz) { case 1: dst[2] = '='; dst[3] = '='; case 2: dst[4] = '='; case 3: dst[5] = '='; dst[6] = '='; case 4: dst[7] = '='; } } return (int)ret_sz; } int ldns_b32_ntop(const uint8_t* src, size_t src_sz, char* dst, size_t dst_sz) { return ldns_b32_ntop_base(src, src_sz, dst, dst_sz, false, true); } int ldns_b32_ntop_extended_hex(const uint8_t* src, size_t src_sz, char* dst, size_t dst_sz) { return ldns_b32_ntop_base(src, src_sz, dst, dst_sz, true, true); } #ifndef HAVE_B32_NTOP int b32_ntop(const uint8_t* src, size_t src_sz, char* dst, size_t dst_sz) { return ldns_b32_ntop_base(src, src_sz, dst, dst_sz, false, true); } int b32_ntop_extended_hex(const uint8_t* src, size_t src_sz, char* dst, size_t dst_sz) { return ldns_b32_ntop_base(src, src_sz, dst, dst_sz, true, true); } #endif /* ! HAVE_B32_NTOP */ static int ldns_b32_pton_base(const char* src, size_t src_sz, uint8_t* dst, size_t dst_sz, bool extended_hex, bool check_padding) { size_t i = 0; char ch = '\0'; uint8_t buf[8]; uint8_t* start = dst; while (src_sz) { /* Collect 8 characters in buf (if possible) */ for (i = 0; i < 8; i++) { do { ch = *src++; --src_sz; } while (isspace(ch) && src_sz > 0); if (ch == '=' || ch == '\0') break; else if (extended_hex) if (ch >= '0' && ch <= '9') buf[i] = (uint8_t)ch - '0'; else if (ch >= 'a' && ch <= 'v') buf[i] = (uint8_t)ch - 'a' + 10; else if (ch >= 'A' && ch <= 'V') buf[i] = (uint8_t)ch - 'A' + 10; else return -1; else if (ch >= 'a' && ch <= 'z') buf[i] = (uint8_t)ch - 'a'; else if (ch >= 'A' && ch <= 'Z') buf[i] = (uint8_t)ch - 'A'; else if (ch >= '2' && ch <= '7') buf[i] = (uint8_t)ch - '2' + 26; else return -1; } /* Less that 8 characters. We're done. */ if (i < 8) break; /* Enough space available at the destination? */ if (dst_sz < 5) return -1; /* 00000... ........ ........ ........ ........ */ /* .....111 11...... ........ ........ ........ */ dst[0] = buf[0] << 3 | buf[1] >> 2; /* .....111 11...... ........ ........ ........ */ /* ........ ..22222. ........ ........ ........ */ /* ........ .......3 3333.... ........ ........ */ dst[1] = buf[1] << 6 | buf[2] << 1 | buf[3] >> 4; /* ........ .......3 3333.... ........ ........ */ /* ........ ........ ....4444 4....... ........ */ dst[2] = buf[3] << 4 | buf[4] >> 1; /* ........ ........ ....4444 4....... ........ */ /* ........ ........ ........ .55555.. ........ */ /* ........ ........ ........ ......66 666..... */ dst[3] = buf[4] << 7 | buf[5] << 2 | buf[6] >> 3; /* ........ ........ ........ ......66 666..... */ /* ........ ........ ........ ........ ...77777 */ dst[4] = buf[6] << 5 | buf[7]; dst += 5; dst_sz -= 5; } /* Not ending on a eight byte boundary? */ if (i > 0 && i < 8) { /* Enough space available at the destination? */ if (dst_sz < (i + 1) / 2) return -1; switch (i) { case 7: /* ........ ........ ........ ......66 666..... */ /* ........ ........ ........ .55555.. ........ */ /* ........ ........ ....4444 4....... ........ */ dst[3] = buf[4] << 7 | buf[5] << 2 | buf[6] >> 3; case 5: /* ........ ........ ....4444 4....... ........ */ /* ........ .......3 3333.... ........ ........ */ dst[2] = buf[3] << 4 | buf[4] >> 1; case 4: /* ........ .......3 3333.... ........ ........ */ /* ........ ..22222. ........ ........ ........ */ /* .....111 11...... ........ ........ ........ */ dst[1] = buf[1] << 6 | buf[2] << 1 | buf[3] >> 4; case 2: /* .....111 11...... ........ ........ ........ */ /* 00000... ........ ........ ........ ........ */ dst[0] = buf[0] << 3 | buf[1] >> 2; break; default: return -1; } dst += (i + 1) / 2; if (check_padding) { /* Check remaining padding characters */ if (ch != '=') return -1; /* One down, 8 - i - 1 more to come... */ for (i = 8 - i - 1; i > 0; i--) { do { if (src_sz == 0) return -1; ch = *src++; src_sz--; } while (isspace(ch)); if (ch != '=') return -1; } } } return dst - start; } int ldns_b32_pton(const char* src, size_t src_sz, uint8_t* dst, size_t dst_sz) { return ldns_b32_pton_base(src, src_sz, dst, dst_sz, false, true); } int ldns_b32_pton_extended_hex(const char* src, size_t src_sz, uint8_t* dst, size_t dst_sz) { return ldns_b32_pton_base(src, src_sz, dst, dst_sz, true, true); } #ifndef HAVE_B32_PTON int b32_pton(const char* src, size_t src_sz, uint8_t* dst, size_t dst_sz) { return ldns_b32_pton_base(src, src_sz, dst, dst_sz, false, true); } int b32_pton_extended_hex(const char* src, size_t src_sz, uint8_t* dst, size_t dst_sz) { return ldns_b32_pton_base(src, src_sz, dst, dst_sz, true, true); } #endif /* ! HAVE_B32_PTON */ ldns-1.6.17/compat/0000775000175100017510000000000012264060151013376 5ustar willemwillemldns-1.6.17/compat/ctime_r.c0000664000175100017510000000040612264060151015164 0ustar willemwillem#ifdef HAVE_CONFIG_H #include #endif #ifdef HAVE_TIME_H #include #endif char *ctime_r(const time_t *timep, char *buf) { /* no thread safety. */ char* result = ctime(timep); if(buf && result) strcpy(buf, result); return result; } ldns-1.6.17/compat/timegm.c0000664000175100017510000000063612264060151015031 0ustar willemwillem#ifdef HAVE_CONFIG_H #include #endif #include #ifdef HAVE_STDLIB_H #include #endif #include time_t timegm (struct tm *tm) { time_t ret; char *tz; tz = getenv("TZ"); putenv((char*)"TZ="); tzset(); ret = mktime(tm); if (tz) { char buf[256]; snprintf(buf, sizeof(buf), "TZ=%s", tz); putenv(tz); } else putenv((char*)"TZ"); tzset(); return ret; } ldns-1.6.17/compat/inet_aton.c0000664000175100017510000001252412264060151015526 0ustar willemwillem/* From openssh4.3p2 compat/inet_aton.c */ /* * Copyright (c) 1983, 1990, 1993 * The Regents of the University of California. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * - * Portions Copyright (c) 1993 by Digital Equipment Corporation. * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above * copyright notice and this permission notice appear in all copies, and that * the name of Digital Equipment Corporation not be used in advertising or * publicity pertaining to distribution of the document or software without * specific, written prior permission. * * THE SOFTWARE IS PROVIDED "AS IS" AND DIGITAL EQUIPMENT CORP. DISCLAIMS ALL * WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL DIGITAL EQUIPMENT * CORPORATION BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS * SOFTWARE. * - * --Copyright-- */ /* OPENBSD ORIGINAL: lib/libc/net/inet_addr.c */ #include #if !defined(HAVE_INET_ATON) #include #include #ifdef HAVE_NETINET_IN_H #include #endif #ifdef HAVE_ARPA_INET_H #include #endif #include #if 0 /* * Ascii internet address interpretation routine. * The value returned is in network order. */ in_addr_t inet_addr(const char *cp) { struct in_addr val; if (inet_aton(cp, &val)) return (val.s_addr); return (INADDR_NONE); } #endif /* * Check whether "cp" is a valid ascii representation * of an Internet address and convert to a binary address. * Returns 1 if the address is valid, 0 if not. * This replaces inet_addr, the return value from which * cannot distinguish between failure and a local broadcast address. */ int inet_aton(const char *cp, struct in_addr *addr) { uint32_t val; int base, n; char c; unsigned int parts[4]; unsigned int *pp = parts; c = *cp; for (;;) { /* * Collect number up to ``.''. * Values are specified as for C: * 0x=hex, 0=octal, isdigit=decimal. */ if (!isdigit((int) c)) return (0); val = 0; base = 10; if (c == '0') { c = *++cp; if (c == 'x' || c == 'X') base = 16, c = *++cp; else base = 8; } for (;;) { if (isascii((int) c) && isdigit((int) c)) { val = (val * base) + (c - '0'); c = *++cp; } else if (base == 16 && isascii((int) c) && isxdigit((int) c)) { val = (val << 4) | (c + 10 - (islower((int) c) ? 'a' : 'A')); c = *++cp; } else break; } if (c == '.') { /* * Internet format: * a.b.c.d * a.b.c (with c treated as 16 bits) * a.b (with b treated as 24 bits) */ if (pp >= parts + 3) return (0); *pp++ = val; c = *++cp; } else break; } /* * Check for trailing characters. */ if (c != '\0' && (!isascii((int) c) || !isspace((int) c))) return (0); /* * Concoct the address according to * the number of parts specified. */ n = pp - parts + 1; switch (n) { case 0: return (0); /* initial nondigit */ case 1: /* a -- 32 bits */ break; case 2: /* a.b -- 8.24 bits */ if ((val > 0xffffff) || (parts[0] > 0xff)) return (0); val |= parts[0] << 24; break; case 3: /* a.b.c -- 8.8.16 bits */ if ((val > 0xffff) || (parts[0] > 0xff) || (parts[1] > 0xff)) return (0); val |= (parts[0] << 24) | (parts[1] << 16); break; case 4: /* a.b.c.d -- 8.8.8.8 bits */ if ((val > 0xff) || (parts[0] > 0xff) || (parts[1] > 0xff) || (parts[2] > 0xff)) return (0); val |= (parts[0] << 24) | (parts[1] << 16) | (parts[2] << 8); break; } if (addr) addr->s_addr = htonl(val); return (1); } #endif /* !defined(HAVE_INET_ATON) */ ldns-1.6.17/compat/isblank.c0000664000175100017510000000037712264060151015174 0ustar willemwillem/* Just a replacement, if the original isblank is not present */ #if HAVE_CONFIG_H #include #endif int isblank(int c); /* true if character is a blank (space or tab). C99. */ int isblank(int c) { return (c == ' ') || (c == '\t'); } ldns-1.6.17/compat/b64_ntop.c0000664000175100017510000001637612264060151015212 0ustar willemwillem/* * Copyright (c) 1996, 1998 by Internet Software Consortium. * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above * copyright notice and this permission notice appear in all copies. * * THE SOFTWARE IS PROVIDED "AS IS" AND INTERNET SOFTWARE CONSORTIUM DISCLAIMS * ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL INTERNET SOFTWARE * CONSORTIUM BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS * SOFTWARE. */ /* * Portions Copyright (c) 1995 by International Business Machines, Inc. * * International Business Machines, Inc. (hereinafter called IBM) grants * permission under its copyrights to use, copy, modify, and distribute this * Software with or without fee, provided that the above copyright notice and * all paragraphs of this notice appear in all copies, and that the name of IBM * not be used in connection with the marketing of any product incorporating * the Software or modifications thereof, without specific, written prior * permission. * * To the extent it has a right to do so, IBM grants an immunity from suit * under its patents, if any, for the use, sale or manufacture of products to * the extent that such products are used for performing Domain Name System * dynamic updates in TCP/IP networks by means of the Software. No immunity is * granted for any product per se or for any other function of any product. * * THE SOFTWARE IS PROVIDED "AS IS", AND IBM DISCLAIMS ALL WARRANTIES, * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A * PARTICULAR PURPOSE. IN NO EVENT SHALL IBM BE LIABLE FOR ANY SPECIAL, * DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER ARISING * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE, EVEN * IF IBM IS APPRISED OF THE POSSIBILITY OF SUCH DAMAGES. */ #include #include #include #include static const char Base64[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; static const char Pad64 = '='; /* (From RFC1521 and draft-ietf-dnssec-secext-03.txt) The following encoding technique is taken from RFC 1521 by Borenstein and Freed. It is reproduced here in a slightly edited form for convenience. A 65-character subset of US-ASCII is used, enabling 6 bits to be represented per printable character. (The extra 65th character, "=", is used to signify a special processing function.) The encoding process represents 24-bit groups of input bits as output strings of 4 encoded characters. Proceeding from left to right, a 24-bit input group is formed by concatenating 3 8-bit input groups. These 24 bits are then treated as 4 concatenated 6-bit groups, each of which is translated into a single digit in the base64 alphabet. Each 6-bit group is used as an index into an array of 64 printable characters. The character referenced by the index is placed in the output string. Table 1: The Base64 Alphabet Value Encoding Value Encoding Value Encoding Value Encoding 0 A 17 R 34 i 51 z 1 B 18 S 35 j 52 0 2 C 19 T 36 k 53 1 3 D 20 U 37 l 54 2 4 E 21 V 38 m 55 3 5 F 22 W 39 n 56 4 6 G 23 X 40 o 57 5 7 H 24 Y 41 p 58 6 8 I 25 Z 42 q 59 7 9 J 26 a 43 r 60 8 10 K 27 b 44 s 61 9 11 L 28 c 45 t 62 + 12 M 29 d 46 u 63 / 13 N 30 e 47 v 14 O 31 f 48 w (pad) = 15 P 32 g 49 x 16 Q 33 h 50 y Special processing is performed if fewer than 24 bits are available at the end of the data being encoded. A full encoding quantum is always completed at the end of a quantity. When fewer than 24 input bits are available in an input group, zero bits are added (on the right) to form an integral number of 6-bit groups. Padding at the end of the data is performed using the '=' character. Since all base64 input is an integral number of octets, only the ------------------------------------------------- following cases can arise: (1) the final quantum of encoding input is an integral multiple of 24 bits; here, the final unit of encoded output will be an integral multiple of 4 characters with no "=" padding, (2) the final quantum of encoding input is exactly 8 bits; here, the final unit of encoded output will be two characters followed by two "=" padding characters, or (3) the final quantum of encoding input is exactly 16 bits; here, the final unit of encoded output will be three characters followed by one "=" padding character. */ int ldns_b64_ntop(uint8_t const *src, size_t srclength, char *target, size_t targsize) { size_t datalength = 0; uint8_t input[3]; uint8_t output[4]; size_t i; if (srclength == 0) { if (targsize > 0) { target[0] = '\0'; return 0; } else { return -1; } } while (2 < srclength) { input[0] = *src++; input[1] = *src++; input[2] = *src++; srclength -= 3; output[0] = input[0] >> 2; output[1] = ((input[0] & 0x03) << 4) + (input[1] >> 4); output[2] = ((input[1] & 0x0f) << 2) + (input[2] >> 6); output[3] = input[2] & 0x3f; assert(output[0] < 64); assert(output[1] < 64); assert(output[2] < 64); assert(output[3] < 64); if (datalength + 4 > targsize) { return (-1); } target[datalength++] = Base64[output[0]]; target[datalength++] = Base64[output[1]]; target[datalength++] = Base64[output[2]]; target[datalength++] = Base64[output[3]]; } /* Now we worry about padding. */ if (0 != srclength) { /* Get what's left. */ input[0] = input[1] = input[2] = (uint8_t) '\0'; for (i = 0; i < srclength; i++) input[i] = *src++; output[0] = input[0] >> 2; output[1] = ((input[0] & 0x03) << 4) + (input[1] >> 4); output[2] = ((input[1] & 0x0f) << 2) + (input[2] >> 6); assert(output[0] < 64); assert(output[1] < 64); assert(output[2] < 64); if (datalength + 4 > targsize) { return (-2); } target[datalength++] = Base64[output[0]]; target[datalength++] = Base64[output[1]]; if (srclength == 1) { target[datalength++] = Pad64; } else { target[datalength++] = Base64[output[2]]; } target[datalength++] = Pad64; } if (datalength >= targsize) { return (-3); } target[datalength] = '\0'; /* Returned value doesn't count \0. */ return (int) (datalength); } ldns-1.6.17/compat/malloc.c0000664000175100017510000000060512264060151015012 0ustar willemwillem/* Just a replacement, if the original malloc is not GNU-compliant. See autoconf documentation. */ #if HAVE_CONFIG_H #include #endif #undef malloc #include void *malloc (); /* Allocate an N-byte block of memory from the heap. If N is zero, allocate a 1-byte block. */ void * rpl_malloc (size_t n) { if (n == 0) n = 1; return malloc (n); } ldns-1.6.17/compat/inet_pton.c0000664000175100017510000001223212264060151015541 0ustar willemwillem/* $KAME: inet_pton.c,v 1.5 2001/08/20 02:32:40 itojun Exp $ */ /* Copyright (c) 1996 by Internet Software Consortium. * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above * copyright notice and this permission notice appear in all copies. * * THE SOFTWARE IS PROVIDED "AS IS" AND INTERNET SOFTWARE CONSORTIUM DISCLAIMS * ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL INTERNET SOFTWARE * CONSORTIUM BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS * SOFTWARE. */ #include #include #include #include /* * WARNING: Don't even consider trying to compile this on a system where * sizeof(int) < 4. sizeof(int) > 4 is fine; all the world's not a VAX. */ static int inet_pton4 (const char *src, uint8_t *dst); static int inet_pton6 (const char *src, uint8_t *dst); /* * * The definitions we might miss. * */ #ifndef NS_INT16SZ #define NS_INT16SZ 2 #endif #ifndef NS_IN6ADDRSZ #define NS_IN6ADDRSZ 16 #endif #ifndef NS_INADDRSZ #define NS_INADDRSZ 4 #endif /* int * inet_pton(af, src, dst) * convert from presentation format (which usually means ASCII printable) * to network format (which is usually some kind of binary format). * return: * 1 if the address was valid for the specified address family * 0 if the address wasn't valid (`dst' is untouched in this case) * -1 if some other error occurred (`dst' is untouched in this case, too) * author: * Paul Vixie, 1996. */ int inet_pton(af, src, dst) int af; const char *src; void *dst; { switch (af) { case AF_INET: return (inet_pton4(src, dst)); case AF_INET6: return (inet_pton6(src, dst)); default: #ifdef EAFNOSUPPORT errno = EAFNOSUPPORT; #else errno = ENOSYS; #endif return (-1); } /* NOTREACHED */ } /* int * inet_pton4(src, dst) * like inet_aton() but without all the hexadecimal and shorthand. * return: * 1 if `src' is a valid dotted quad, else 0. * notice: * does not touch `dst' unless it's returning 1. * author: * Paul Vixie, 1996. */ static int inet_pton4(src, dst) const char *src; uint8_t *dst; { static const char digits[] = "0123456789"; int saw_digit, octets, ch; uint8_t tmp[NS_INADDRSZ], *tp; saw_digit = 0; octets = 0; *(tp = tmp) = 0; while ((ch = *src++) != '\0') { const char *pch; if ((pch = strchr(digits, ch)) != NULL) { uint32_t new = *tp * 10 + (pch - digits); if (new > 255) return (0); *tp = new; if (! saw_digit) { if (++octets > 4) return (0); saw_digit = 1; } } else if (ch == '.' && saw_digit) { if (octets == 4) return (0); *++tp = 0; saw_digit = 0; } else return (0); } if (octets < 4) return (0); memcpy(dst, tmp, NS_INADDRSZ); return (1); } /* int * inet_pton6(src, dst) * convert presentation level address to network order binary form. * return: * 1 if `src' is a valid [RFC1884 2.2] address, else 0. * notice: * (1) does not touch `dst' unless it's returning 1. * (2) :: in a full address is silently ignored. * credit: * inspired by Mark Andrews. * author: * Paul Vixie, 1996. */ static int inet_pton6(src, dst) const char *src; uint8_t *dst; { static const char xdigits_l[] = "0123456789abcdef", xdigits_u[] = "0123456789ABCDEF"; uint8_t tmp[NS_IN6ADDRSZ], *tp, *endp, *colonp; const char *xdigits, *curtok; int ch, saw_xdigit; uint32_t val; memset((tp = tmp), '\0', NS_IN6ADDRSZ); endp = tp + NS_IN6ADDRSZ; colonp = NULL; /* Leading :: requires some special handling. */ if (*src == ':') if (*++src != ':') return (0); curtok = src; saw_xdigit = 0; val = 0; while ((ch = *src++) != '\0') { const char *pch; if ((pch = strchr((xdigits = xdigits_l), ch)) == NULL) pch = strchr((xdigits = xdigits_u), ch); if (pch != NULL) { val <<= 4; val |= (pch - xdigits); if (val > 0xffff) return (0); saw_xdigit = 1; continue; } if (ch == ':') { curtok = src; if (!saw_xdigit) { if (colonp) return (0); colonp = tp; continue; } if (tp + NS_INT16SZ > endp) return (0); *tp++ = (uint8_t) (val >> 8) & 0xff; *tp++ = (uint8_t) val & 0xff; saw_xdigit = 0; val = 0; continue; } if (ch == '.' && ((tp + NS_INADDRSZ) <= endp) && inet_pton4(curtok, tp) > 0) { tp += NS_INADDRSZ; saw_xdigit = 0; break; /* '\0' was seen by inet_pton4(). */ } return (0); } if (saw_xdigit) { if (tp + NS_INT16SZ > endp) return (0); *tp++ = (uint8_t) (val >> 8) & 0xff; *tp++ = (uint8_t) val & 0xff; } if (colonp != NULL) { /* * Since some memmove()'s erroneously fail to handle * overlapping regions, we'll do the shift by hand. */ const int n = tp - colonp; int i; for (i = 1; i <= n; i++) { endp[- i] = colonp[n - i]; colonp[n - i] = 0; } tp = endp; } if (tp != endp) return (0); memcpy(dst, tmp, NS_IN6ADDRSZ); return (1); } ldns-1.6.17/compat/isascii.c0000664000175100017510000000034112264060151015164 0ustar willemwillem/* Just a replacement, if the original isascii is not present */ #if HAVE_CONFIG_H #include #endif int isascii(int c); /* true if character is ascii. */ int isascii(int c) { return c >= 0 && c < 128; } ldns-1.6.17/compat/fake-rfc2553.c0000664000175100017510000001411112264060151015535 0ustar willemwillem/* From openssh 4.3p2 filename openbsd-compat/fake-rfc2553.h */ /* * Copyright (C) 2000-2003 Damien Miller. All rights reserved. * Copyright (C) 1999 WIDE Project. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. Neither the name of the project nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* * Pseudo-implementation of RFC2553 name / address resolution functions * * But these functions are not implemented correctly. The minimum subset * is implemented for ssh use only. For example, this routine assumes * that ai_family is AF_INET. Don't use it for another purpose. */ #include #include #include #include #include #include #include "compat/fake-rfc2553.h" #ifndef HAVE_GETNAMEINFO int getnameinfo(const struct sockaddr *sa, size_t ATTR_UNUSED(salen), char *host, size_t hostlen, char *serv, size_t servlen, int flags) { struct sockaddr_in *sin = (struct sockaddr_in *)sa; struct hostent *hp; char tmpserv[16]; if (serv != NULL) { snprintf(tmpserv, sizeof(tmpserv), "%d", ntohs(sin->sin_port)); if (strlcpy(serv, tmpserv, servlen) >= servlen) return (EAI_MEMORY); } if (host != NULL) { if (flags & NI_NUMERICHOST) { if (strlcpy(host, inet_ntoa(sin->sin_addr), hostlen) >= hostlen) return (EAI_MEMORY); else return (0); } else { hp = gethostbyaddr((char *)&sin->sin_addr, sizeof(struct in_addr), AF_INET); if (hp == NULL) return (EAI_NODATA); if (strlcpy(host, hp->h_name, hostlen) >= hostlen) return (EAI_MEMORY); else return (0); } } return (0); } #endif /* !HAVE_GETNAMEINFO */ #ifndef HAVE_GAI_STRERROR #ifdef HAVE_CONST_GAI_STRERROR_PROTO const char * #else char * #endif gai_strerror(int err) { switch (err) { case EAI_NODATA: return ("no address associated with name"); case EAI_MEMORY: return ("memory allocation failure."); case EAI_NONAME: return ("nodename nor servname provided, or not known"); default: return ("unknown/invalid error."); } } #endif /* !HAVE_GAI_STRERROR */ #ifndef HAVE_FREEADDRINFO void freeaddrinfo(struct addrinfo *ai) { struct addrinfo *next; for(; ai != NULL;) { next = ai->ai_next; free(ai); ai = next; } } #endif /* !HAVE_FREEADDRINFO */ #ifndef HAVE_GETADDRINFO static struct addrinfo *malloc_ai(int port, u_long addr, const struct addrinfo *hints) { struct addrinfo *ai; ai = malloc(sizeof(*ai) + sizeof(struct sockaddr_in)); if (ai == NULL) return (NULL); memset(ai, '\0', sizeof(*ai) + sizeof(struct sockaddr_in)); ai->ai_addr = (struct sockaddr *)(ai + 1); /* XXX -- ssh doesn't use sa_len */ ai->ai_addrlen = sizeof(struct sockaddr_in); ai->ai_addr->sa_family = ai->ai_family = AF_INET; ((struct sockaddr_in *)(ai)->ai_addr)->sin_port = port; ((struct sockaddr_in *)(ai)->ai_addr)->sin_addr.s_addr = addr; /* XXX: the following is not generally correct, but does what we want */ if (hints->ai_socktype) ai->ai_socktype = hints->ai_socktype; else ai->ai_socktype = SOCK_STREAM; if (hints->ai_protocol) ai->ai_protocol = hints->ai_protocol; return (ai); } int getaddrinfo(const char *hostname, const char *servname, const struct addrinfo *hints, struct addrinfo **res) { struct hostent *hp; struct servent *sp; struct in_addr in; int i; long int port; u_long addr; port = 0; if (servname != NULL) { char *cp; port = strtol(servname, &cp, 10); if (port > 0 && port <= 65535 && *cp == '\0') port = htons(port); else if ((sp = getservbyname(servname, NULL)) != NULL) port = sp->s_port; else port = 0; } if (hints && hints->ai_flags & AI_PASSIVE) { addr = htonl(0x00000000); if (hostname && inet_aton(hostname, &in) != 0) addr = in.s_addr; *res = malloc_ai(port, addr, hints); if (*res == NULL) return (EAI_MEMORY); return (0); } if (!hostname) { *res = malloc_ai(port, htonl(0x7f000001), hints); if (*res == NULL) return (EAI_MEMORY); return (0); } if (inet_aton(hostname, &in)) { *res = malloc_ai(port, in.s_addr, hints); if (*res == NULL) return (EAI_MEMORY); return (0); } /* Don't try DNS if AI_NUMERICHOST is set */ if (hints && hints->ai_flags & AI_NUMERICHOST) return (EAI_NONAME); hp = gethostbyname(hostname); if (hp && hp->h_name && hp->h_name[0] && hp->h_addr_list[0]) { struct addrinfo *cur, *prev; cur = prev = *res = NULL; for (i = 0; hp->h_addr_list[i]; i++) { struct in_addr *in = (struct in_addr *)hp->h_addr_list[i]; cur = malloc_ai(port, in->s_addr, hints); if (cur == NULL) { if (*res != NULL) freeaddrinfo(*res); return (EAI_MEMORY); } if (prev) prev->ai_next = cur; else *res = cur; prev = cur; } return (0); } return (EAI_NODATA); } #endif /* !HAVE_GETADDRINFO */ ldns-1.6.17/compat/localtime_r.c0000664000175100017510000000035512264060151016037 0ustar willemwillem#ifdef HAVE_CONFIG_H #include #endif #ifdef HAVE_TIME_H #include #endif struct tm *localtime_r(const time_t *timep, struct tm *result) { /* no thread safety. */ *result = *localtime(timep); return result; } ldns-1.6.17/compat/calloc.c0000664000175100017510000000063712264060151015005 0ustar willemwillem/* Just a replacement, if the original malloc is not GNU-compliant. See autoconf documentation. */ #if HAVE_CONFIG_H #include #endif void *calloc(); #if !HAVE_BZERO && HAVE_MEMSET # define bzero(buf, bytes) ((void) memset (buf, 0, bytes)) #endif void * calloc(size_t num, size_t size) { void *new = malloc(num * size); if (!new) { return NULL; } bzero(new, num * size); return new; } ldns-1.6.17/compat/realloc.c0000664000175100017510000000106712264060151015167 0ustar willemwillem/* Just a replacement, if the original malloc is not GNU-compliant. Based on malloc.c */ #if HAVE_CONFIG_H #include #endif #undef realloc #include void *realloc (void*, size_t); void *malloc (size_t); /* Changes allocation to new sizes, copies over old data. * if oldptr is NULL, does a malloc. * if size is zero, allocate 1-byte block.... * (does not return NULL and free block) */ void * rpl_realloc (void* ptr, size_t n) { if (n == 0) n = 1; if(ptr == 0) { return malloc(n); } return realloc(ptr, n); } ldns-1.6.17/compat/strlcpy.c0000664000175100017510000000321212264060151015240 0ustar willemwillem/* from openssh 4.3p2 compat/strlcpy.c */ /* * Copyright (c) 1998 Todd C. Miller * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above * copyright notice and this permission notice appear in all copies. * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ /* OPENBSD ORIGINAL: lib/libc/string/strlcpy.c */ #include #ifndef HAVE_STRLCPY #include #include /* * Copy src to string dst of size siz. At most siz-1 characters * will be copied. Always NUL terminates (unless siz == 0). * Returns strlen(src); if retval >= siz, truncation occurred. */ size_t strlcpy(char *dst, const char *src, size_t siz) { char *d = dst; const char *s = src; size_t n = siz; /* Copy as many bytes as will fit */ if (n != 0 && --n != 0) { do { if ((*d++ = *s++) == 0) break; } while (--n != 0); } /* Not enough room in dst, add NUL and traverse rest of src */ if (n == 0) { if (siz != 0) *d = '\0'; /* NUL-terminate dst */ while (*s++) ; } return(s - src - 1); /* count does not include NUL */ } #endif /* !HAVE_STRLCPY */ ldns-1.6.17/compat/memmove.c0000664000175100017510000000167112264060151015214 0ustar willemwillem/* * memmove.c: memmove compat implementation. * * Copyright (c) 2001-2008, NLnet Labs. All rights reserved. * * See LICENSE for the license. */ #include #include void *memmove(void *dest, const void *src, size_t n); void *memmove(void *dest, const void *src, size_t n) { uint8_t* from = (uint8_t*) src; uint8_t* to = (uint8_t*) dest; if (from == to || n == 0) return dest; if (to > from && to-from < (int)n) { /* to overlaps with from */ /* */ /* */ /* copy in reverse, to avoid overwriting from */ int i; for(i=n-1; i>=0; i--) to[i] = from[i]; return dest; } if (from > to && from-to < (int)n) { /* to overlaps with from */ /* */ /* */ /* copy forwards, to avoid overwriting from */ size_t i; for(i=0; i #endif #ifdef HAVE_TIME_H #include #endif struct tm *gmtime_r(const time_t *timep, struct tm *result) { /* no thread safety. */ *result = *gmtime(timep); return result; } ldns-1.6.17/compat/fake-rfc2553.h0000664000175100017510000001241112264060151015543 0ustar willemwillem/* From openssh 4.3p2 filename openbsd-compat/fake-rfc2553.h */ /* * Copyright (C) 2000-2003 Damien Miller. All rights reserved. * Copyright (C) 1999 WIDE Project. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. Neither the name of the project nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* * Pseudo-implementation of RFC2553 name / address resolution functions * * But these functions are not implemented correctly. The minimum subset * is implemented for ssh use only. For example, this routine assumes * that ai_family is AF_INET. Don't use it for another purpose. */ #ifndef _FAKE_RFC2553_H #define _FAKE_RFC2553_H #include #include #include #include #ifdef __cplusplus extern "C" { #endif /* * First, socket and INET6 related definitions */ #ifndef HAVE_STRUCT_SOCKADDR_STORAGE #ifndef _SS_MAXSIZE # define _SS_MAXSIZE 128 /* Implementation specific max size */ # define _SS_PADSIZE (_SS_MAXSIZE - sizeof (struct sockaddr)) struct sockaddr_storage { struct sockaddr ss_sa; char __ss_pad2[_SS_PADSIZE]; }; # define ss_family ss_sa.sa_family #endif /* _SS_MAXSIZE */ #endif /* !HAVE_STRUCT_SOCKADDR_STORAGE */ #ifndef IN6_IS_ADDR_LOOPBACK # define IN6_IS_ADDR_LOOPBACK(a) \ (((uint32_t *)(a))[0] == 0 && ((uint32_t *)(a))[1] == 0 && \ ((uint32_t *)(a))[2] == 0 && ((uint32_t *)(a))[3] == htonl(1)) #endif /* !IN6_IS_ADDR_LOOPBACK */ #ifndef HAVE_STRUCT_IN6_ADDR struct in6_addr { uint8_t s6_addr[16]; }; #endif /* !HAVE_STRUCT_IN6_ADDR */ #ifndef HAVE_STRUCT_SOCKADDR_IN6 struct sockaddr_in6 { unsigned short sin6_family; uint16_t sin6_port; uint32_t sin6_flowinfo; struct in6_addr sin6_addr; }; #endif /* !HAVE_STRUCT_SOCKADDR_IN6 */ #ifndef AF_INET6 /* Define it to something that should never appear */ #define AF_INET6 AF_MAX #endif /* * Next, RFC2553 name / address resolution API */ #ifndef NI_NUMERICHOST # define NI_NUMERICHOST (1) #endif #ifndef NI_NAMEREQD # define NI_NAMEREQD (1<<1) #endif #ifndef NI_NUMERICSERV # define NI_NUMERICSERV (1<<2) #endif #ifndef AI_PASSIVE # define AI_PASSIVE (1) #endif #ifndef AI_CANONNAME # define AI_CANONNAME (1<<1) #endif #ifndef AI_NUMERICHOST # define AI_NUMERICHOST (1<<2) #endif #ifndef NI_MAXSERV # define NI_MAXSERV 32 #endif /* !NI_MAXSERV */ #ifndef NI_MAXHOST # define NI_MAXHOST 1025 #endif /* !NI_MAXHOST */ #ifndef INT_MAX #define INT_MAX 0xffffffff #endif #ifndef EAI_NODATA # define EAI_NODATA (INT_MAX - 1) #endif #ifndef EAI_MEMORY # define EAI_MEMORY (INT_MAX - 2) #endif #ifndef EAI_NONAME # define EAI_NONAME (INT_MAX - 3) #endif #ifndef EAI_SYSTEM # define EAI_SYSTEM (INT_MAX - 4) #endif #ifndef HAVE_STRUCT_ADDRINFO struct addrinfo { int ai_flags; /* AI_PASSIVE, AI_CANONNAME */ int ai_family; /* PF_xxx */ int ai_socktype; /* SOCK_xxx */ int ai_protocol; /* 0 or IPPROTO_xxx for IPv4 and IPv6 */ size_t ai_addrlen; /* length of ai_addr */ char *ai_canonname; /* canonical name for hostname */ struct sockaddr *ai_addr; /* binary address */ struct addrinfo *ai_next; /* next structure in linked list */ }; #endif /* !HAVE_STRUCT_ADDRINFO */ #ifndef HAVE_GETADDRINFO #ifdef getaddrinfo # undef getaddrinfo #endif #define getaddrinfo(a,b,c,d) (ssh_getaddrinfo(a,b,c,d)) int getaddrinfo(const char *, const char *, const struct addrinfo *, struct addrinfo **); #endif /* !HAVE_GETADDRINFO */ #if !defined(HAVE_GAI_STRERROR) && !defined(HAVE_CONST_GAI_STRERROR_PROTO) #define gai_strerror(a) (ssh_gai_strerror(a)) char *gai_strerror(int); #endif /* !HAVE_GAI_STRERROR */ #ifndef HAVE_FREEADDRINFO #define freeaddrinfo(a) (ssh_freeaddrinfo(a)) void freeaddrinfo(struct addrinfo *); #endif /* !HAVE_FREEADDRINFO */ #ifndef HAVE_GETNAMEINFO #define getnameinfo(a,b,c,d,e,f,g) (ssh_getnameinfo(a,b,c,d,e,f,g)) int getnameinfo(const struct sockaddr *, size_t, char *, size_t, char *, size_t, int); #endif /* !HAVE_GETNAMEINFO */ #ifdef __cplusplus } #endif #endif /* !_FAKE_RFC2553_H */ ldns-1.6.17/compat/inet_ntop.c0000664000175100017510000001276012264060151015547 0ustar willemwillem/* From openssh 4.3p2 compat/inet_ntop.c */ /* Copyright (c) 1996 by Internet Software Consortium. * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above * copyright notice and this permission notice appear in all copies. * * THE SOFTWARE IS PROVIDED "AS IS" AND INTERNET SOFTWARE CONSORTIUM DISCLAIMS * ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL INTERNET SOFTWARE * CONSORTIUM BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS * SOFTWARE. */ /* OPENBSD ORIGINAL: lib/libc/net/inet_ntop.c */ #include #ifndef HAVE_INET_NTOP #include #include #ifdef HAVE_SYS_SOCKET_H #include #endif #ifdef HAVE_NETINET_IN_H #include #endif #include #include #include #ifndef IN6ADDRSZ #define IN6ADDRSZ 16 /* IPv6 T_AAAA */ #endif #ifndef INT16SZ #define INT16SZ 2 /* for systems without 16-bit ints */ #endif /* * WARNING: Don't even consider trying to compile this on a system where * sizeof(int) < 4. sizeof(int) > 4 is fine; all the world's not a VAX. */ static const char *inet_ntop4(const u_char *src, char *dst, size_t size); static const char *inet_ntop6(const u_char *src, char *dst, size_t size); /* char * * inet_ntop(af, src, dst, size) * convert a network format address to presentation format. * return: * pointer to presentation format address (`dst'), or NULL (see errno). * author: * Paul Vixie, 1996. */ const char * inet_ntop(int af, const void *src, char *dst, size_t size) { switch (af) { case AF_INET: return (inet_ntop4(src, dst, size)); case AF_INET6: return (inet_ntop6(src, dst, size)); default: #ifdef EAFNOSUPPORT errno = EAFNOSUPPORT; #else errno = ENOSYS; #endif return (NULL); } /* NOTREACHED */ } /* const char * * inet_ntop4(src, dst, size) * format an IPv4 address, more or less like inet_ntoa() * return: * `dst' (as a const) * notes: * (1) uses no statics * (2) takes a u_char* not an in_addr as input * author: * Paul Vixie, 1996. */ static const char * inet_ntop4(const u_char *src, char *dst, size_t size) { static const char fmt[] = "%u.%u.%u.%u"; char tmp[sizeof "255.255.255.255"]; int l; l = snprintf(tmp, size, fmt, src[0], src[1], src[2], src[3]); if (l <= 0 || l >= (int)size) { errno = ENOSPC; return (NULL); } strlcpy(dst, tmp, size); return (dst); } /* const char * * inet_ntop6(src, dst, size) * convert IPv6 binary address into presentation (printable) format * author: * Paul Vixie, 1996. */ static const char * inet_ntop6(const u_char *src, char *dst, size_t size) { /* * Note that int32_t and int16_t need only be "at least" large enough * to contain a value of the specified size. On some systems, like * Crays, there is no such thing as an integer variable with 16 bits. * Keep this in mind if you think this function should have been coded * to use pointer overlays. All the world's not a VAX. */ char tmp[sizeof "ffff:ffff:ffff:ffff:ffff:ffff:255.255.255.255"]; char *tp, *ep; struct { int base, len; } best, cur; u_int words[IN6ADDRSZ / INT16SZ]; int i; int advance; /* * Preprocess: * Copy the input (bytewise) array into a wordwise array. * Find the longest run of 0x00's in src[] for :: shorthanding. */ memset(words, '\0', sizeof words); for (i = 0; i < IN6ADDRSZ; i++) words[i / 2] |= (src[i] << ((1 - (i % 2)) << 3)); best.base = -1; best.len = 0; cur.base = -1; cur.len = 0; for (i = 0; i < (IN6ADDRSZ / INT16SZ); i++) { if (words[i] == 0) { if (cur.base == -1) cur.base = i, cur.len = 1; else cur.len++; } else { if (cur.base != -1) { if (best.base == -1 || cur.len > best.len) best = cur; cur.base = -1; } } } if (cur.base != -1) { if (best.base == -1 || cur.len > best.len) best = cur; } if (best.base != -1 && best.len < 2) best.base = -1; /* * Format the result. */ tp = tmp; ep = tmp + sizeof(tmp); for (i = 0; i < (IN6ADDRSZ / INT16SZ) && tp < ep; i++) { /* Are we inside the best run of 0x00's? */ if (best.base != -1 && i >= best.base && i < (best.base + best.len)) { if (i == best.base) { if (tp + 1 >= ep) return (NULL); *tp++ = ':'; } continue; } /* Are we following an initial run of 0x00s or any real hex? */ if (i != 0) { if (tp + 1 >= ep) return (NULL); *tp++ = ':'; } /* Is this address an encapsulated IPv4? */ if (i == 6 && best.base == 0 && (best.len == 6 || (best.len == 5 && words[5] == 0xffff))) { if (!inet_ntop4(src+12, tp, (size_t)(ep - tp))) return (NULL); tp += strlen(tp); break; } advance = snprintf(tp, ep - tp, "%x", words[i]); if (advance <= 0 || advance >= ep - tp) return (NULL); tp += advance; } /* Was it a trailing run of 0x00's? */ if (best.base != -1 && (best.base + best.len) == (IN6ADDRSZ / INT16SZ)) { if (tp + 1 >= ep) return (NULL); *tp++ = ':'; } if (tp + 1 >= ep) return (NULL); *tp++ = '\0'; /* * Check for overflow, copy, and we're done. */ if ((size_t)(tp - tmp) > size) { errno = ENOSPC; return (NULL); } strlcpy(dst, tmp, size); return (dst); } #endif /* !HAVE_INET_NTOP */ ldns-1.6.17/compat/snprintf.c0000664000175100017510000007123512264060151015415 0ustar willemwillem/* snprintf - compatibility implementation of snprintf, vsnprintf * * Copyright (c) 2013, NLnet Labs. All rights reserved. * * This software is open source. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * Redistributions of source code must retain the above copyright notice, * this list of conditions and the following disclaimer. * * Redistributions in binary form must reproduce the above copyright notice, * this list of conditions and the following disclaimer in the documentation * and/or other materials provided with the distribution. * * Neither the name of the NLNET LABS nor the names of its contributors may * be used to endorse or promote products derived from this software without * specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. */ #include #include #include #include #include #include #include #ifdef HAVE_STDINT_H #include #endif /* for test */ /* #define SNPRINTF_TEST 1 */ #ifdef SNPRINTF_TEST #define snprintf my_snprintf #define vsnprintf my_vsnprintf #endif /* SNPRINTF_TEST */ int snprintf(char* str, size_t size, const char* format, ...); int vsnprintf(char* str, size_t size, const char* format, va_list arg); /** * Very portable snprintf implementation, limited in functionality, * esp. for %[capital] %[nonportable] and so on. Reduced float functionality, * mostly in formatting and range (e+-16), for %f and %g. * * %s, %d, %u, %i, %x, %c, %n and %% are fully supported. * This includes width, precision, flags 0- +, and *(arg for wid,prec). * %f, %g, %m, %p have reduced support, support for wid,prec,flags,*, but * less floating point range, no %e formatting for %g. */ int snprintf(char* str, size_t size, const char* format, ...) { int r; va_list args; va_start(args, format); r = vsnprintf(str, size, format, args); va_end(args); return r; } /** add padding to string */ static void print_pad(char** at, size_t* left, int* ret, char p, int num) { while(num--) { if(*left > 1) { *(*at)++ = p; (*left)--; } (*ret)++; } } /** get negative symbol, 0 if none */ static char get_negsign(int negative, int plus, int space) { if(negative) return '-'; if(plus) return '+'; if(space) return ' '; return 0; } #define PRINT_DEC_BUFSZ 32 /* 20 is enough for 64 bit decimals */ /** print decimal into buffer, returns length */ static int print_dec(char* buf, int max, unsigned int value) { int i = 0; if(value == 0) { if(max > 0) { buf[0] = '0'; i = 1; } } else while(value && i < max) { buf[i++] = '0' + value % 10; value /= 10; } return i; } /** print long decimal into buffer, returns length */ static int print_dec_l(char* buf, int max, unsigned long value) { int i = 0; if(value == 0) { if(max > 0) { buf[0] = '0'; i = 1; } } else while(value && i < max) { buf[i++] = '0' + value % 10; value /= 10; } return i; } /** print long decimal into buffer, returns length */ static int print_dec_ll(char* buf, int max, unsigned long long value) { int i = 0; if(value == 0) { if(max > 0) { buf[0] = '0'; i = 1; } } else while(value && i < max) { buf[i++] = '0' + value % 10; value /= 10; } return i; } /** print hex into buffer, returns length */ static int print_hex(char* buf, int max, unsigned int value) { const char* h = "0123456789abcdef"; int i = 0; if(value == 0) { if(max > 0) { buf[0] = '0'; i = 1; } } else while(value && i < max) { buf[i++] = h[value & 0x0f]; value >>= 4; } return i; } /** print long hex into buffer, returns length */ static int print_hex_l(char* buf, int max, unsigned long value) { const char* h = "0123456789abcdef"; int i = 0; if(value == 0) { if(max > 0) { buf[0] = '0'; i = 1; } } else while(value && i < max) { buf[i++] = h[value & 0x0f]; value >>= 4; } return i; } /** print long long hex into buffer, returns length */ static int print_hex_ll(char* buf, int max, unsigned long long value) { const char* h = "0123456789abcdef"; int i = 0; if(value == 0) { if(max > 0) { buf[0] = '0'; i = 1; } } else while(value && i < max) { buf[i++] = h[value & 0x0f]; value >>= 4; } return i; } /** copy string into result, reversed */ static void spool_str_rev(char** at, size_t* left, int* ret, const char* buf, int len) { int i = len; while(i) { if(*left > 1) { *(*at)++ = buf[--i]; (*left)--; } else --i; (*ret)++; } } /** copy string into result */ static void spool_str(char** at, size_t* left, int* ret, const char* buf, int len) { int i; for(i=0; i 1) { *(*at)++ = buf[i]; (*left)--; } (*ret)++; } } /** print number formatted */ static void print_num(char** at, size_t* left, int* ret, int minw, int precision, int prgiven, int zeropad, int minus, int plus, int space, int zero, int negative, char* buf, int len) { int w = len; /* excludes minus sign */ char s = get_negsign(negative, plus, space); if(minus) { /* left adjust the number into the field, space padding */ /* calc numw = [sign][zeroes][number] */ int numw = w; if(precision == 0 && zero) numw = 0; if(numw < precision) numw = precision; if(s) numw++; /* sign */ if(s) print_pad(at, left, ret, s, 1); /* number */ if(precision == 0 && zero) { /* "" for the number */ } else { if(w < precision) print_pad(at, left, ret, '0', precision - w); spool_str_rev(at, left, ret, buf, len); } /* spaces */ if(numw < minw) print_pad(at, left, ret, ' ', minw - numw); } else { /* pad on the left of the number */ /* calculate numw has width of [sign][zeroes][number] */ int numw = w; if(precision == 0 && zero) numw = 0; if(numw < precision) numw = precision; if(!prgiven && zeropad && numw < minw) numw = minw; else if(s) numw++; /* pad with spaces */ if(numw < minw) print_pad(at, left, ret, ' ', minw - numw); /* print sign (and one less zeropad if so) */ if(s) { print_pad(at, left, ret, s, 1); numw--; } /* pad with zeroes */ if(w < numw) print_pad(at, left, ret, '0', numw - w); if(precision == 0 && zero) return; /* print the characters for the value */ spool_str_rev(at, left, ret, buf, len); } } /** print %d and %i */ static void print_num_d(char** at, size_t* left, int* ret, int value, int minw, int precision, int prgiven, int zeropad, int minus, int plus, int space) { char buf[PRINT_DEC_BUFSZ]; int negative = (value < 0); int zero = (value == 0); int len = print_dec(buf, (int)sizeof(buf), (unsigned int)(negative?-value:value)); print_num(at, left, ret, minw, precision, prgiven, zeropad, minus, plus, space, zero, negative, buf, len); } /** print %ld and %li */ static void print_num_ld(char** at, size_t* left, int* ret, long value, int minw, int precision, int prgiven, int zeropad, int minus, int plus, int space) { char buf[PRINT_DEC_BUFSZ]; int negative = (value < 0); int zero = (value == 0); int len = print_dec_l(buf, (int)sizeof(buf), (unsigned long)(negative?-value:value)); print_num(at, left, ret, minw, precision, prgiven, zeropad, minus, plus, space, zero, negative, buf, len); } /** print %lld and %lli */ static void print_num_lld(char** at, size_t* left, int* ret, long long value, int minw, int precision, int prgiven, int zeropad, int minus, int plus, int space) { char buf[PRINT_DEC_BUFSZ]; int negative = (value < 0); int zero = (value == 0); int len = print_dec_ll(buf, (int)sizeof(buf), (unsigned long long)(negative?-value:value)); print_num(at, left, ret, minw, precision, prgiven, zeropad, minus, plus, space, zero, negative, buf, len); } /** print %u */ static void print_num_u(char** at, size_t* left, int* ret, unsigned int value, int minw, int precision, int prgiven, int zeropad, int minus, int plus, int space) { char buf[PRINT_DEC_BUFSZ]; int negative = 0; int zero = (value == 0); int len = print_dec(buf, (int)sizeof(buf), value); print_num(at, left, ret, minw, precision, prgiven, zeropad, minus, plus, space, zero, negative, buf, len); } /** print %lu */ static void print_num_lu(char** at, size_t* left, int* ret, unsigned long value, int minw, int precision, int prgiven, int zeropad, int minus, int plus, int space) { char buf[PRINT_DEC_BUFSZ]; int negative = 0; int zero = (value == 0); int len = print_dec_l(buf, (int)sizeof(buf), value); print_num(at, left, ret, minw, precision, prgiven, zeropad, minus, plus, space, zero, negative, buf, len); } /** print %llu */ static void print_num_llu(char** at, size_t* left, int* ret, unsigned long long value, int minw, int precision, int prgiven, int zeropad, int minus, int plus, int space) { char buf[PRINT_DEC_BUFSZ]; int negative = 0; int zero = (value == 0); int len = print_dec_ll(buf, (int)sizeof(buf), value); print_num(at, left, ret, minw, precision, prgiven, zeropad, minus, plus, space, zero, negative, buf, len); } /** print %x */ static void print_num_x(char** at, size_t* left, int* ret, unsigned int value, int minw, int precision, int prgiven, int zeropad, int minus, int plus, int space) { char buf[PRINT_DEC_BUFSZ]; int negative = 0; int zero = (value == 0); int len = print_hex(buf, (int)sizeof(buf), value); print_num(at, left, ret, minw, precision, prgiven, zeropad, minus, plus, space, zero, negative, buf, len); } /** print %lx */ static void print_num_lx(char** at, size_t* left, int* ret, unsigned long value, int minw, int precision, int prgiven, int zeropad, int minus, int plus, int space) { char buf[PRINT_DEC_BUFSZ]; int negative = 0; int zero = (value == 0); int len = print_hex_l(buf, (int)sizeof(buf), value); print_num(at, left, ret, minw, precision, prgiven, zeropad, minus, plus, space, zero, negative, buf, len); } /** print %llx */ static void print_num_llx(char** at, size_t* left, int* ret, unsigned long long value, int minw, int precision, int prgiven, int zeropad, int minus, int plus, int space) { char buf[PRINT_DEC_BUFSZ]; int negative = 0; int zero = (value == 0); int len = print_hex_ll(buf, (int)sizeof(buf), value); print_num(at, left, ret, minw, precision, prgiven, zeropad, minus, plus, space, zero, negative, buf, len); } /** print %llp */ static void print_num_llp(char** at, size_t* left, int* ret, void* value, int minw, int precision, int prgiven, int zeropad, int minus, int plus, int space) { char buf[PRINT_DEC_BUFSZ]; int negative = 0; int zero = (value == 0); #if defined(UINTPTR_MAX) && defined(UINT32_MAX) && (UINTPTR_MAX == UINT32_MAX) /* avoid warning about upcast on 32bit systems */ unsigned long long llvalue = (unsigned long)value; #else unsigned long long llvalue = (unsigned long long)value; #endif int len = print_hex_ll(buf, (int)sizeof(buf), llvalue); if(zero) { buf[0]=')'; buf[1]='l'; buf[2]='i'; buf[3]='n'; buf[4]='('; len = 5; } else { /* put '0x' in front of the (reversed) buffer result */ if(len < PRINT_DEC_BUFSZ) buf[len++] = 'x'; if(len < PRINT_DEC_BUFSZ) buf[len++] = '0'; } print_num(at, left, ret, minw, precision, prgiven, zeropad, minus, plus, space, zero, negative, buf, len); } #define PRINT_FLOAT_BUFSZ 64 /* xx.yy with 20.20 about the max */ /** spool remainder after the decimal point to buffer, in reverse */ static int print_remainder(char* buf, int max, double r, int prec) { unsigned long long cap = 1; unsigned long long value; int len, i; if(prec > 19) prec = 19; /* max we can do */ if(max < prec) return 0; for(i=0; i= 5) { value++; /* that might carry to numbers before the comma, if so, * just ignore that rounding. failure because 64bitprintout */ if(value >= cap) value = cap-1; } len = print_dec_ll(buf, max, value); while(len < prec) { /* pad with zeroes, e.g. if 0.0012 */ buf[len++] = '0'; } if(len < max) buf[len++] = '.'; return len; } /** spool floating point to buffer */ static int print_float(char* buf, int max, double value, int prec) { /* as xxx.xxx if prec==0, no '.', with prec decimals after . */ /* no conversion for NAN and INF, because we do not want to require linking with -lm. */ /* Thus, the conversions use 64bit integers to convert the numbers, * which makes 19 digits before and after the decimal point the max */ unsigned long long whole = (unsigned long long)value; double remain = value - (double)whole; int len = 0; if(prec != 0) len = print_remainder(buf, max, remain, prec); len += print_dec_ll(buf+len, max-len, whole); return len; } /** print %f */ static void print_num_f(char** at, size_t* left, int* ret, double value, int minw, int precision, int prgiven, int zeropad, int minus, int plus, int space) { char buf[PRINT_FLOAT_BUFSZ]; int negative = (value < 0); int zero = 0; int len; if(!prgiven) precision = 6; len = print_float(buf, (int)sizeof(buf), negative?-value:value, precision); print_num(at, left, ret, minw, 1, 0, zeropad, minus, plus, space, zero, negative, buf, len); } /* rudimentary %g support */ static int print_float_g(char* buf, int max, double value, int prec) { unsigned long long whole = (unsigned long long)value; double remain = value - (double)whole; int before = 0; int len = 0; /* number of digits before the decimal point */ while(whole > 0) { before++; whole /= 10; } whole = (unsigned long long)value; if(prec > before && remain != 0.0) { /* see if the last decimals are zero, if so, skip them */ len = print_remainder(buf, max, remain, prec-before); while(len > 0 && buf[0]=='0') { memmove(buf, buf+1, --len); } } len += print_dec_ll(buf+len, max-len, whole); return len; } /** print %g */ static void print_num_g(char** at, size_t* left, int* ret, double value, int minw, int precision, int prgiven, int zeropad, int minus, int plus, int space) { char buf[PRINT_FLOAT_BUFSZ]; int negative = (value < 0); int zero = 0; int len; if(!prgiven) precision = 6; if(precision == 0) precision = 1; len = print_float_g(buf, (int)sizeof(buf), negative?-value:value, precision); print_num(at, left, ret, minw, 1, 0, zeropad, minus, plus, space, zero, negative, buf, len); } /** strnlen (compat implementation) */ static int my_strnlen(const char* s, int max) { int i; for(i=0; i 1) { *at++ = *fmt++; left--; } else fmt++; ret++; } /* see if we are at end */ if(!*fmt) break; /* fetch next argument % designation from format string */ fmt++; /* skip the '%' */ /********************************/ /* get the argument designation */ /********************************/ /* we must do this vararg stuff inside this function for * portability. Hence, get_designation, and print_designation * are not their own functions. */ /* printout designation: * conversion specifier: x, d, u, s, c, n, m, p * flags: # not supported * 0 zeropad (on the left) * - left adjust (right by default) * ' ' printspace for positive number (in - position). * + alwayssign * fieldwidth: [1-9][0-9]* minimum field width. * if this is * then type int next argument specifies the minwidth. * if this is negative, the - flag is set (with positive width). * precision: period[digits]*, %.2x. * if this is * then type int next argument specifies the precision. * just '.' or negative value means precision=0. * this is mindigits to print for d, i, u, x * this is aftercomma digits for f * this is max number significant digits for g * maxnumber characters to be printed for s * length: 0-none (int), 1-l (long), 2-ll (long long) * notsupported: hh (char), h (short), L (long double), q, j, z, t * Does not support %m$ and *m$ argument designation as array indices. * Does not support %#x * */ minw = 0; precision = 1; prgiven = 0; zeropad = 0; minus = 0; plus = 0; space = 0; length = 0; /* get flags in any order */ for(;;) { if(*fmt == '0') zeropad = 1; else if(*fmt == '-') minus = 1; else if(*fmt == '+') plus = 1; else if(*fmt == ' ') space = 1; else break; fmt++; } /* field width */ if(*fmt == '*') { fmt++; /* skip char */ minw = va_arg(arg, int); if(minw < 0) { minus = 1; minw = -minw; } } else while(*fmt >= '0' && *fmt <= '9') { minw = minw*10 + (*fmt++)-'0'; } /* precision */ if(*fmt == '.') { fmt++; /* skip period */ prgiven = 1; precision = 0; if(*fmt == '*') { fmt++; /* skip char */ precision = va_arg(arg, int); if(precision < 0) precision = 0; } else while(*fmt >= '0' && *fmt <= '9') { precision = precision*10 + (*fmt++)-'0'; } } /* length */ if(*fmt == 'l') { fmt++; /* skip char */ length = 1; if(*fmt == 'l') { fmt++; /* skip char */ length = 2; } } /* get the conversion */ if(!*fmt) conv = 0; else conv = *fmt++; /***********************************/ /* print that argument designation */ /***********************************/ switch(conv) { case 'i': case 'd': if(length == 0) print_num_d(&at, &left, &ret, va_arg(arg, int), minw, precision, prgiven, zeropad, minus, plus, space); else if(length == 1) print_num_ld(&at, &left, &ret, va_arg(arg, long), minw, precision, prgiven, zeropad, minus, plus, space); else if(length == 2) print_num_lld(&at, &left, &ret, va_arg(arg, long long), minw, precision, prgiven, zeropad, minus, plus, space); break; case 'u': if(length == 0) print_num_u(&at, &left, &ret, va_arg(arg, unsigned int), minw, precision, prgiven, zeropad, minus, plus, space); else if(length == 1) print_num_lu(&at, &left, &ret, va_arg(arg, unsigned long), minw, precision, prgiven, zeropad, minus, plus, space); else if(length == 2) print_num_llu(&at, &left, &ret, va_arg(arg, unsigned long long), minw, precision, prgiven, zeropad, minus, plus, space); break; case 'x': if(length == 0) print_num_x(&at, &left, &ret, va_arg(arg, unsigned int), minw, precision, prgiven, zeropad, minus, plus, space); else if(length == 1) print_num_lx(&at, &left, &ret, va_arg(arg, unsigned long), minw, precision, prgiven, zeropad, minus, plus, space); else if(length == 2) print_num_llx(&at, &left, &ret, va_arg(arg, unsigned long long), minw, precision, prgiven, zeropad, minus, plus, space); break; case 's': print_str(&at, &left, &ret, va_arg(arg, char*), minw, precision, prgiven, minus); break; case 'c': print_char(&at, &left, &ret, va_arg(arg, int), minw, minus); break; case 'n': *va_arg(arg, int*) = ret; break; case 'm': print_str(&at, &left, &ret, strerror(errno), minw, precision, prgiven, minus); break; case 'p': print_num_llp(&at, &left, &ret, va_arg(arg, void*), minw, precision, prgiven, zeropad, minus, plus, space); break; case '%': print_pad(&at, &left, &ret, '%', 1); break; case 'f': print_num_f(&at, &left, &ret, va_arg(arg, double), minw, precision, prgiven, zeropad, minus, plus, space); break; case 'g': print_num_g(&at, &left, &ret, va_arg(arg, double), minw, precision, prgiven, zeropad, minus, plus, space); break; /* unknown */ default: case 0: break; } } /* zero terminate */ if(left > 0) *at = 0; return ret; } #ifdef SNPRINTF_TEST /** do tests */ #undef snprintf #define DOTEST(bufsz, result, retval, ...) do { \ char buf[bufsz]; \ printf("now test %s\n", #__VA_ARGS__); \ int r=my_snprintf(buf, sizeof(buf), __VA_ARGS__); \ if(r != retval || strcmp(buf, result) != 0) { \ printf("error test(%s) was \"%s\":%d\n", \ ""#bufsz", "#result", "#retval", "#__VA_ARGS__, \ buf, r); \ exit(1); \ } \ r=snprintf(buf, sizeof(buf), __VA_ARGS__); \ if(r != retval || strcmp(buf, result) != 0) { \ printf("error test(%s) differs with system, \"%s\":%d\n", \ ""#bufsz", "#result", "#retval", "#__VA_ARGS__, \ buf, r); \ exit(1); \ } \ printf("test(\"%s\":%d) passed\n", buf, r); \ } while(0); /** test program */ int main(void) { int x = 0; /* bufsize, expectedstring, expectedretval, snprintf arguments */ DOTEST(1024, "hello", 5, "hello"); DOTEST(1024, "h", 1, "h"); /* warning from gcc for format string, but it does work * DOTEST(1024, "", 0, ""); */ DOTEST(3, "he", 5, "hello"); DOTEST(1, "", 7, "%d", 7823089); /* test positive numbers */ DOTEST(1024, "0", 1, "%d", 0); DOTEST(1024, "1", 1, "%d", 1); DOTEST(1024, "9", 1, "%d", 9); DOTEST(1024, "15", 2, "%d", 15); DOTEST(1024, "ab15cd", 6, "ab%dcd", 15); DOTEST(1024, "167", 3, "%d", 167); DOTEST(1024, "7823089", 7, "%d", 7823089); DOTEST(1024, " 12", 3, "%3d", 12); DOTEST(1024, "012", 3, "%.3d", 12); DOTEST(1024, "012", 3, "%3.3d", 12); DOTEST(1024, "012", 3, "%03d", 12); DOTEST(1024, " 012", 4, "%4.3d", 12); DOTEST(1024, "", 0, "%.0d", 0); /* test negative numbers */ DOTEST(1024, "-1", 2, "%d", -1); DOTEST(1024, "-12", 3, "%3d", -12); DOTEST(1024, " -2", 3, "%3d", -2); DOTEST(1024, "-012", 4, "%.3d", -12); DOTEST(1024, "-012", 4, "%3.3d", -12); DOTEST(1024, "-012", 4, "%4.3d", -12); DOTEST(1024, " -012", 5, "%5.3d", -12); DOTEST(1024, "-12", 3, "%03d", -12); DOTEST(1024, "-02", 3, "%03d", -2); DOTEST(1024, "-15", 3, "%d", -15); DOTEST(1024, "-7307", 5, "%d", -7307); DOTEST(1024, "-12 ", 5, "%-5d", -12); DOTEST(1024, "-00012", 6, "%-.5d", -12); /* test + and space flags */ DOTEST(1024, "+12", 3, "%+d", 12); DOTEST(1024, " 12", 3, "% d", 12); /* test %u */ DOTEST(1024, "12", 2, "%u", 12); DOTEST(1024, "0", 1, "%u", 0); DOTEST(1024, "4294967295", 10, "%u", 0xffffffff); /* test %x */ DOTEST(1024, "0", 1, "%x", 0); DOTEST(1024, "c", 1, "%x", 12); DOTEST(1024, "12ab34cd", 8, "%x", 0x12ab34cd); /* test %llu, %lld */ DOTEST(1024, "18446744073709551615", 20, "%llu", (long long)0xffffffffffffffff); DOTEST(1024, "-9223372036854775808", 20, "%lld", (long long)0x8000000000000000); DOTEST(1024, "9223372036854775808", 19, "%llu", (long long)0x8000000000000000); /* test %s */ DOTEST(1024, "hello", 5, "%s", "hello"); DOTEST(1024, " hello", 10, "%10s", "hello"); DOTEST(1024, "hello ", 10, "%-10s", "hello"); DOTEST(1024, "he", 2, "%.2s", "hello"); DOTEST(1024, " he", 4, "%4.2s", "hello"); DOTEST(1024, " h", 4, "%4.2s", "h"); /* test %c */ DOTEST(1024, "a", 1, "%c", 'a'); /* warning from gcc for format string, but it does work DOTEST(1024, " a", 5, "%5c", 'a'); DOTEST(1024, "a", 1, "%.0c", 'a'); */ /* test %n */ DOTEST(1024, "hello", 5, "hello%n", &x); if(x != 5) { printf("the %%n failed\n"); exit(1); } /* test %m */ errno = 0; DOTEST(1024, "Success", 7, "%m"); /* test %p */ DOTEST(1024, "0x10", 4, "%p", (void*)0x10); DOTEST(1024, "(nil)", 5, "%p", (void*)0x0); /* test %% */ DOTEST(1024, "%", 1, "%%"); /* test %f */ DOTEST(1024, "0.000000", 8, "%f", 0.0); DOTEST(1024, "0.00", 4, "%.2f", 0.0); /* differs, "-0.00" DOTEST(1024, "0.00", 4, "%.2f", -0.0); */ DOTEST(1024, "234.00", 6, "%.2f", 234.005); DOTEST(1024, "8973497.1246", 12, "%.4f", 8973497.12456); DOTEST(1024, "-12.000000", 10, "%f", -12.0); DOTEST(1024, "6", 1, "%.0f", 6.0); DOTEST(1024, "6", 1, "%g", 6.0); DOTEST(1024, "6.1", 3, "%g", 6.1); DOTEST(1024, "6.15", 4, "%g", 6.15); /* These format strings are from the code of NSD, Unbound, ldns */ DOTEST(1024, "abcdef", 6, "%s", "abcdef"); DOTEST(1024, "005", 3, "%03u", 5); DOTEST(1024, "12345", 5, "%03u", 12345); DOTEST(1024, "5", 1, "%d", 5); DOTEST(1024, "(nil)", 5, "%p", NULL); DOTEST(1024, "12345", 5, "%ld", (long)12345); DOTEST(1024, "12345", 5, "%lu", (long)12345); DOTEST(1024, " 12345", 12, "%12u", (unsigned)12345); DOTEST(1024, "12345", 5, "%u", (unsigned)12345); DOTEST(1024, "12345", 5, "%llu", (unsigned long long)12345); DOTEST(1024, "12345", 5, "%x", 0x12345); DOTEST(1024, "12345", 5, "%llx", (long long)0x12345); DOTEST(1024, "012345", 6, "%6.6d", 12345); DOTEST(1024, "012345", 6, "%6.6u", 12345); DOTEST(1024, "1234.54", 7, "%g", 1234.54); DOTEST(1024, "123456789.54", 12, "%.12g", 123456789.54); DOTEST(1024, "3456789123456.54", 16, "%.16g", 3456789123456.54); /* %24g does not work with 24 digits, not enough accuracy, * the first 16 digits are correct */ DOTEST(1024, "12345", 5, "%3.3d", 12345); DOTEST(1024, "000", 3, "%3.3d", 0); DOTEST(1024, "001", 3, "%3.3d", 1); DOTEST(1024, "012", 3, "%3.3d", 12); DOTEST(1024, "-012", 4, "%3.3d", -12); DOTEST(1024, "he", 2, "%.2s", "hello"); DOTEST(1024, "helloworld", 10, "%s%s", "hello", "world"); DOTEST(1024, "he", 2, "%.*s", 2, "hello"); DOTEST(1024, " hello", 7, "%*s", 7, "hello"); DOTEST(1024, "hello ", 7, "%*s", -7, "hello"); DOTEST(1024, "0", 1, "%c", '0'); DOTEST(1024, "A", 1, "%c", 'A'); DOTEST(1024, "", 1, "%c", 0); DOTEST(1024, "\010", 1, "%c", 8); DOTEST(1024, "%", 1, "%%"); DOTEST(1024, "0a", 2, "%02x", 0x0a); DOTEST(1024, "bd", 2, "%02x", 0xbd); DOTEST(1024, "12", 2, "%02ld", (long)12); DOTEST(1024, "02", 2, "%02ld", (long)2); DOTEST(1024, "02", 2, "%02u", (unsigned)2); DOTEST(1024, "765432", 6, "%05u", (unsigned)765432); DOTEST(1024, "10.234", 6, "%0.3f", 10.23421); DOTEST(1024, "123456.234", 10, "%0.3f", 123456.23421); DOTEST(1024, "123456789.234", 13, "%0.3f", 123456789.23421); DOTEST(1024, "123456.23", 9, "%.2f", 123456.23421); DOTEST(1024, "123456", 6, "%.0f", 123456.23421); DOTEST(1024, "0123", 4, "%.4x", 0x0123); DOTEST(1024, "00000123", 8, "%.8x", 0x0123); DOTEST(1024, "ffeb0cde", 8, "%.8x", 0xffeb0cde); DOTEST(1024, " 987654321", 10, "%10lu", (unsigned long)987654321); DOTEST(1024, " 987654321", 12, "%12lu", (unsigned long)987654321); DOTEST(1024, "987654321", 9, "%i", 987654321); DOTEST(1024, "-87654321", 9, "%i", -87654321); DOTEST(1024, "hello ", 16, "%-16s", "hello"); DOTEST(1024, " ", 16, "%-16s", ""); DOTEST(1024, "a ", 16, "%-16s", "a"); DOTEST(1024, "foobarfoobar ", 16, "%-16s", "foobarfoobar"); DOTEST(1024, "foobarfoobarfoobar", 18, "%-16s", "foobarfoobarfoobar"); /* combined expressions */ DOTEST(1024, "foo 1.0 size 512 edns", 21, "foo %s size %d %s%s", "1.0", 512, "", "edns"); DOTEST(15, "foo 1.0 size 5", 21, "foo %s size %d %s%s", "1.0", 512, "", "edns"); DOTEST(1024, "packet 1203ceff id", 18, "packet %2.2x%2.2x%2.2x%2.2x id", 0x12, 0x03, 0xce, 0xff); DOTEST(1024, "/tmp/testbound_123abcd.tmp", 26, "/tmp/testbound_%u%s%s.tmp", 123, "ab", "cd"); return 0; } #endif /* SNPRINTF_TEST */ ldns-1.6.17/compat/b64_pton.c0000664000175100017510000002065012264060151015200 0ustar willemwillem/* * Copyright (c) 1996, 1998 by Internet Software Consortium. * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above * copyright notice and this permission notice appear in all copies. * * THE SOFTWARE IS PROVIDED "AS IS" AND INTERNET SOFTWARE CONSORTIUM DISCLAIMS * ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL INTERNET SOFTWARE * CONSORTIUM BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS * SOFTWARE. */ /* * Portions Copyright (c) 1995 by International Business Machines, Inc. * * International Business Machines, Inc. (hereinafter called IBM) grants * permission under its copyrights to use, copy, modify, and distribute this * Software with or without fee, provided that the above copyright notice and * all paragraphs of this notice appear in all copies, and that the name of IBM * not be used in connection with the marketing of any product incorporating * the Software or modifications thereof, without specific, written prior * permission. * * To the extent it has a right to do so, IBM grants an immunity from suit * under its patents, if any, for the use, sale or manufacture of products to * the extent that such products are used for performing Domain Name System * dynamic updates in TCP/IP networks by means of the Software. No immunity is * granted for any product per se or for any other function of any product. * * THE SOFTWARE IS PROVIDED "AS IS", AND IBM DISCLAIMS ALL WARRANTIES, * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A * PARTICULAR PURPOSE. IN NO EVENT SHALL IBM BE LIABLE FOR ANY SPECIAL, * DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER ARISING * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE, EVEN * IF IBM IS APPRISED OF THE POSSIBILITY OF SUCH DAMAGES. */ #include #include #include #include static const char Base64[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; static const char Pad64 = '='; /* (From RFC1521 and draft-ietf-dnssec-secext-03.txt) The following encoding technique is taken from RFC 1521 by Borenstein and Freed. It is reproduced here in a slightly edited form for convenience. A 65-character subset of US-ASCII is used, enabling 6 bits to be represented per printable character. (The extra 65th character, "=", is used to signify a special processing function.) The encoding process represents 24-bit groups of input bits as output strings of 4 encoded characters. Proceeding from left to right, a 24-bit input group is formed by concatenating 3 8-bit input groups. These 24 bits are then treated as 4 concatenated 6-bit groups, each of which is translated into a single digit in the base64 alphabet. Each 6-bit group is used as an index into an array of 64 printable characters. The character referenced by the index is placed in the output string. Table 1: The Base64 Alphabet Value Encoding Value Encoding Value Encoding Value Encoding 0 A 17 R 34 i 51 z 1 B 18 S 35 j 52 0 2 C 19 T 36 k 53 1 3 D 20 U 37 l 54 2 4 E 21 V 38 m 55 3 5 F 22 W 39 n 56 4 6 G 23 X 40 o 57 5 7 H 24 Y 41 p 58 6 8 I 25 Z 42 q 59 7 9 J 26 a 43 r 60 8 10 K 27 b 44 s 61 9 11 L 28 c 45 t 62 + 12 M 29 d 46 u 63 / 13 N 30 e 47 v 14 O 31 f 48 w (pad) = 15 P 32 g 49 x 16 Q 33 h 50 y Special processing is performed if fewer than 24 bits are available at the end of the data being encoded. A full encoding quantum is always completed at the end of a quantity. When fewer than 24 input bits are available in an input group, zero bits are added (on the right) to form an integral number of 6-bit groups. Padding at the end of the data is performed using the '=' character. Since all base64 input is an integral number of octets, only the ------------------------------------------------- following cases can arise: (1) the final quantum of encoding input is an integral multiple of 24 bits; here, the final unit of encoded output will be an integral multiple of 4 characters with no "=" padding, (2) the final quantum of encoding input is exactly 8 bits; here, the final unit of encoded output will be two characters followed by two "=" padding characters, or (3) the final quantum of encoding input is exactly 16 bits; here, the final unit of encoded output will be three characters followed by one "=" padding character. */ /* skips all whitespace anywhere. converts characters, four at a time, starting at (or after) src from base - 64 numbers into three 8 bit bytes in the target area. it returns the number of data bytes stored at the target, or -1 on error. */ int ldns_b64_pton(char const *src, uint8_t *target, size_t targsize) { int tarindex, state, ch; char *pos; state = 0; tarindex = 0; if (strlen(src) == 0) { return 0; } while ((ch = *src++) != '\0') { if (isspace((unsigned char)ch)) /* Skip whitespace anywhere. */ continue; if (ch == Pad64) break; pos = strchr(Base64, ch); if (pos == 0) { /* A non-base64 character. */ return (-1); } switch (state) { case 0: if (target) { if ((size_t)tarindex >= targsize) return (-1); target[tarindex] = (pos - Base64) << 2; } state = 1; break; case 1: if (target) { if ((size_t)tarindex + 1 >= targsize) return (-1); target[tarindex] |= (pos - Base64) >> 4; target[tarindex+1] = ((pos - Base64) & 0x0f) << 4 ; } tarindex++; state = 2; break; case 2: if (target) { if ((size_t)tarindex + 1 >= targsize) return (-1); target[tarindex] |= (pos - Base64) >> 2; target[tarindex+1] = ((pos - Base64) & 0x03) << 6; } tarindex++; state = 3; break; case 3: if (target) { if ((size_t)tarindex >= targsize) return (-1); target[tarindex] |= (pos - Base64); } tarindex++; state = 0; break; default: abort(); } } /* * We are done decoding Base-64 chars. Let's see if we ended * on a byte boundary, and/or with erroneous trailing characters. */ if (ch == Pad64) { /* We got a pad char. */ ch = *src++; /* Skip it, get next. */ switch (state) { case 0: /* Invalid = in first position */ case 1: /* Invalid = in second position */ return (-1); case 2: /* Valid, means one byte of info */ /* Skip any number of spaces. */ for ((void)NULL; ch != '\0'; ch = *src++) if (!isspace((unsigned char)ch)) break; /* Make sure there is another trailing = sign. */ if (ch != Pad64) return (-1); ch = *src++; /* Skip the = */ /* Fall through to "single trailing =" case. */ /* FALLTHROUGH */ case 3: /* Valid, means two bytes of info */ /* * We know this char is an =. Is there anything but * whitespace after it? */ for ((void)NULL; ch != '\0'; ch = *src++) if (!isspace((unsigned char)ch)) return (-1); /* * Now make sure for cases 2 and 3 that the "extra" * bits that slopped past the last full byte were * zeros. If we don't check them, they become a * subliminal channel. */ if (target && target[tarindex] != 0) return (-1); } } else { /* * We ended by seeing the end of the string. Make sure we * have no partial bytes lying around. */ if (state != 0) return (-1); } return (tarindex); } ldns-1.6.17/wire2host.c0000664000175100017510000003107312264060151014211 0ustar willemwillem/* * wire2host.c * * conversion routines from the wire to the host * format. * This will usually just a re-ordering of the * data (as we store it in network format) * * a Net::DNS like library for C * * (c) NLnet Labs, 2004-2006 * * See the file LICENSE for the license */ #include #include /*#include */ #include #include /* * Set of macro's to deal with the dns message header as specified * in RFC1035 in portable way. * */ /* * * 1 1 1 1 1 1 * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 * +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+ * | ID | * +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+ * |QR| Opcode |AA|TC|RD|RA| Z|AD|CD| RCODE | * +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+ * | QDCOUNT | * +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+ * | ANCOUNT | * +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+ * | NSCOUNT | * +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+ * | ARCOUNT | * +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+ * */ /* allocates memory to *dname! */ ldns_status ldns_wire2dname(ldns_rdf **dname, const uint8_t *wire, size_t max, size_t *pos) { uint8_t label_size; uint16_t pointer_target; uint8_t pointer_target_buf[2]; size_t dname_pos = 0; size_t uncompressed_length = 0; size_t compression_pos = 0; uint8_t tmp_dname[LDNS_MAX_DOMAINLEN]; unsigned int pointer_count = 0; if (pos == NULL) { return LDNS_STATUS_WIRE_RDATA_ERR; } if (*pos >= max) { return LDNS_STATUS_PACKET_OVERFLOW; } label_size = wire[*pos]; while (label_size > 0) { /* compression */ while (label_size >= 192) { if (compression_pos == 0) { compression_pos = *pos + 2; } pointer_count++; /* remove first two bits */ if (*pos + 2 > max) { return LDNS_STATUS_PACKET_OVERFLOW; } pointer_target_buf[0] = wire[*pos] & 63; pointer_target_buf[1] = wire[*pos + 1]; pointer_target = ldns_read_uint16(pointer_target_buf); if (pointer_target == 0) { return LDNS_STATUS_INVALID_POINTER; } else if (pointer_target >= max) { return LDNS_STATUS_INVALID_POINTER; } else if (pointer_count > LDNS_MAX_POINTERS) { return LDNS_STATUS_INVALID_POINTER; } *pos = pointer_target; label_size = wire[*pos]; } if(label_size == 0) break; /* break from pointer to 0 byte */ if (label_size > LDNS_MAX_LABELLEN) { return LDNS_STATUS_LABEL_OVERFLOW; } if (*pos + 1 + label_size > max) { return LDNS_STATUS_LABEL_OVERFLOW; } /* check space for labelcount itself */ if (dname_pos + 1 > LDNS_MAX_DOMAINLEN) { return LDNS_STATUS_DOMAINNAME_OVERFLOW; } tmp_dname[dname_pos] = label_size; if (label_size > 0) { dname_pos++; } *pos = *pos + 1; if (dname_pos + label_size > LDNS_MAX_DOMAINLEN) { return LDNS_STATUS_DOMAINNAME_OVERFLOW; } memcpy(&tmp_dname[dname_pos], &wire[*pos], label_size); uncompressed_length += label_size + 1; dname_pos += label_size; *pos = *pos + label_size; if (*pos < max) { label_size = wire[*pos]; } } if (compression_pos > 0) { *pos = compression_pos; } else { *pos = *pos + 1; } if (dname_pos >= LDNS_MAX_DOMAINLEN) { return LDNS_STATUS_DOMAINNAME_OVERFLOW; } tmp_dname[dname_pos] = 0; dname_pos++; *dname = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_DNAME, (uint16_t) dname_pos, tmp_dname); if (!*dname) { return LDNS_STATUS_MEM_ERR; } return LDNS_STATUS_OK; } /* maybe make this a goto error so data can be freed or something/ */ #define LDNS_STATUS_CHECK_RETURN(st) {if (st != LDNS_STATUS_OK) { return st; }} #define LDNS_STATUS_CHECK_GOTO(st, label) {if (st != LDNS_STATUS_OK) { /*printf("STG %s:%d: status code %d\n", __FILE__, __LINE__, st);*/ goto label; }} ldns_status ldns_wire2rdf(ldns_rr *rr, const uint8_t *wire, size_t max, size_t *pos) { size_t end; size_t cur_rdf_length; uint8_t rdf_index; uint8_t *data; uint16_t rd_length; ldns_rdf *cur_rdf = NULL; ldns_rdf_type cur_rdf_type; const ldns_rr_descriptor *descriptor; ldns_status status; assert(rr != NULL); descriptor = ldns_rr_descript(ldns_rr_get_type(rr)); if (*pos + 2 > max) { return LDNS_STATUS_PACKET_OVERFLOW; } rd_length = ldns_read_uint16(&wire[*pos]); *pos = *pos + 2; if (*pos + rd_length > max) { return LDNS_STATUS_PACKET_OVERFLOW; } end = *pos + (size_t) rd_length; rdf_index = 0; while (*pos < end && rdf_index < ldns_rr_descriptor_maximum(descriptor)) { cur_rdf_length = 0; cur_rdf_type = ldns_rr_descriptor_field_type( descriptor, rdf_index); /* handle special cases immediately, set length for fixed length rdata and do them below */ switch (cur_rdf_type) { case LDNS_RDF_TYPE_DNAME: status = ldns_wire2dname(&cur_rdf, wire, max, pos); LDNS_STATUS_CHECK_RETURN(status); break; case LDNS_RDF_TYPE_CLASS: case LDNS_RDF_TYPE_ALG: case LDNS_RDF_TYPE_INT8: cur_rdf_length = LDNS_RDF_SIZE_BYTE; break; case LDNS_RDF_TYPE_TYPE: case LDNS_RDF_TYPE_INT16: case LDNS_RDF_TYPE_CERT_ALG: cur_rdf_length = LDNS_RDF_SIZE_WORD; break; case LDNS_RDF_TYPE_TIME: case LDNS_RDF_TYPE_INT32: case LDNS_RDF_TYPE_A: case LDNS_RDF_TYPE_PERIOD: cur_rdf_length = LDNS_RDF_SIZE_DOUBLEWORD; break; case LDNS_RDF_TYPE_TSIGTIME: case LDNS_RDF_TYPE_EUI48: cur_rdf_length = LDNS_RDF_SIZE_6BYTES; break; case LDNS_RDF_TYPE_ILNP64: case LDNS_RDF_TYPE_EUI64: cur_rdf_length = LDNS_RDF_SIZE_8BYTES; break; case LDNS_RDF_TYPE_AAAA: cur_rdf_length = LDNS_RDF_SIZE_16BYTES; break; case LDNS_RDF_TYPE_STR: case LDNS_RDF_TYPE_NSEC3_SALT: case LDNS_RDF_TYPE_TAG: /* len is stored in first byte * it should be in the rdf too, so just * copy len+1 from this position */ cur_rdf_length = ((size_t) wire[*pos]) + 1; break; case LDNS_RDF_TYPE_INT16_DATA: if (*pos + 2 > end) { return LDNS_STATUS_PACKET_OVERFLOW; } cur_rdf_length = (size_t) ldns_read_uint16(&wire[*pos]) + 2; break; case LDNS_RDF_TYPE_HIP: if (*pos + 4 > end) { return LDNS_STATUS_PACKET_OVERFLOW; } cur_rdf_length = (size_t) wire[*pos] + (size_t) ldns_read_uint16(&wire[*pos + 2]) + 4; break; case LDNS_RDF_TYPE_B32_EXT: case LDNS_RDF_TYPE_NSEC3_NEXT_OWNER: /* length is stored in first byte */ cur_rdf_length = ((size_t) wire[*pos]) + 1; break; case LDNS_RDF_TYPE_APL: case LDNS_RDF_TYPE_B64: case LDNS_RDF_TYPE_HEX: case LDNS_RDF_TYPE_NSEC: case LDNS_RDF_TYPE_UNKNOWN: case LDNS_RDF_TYPE_SERVICE: case LDNS_RDF_TYPE_LOC: case LDNS_RDF_TYPE_WKS: case LDNS_RDF_TYPE_NSAP: case LDNS_RDF_TYPE_ATMA: case LDNS_RDF_TYPE_IPSECKEY: case LDNS_RDF_TYPE_LONG_STR: case LDNS_RDF_TYPE_NONE: /* * Read to end of rr rdata */ cur_rdf_length = end - *pos; break; } /* fixed length rdata */ if (cur_rdf_length > 0) { if (cur_rdf_length + *pos > end) { return LDNS_STATUS_PACKET_OVERFLOW; } data = LDNS_XMALLOC(uint8_t, rd_length); if (!data) { return LDNS_STATUS_MEM_ERR; } memcpy(data, &wire[*pos], cur_rdf_length); cur_rdf = ldns_rdf_new(cur_rdf_type, cur_rdf_length, data); *pos = *pos + cur_rdf_length; } if (cur_rdf) { ldns_rr_push_rdf(rr, cur_rdf); cur_rdf = NULL; } rdf_index++; } /* while (rdf_index < ldns_rr_descriptor_maximum(descriptor)) */ return LDNS_STATUS_OK; } /* TODO: can *pos be incremented at READ_INT? or maybe use something like RR_CLASS(wire)? uhhm Jelte?? */ ldns_status ldns_wire2rr(ldns_rr **rr_p, const uint8_t *wire, size_t max, size_t *pos, ldns_pkt_section section) { ldns_rdf *owner = NULL; ldns_rr *rr = ldns_rr_new(); ldns_status status; status = ldns_wire2dname(&owner, wire, max, pos); LDNS_STATUS_CHECK_GOTO(status, status_error); ldns_rr_set_owner(rr, owner); if (*pos + 4 > max) { status = LDNS_STATUS_PACKET_OVERFLOW; goto status_error; } ldns_rr_set_type(rr, ldns_read_uint16(&wire[*pos])); *pos = *pos + 2; ldns_rr_set_class(rr, ldns_read_uint16(&wire[*pos])); *pos = *pos + 2; if (section != LDNS_SECTION_QUESTION) { if (*pos + 4 > max) { status = LDNS_STATUS_PACKET_OVERFLOW; goto status_error; } ldns_rr_set_ttl(rr, ldns_read_uint32(&wire[*pos])); *pos = *pos + 4; status = ldns_wire2rdf(rr, wire, max, pos); LDNS_STATUS_CHECK_GOTO(status, status_error); ldns_rr_set_question(rr, false); } else { ldns_rr_set_question(rr, true); } *rr_p = rr; return LDNS_STATUS_OK; status_error: ldns_rr_free(rr); return status; } static ldns_status ldns_wire2pkt_hdr(ldns_pkt *packet, const uint8_t *wire, size_t max, size_t *pos) { if (*pos + LDNS_HEADER_SIZE > max) { return LDNS_STATUS_WIRE_INCOMPLETE_HEADER; } else { ldns_pkt_set_id(packet, LDNS_ID_WIRE(wire)); ldns_pkt_set_qr(packet, LDNS_QR_WIRE(wire)); ldns_pkt_set_opcode(packet, LDNS_OPCODE_WIRE(wire)); ldns_pkt_set_aa(packet, LDNS_AA_WIRE(wire)); ldns_pkt_set_tc(packet, LDNS_TC_WIRE(wire)); ldns_pkt_set_rd(packet, LDNS_RD_WIRE(wire)); ldns_pkt_set_ra(packet, LDNS_RA_WIRE(wire)); ldns_pkt_set_ad(packet, LDNS_AD_WIRE(wire)); ldns_pkt_set_cd(packet, LDNS_CD_WIRE(wire)); ldns_pkt_set_rcode(packet, LDNS_RCODE_WIRE(wire)); ldns_pkt_set_qdcount(packet, LDNS_QDCOUNT(wire)); ldns_pkt_set_ancount(packet, LDNS_ANCOUNT(wire)); ldns_pkt_set_nscount(packet, LDNS_NSCOUNT(wire)); ldns_pkt_set_arcount(packet, LDNS_ARCOUNT(wire)); *pos += LDNS_HEADER_SIZE; return LDNS_STATUS_OK; } } ldns_status ldns_buffer2pkt_wire(ldns_pkt **packet, ldns_buffer *buffer) { /* lazy */ return ldns_wire2pkt(packet, ldns_buffer_begin(buffer), ldns_buffer_limit(buffer)); } ldns_status ldns_wire2pkt(ldns_pkt **packet_p, const uint8_t *wire, size_t max) { size_t pos = 0; uint16_t i; ldns_rr *rr; ldns_pkt *packet = ldns_pkt_new(); ldns_status status = LDNS_STATUS_OK; int have_edns = 0; uint8_t data[4]; status = ldns_wire2pkt_hdr(packet, wire, max, &pos); LDNS_STATUS_CHECK_GOTO(status, status_error); for (i = 0; i < ldns_pkt_qdcount(packet); i++) { status = ldns_wire2rr(&rr, wire, max, &pos, LDNS_SECTION_QUESTION); if (status == LDNS_STATUS_PACKET_OVERFLOW) { status = LDNS_STATUS_WIRE_INCOMPLETE_QUESTION; } LDNS_STATUS_CHECK_GOTO(status, status_error); if (!ldns_rr_list_push_rr(ldns_pkt_question(packet), rr)) { ldns_pkt_free(packet); return LDNS_STATUS_INTERNAL_ERR; } } for (i = 0; i < ldns_pkt_ancount(packet); i++) { status = ldns_wire2rr(&rr, wire, max, &pos, LDNS_SECTION_ANSWER); if (status == LDNS_STATUS_PACKET_OVERFLOW) { status = LDNS_STATUS_WIRE_INCOMPLETE_ANSWER; } LDNS_STATUS_CHECK_GOTO(status, status_error); if (!ldns_rr_list_push_rr(ldns_pkt_answer(packet), rr)) { ldns_pkt_free(packet); return LDNS_STATUS_INTERNAL_ERR; } } for (i = 0; i < ldns_pkt_nscount(packet); i++) { status = ldns_wire2rr(&rr, wire, max, &pos, LDNS_SECTION_AUTHORITY); if (status == LDNS_STATUS_PACKET_OVERFLOW) { status = LDNS_STATUS_WIRE_INCOMPLETE_AUTHORITY; } LDNS_STATUS_CHECK_GOTO(status, status_error); if (!ldns_rr_list_push_rr(ldns_pkt_authority(packet), rr)) { ldns_pkt_free(packet); return LDNS_STATUS_INTERNAL_ERR; } } for (i = 0; i < ldns_pkt_arcount(packet); i++) { status = ldns_wire2rr(&rr, wire, max, &pos, LDNS_SECTION_ADDITIONAL); if (status == LDNS_STATUS_PACKET_OVERFLOW) { status = LDNS_STATUS_WIRE_INCOMPLETE_ADDITIONAL; } LDNS_STATUS_CHECK_GOTO(status, status_error); if (ldns_rr_get_type(rr) == LDNS_RR_TYPE_OPT) { ldns_pkt_set_edns_udp_size(packet, ldns_rr_get_class(rr)); ldns_write_uint32(data, ldns_rr_ttl(rr)); ldns_pkt_set_edns_extended_rcode(packet, data[0]); ldns_pkt_set_edns_version(packet, data[1]); ldns_pkt_set_edns_z(packet, ldns_read_uint16(&data[2])); /* edns might not have rdfs */ if (ldns_rr_rdf(rr, 0)) { ldns_pkt_set_edns_data(packet, ldns_rdf_clone(ldns_rr_rdf(rr, 0))); } ldns_rr_free(rr); have_edns += 1; } else if (ldns_rr_get_type(rr) == LDNS_RR_TYPE_TSIG) { ldns_pkt_set_tsig(packet, rr); ldns_pkt_set_arcount(packet, ldns_pkt_arcount(packet) - 1); } else if (!ldns_rr_list_push_rr(ldns_pkt_additional(packet), rr)) { ldns_pkt_free(packet); return LDNS_STATUS_INTERNAL_ERR; } } ldns_pkt_set_size(packet, max); if(have_edns) ldns_pkt_set_arcount(packet, ldns_pkt_arcount(packet) - have_edns); *packet_p = packet; return status; status_error: ldns_pkt_free(packet); return status; } ldns-1.6.17/error.c0000664000175100017510000002157612264060151013423 0ustar willemwillem/* * a error2str function to make sense of all the * error codes we have laying ardoun * * a Net::DNS like library for C * LibDNS Team @ NLnet Labs * (c) NLnet Labs, 2005-2006 * See the file LICENSE for the license */ #include #include ldns_lookup_table ldns_error_str[] = { { LDNS_STATUS_OK, "All OK" }, { LDNS_STATUS_EMPTY_LABEL, "Empty label" }, { LDNS_STATUS_LABEL_OVERFLOW, "Label length overflow" }, { LDNS_STATUS_DOMAINNAME_OVERFLOW, "Domainname length overflow" }, { LDNS_STATUS_DOMAINNAME_UNDERFLOW, "Domainname length underflow (zero length)" }, { LDNS_STATUS_DDD_OVERFLOW, "\\DDD sequence overflow (>255)" }, { LDNS_STATUS_PACKET_OVERFLOW, "Packet size overflow" }, { LDNS_STATUS_INVALID_POINTER, "Invalid compression pointer" }, { LDNS_STATUS_MEM_ERR, "General memory error" }, { LDNS_STATUS_INTERNAL_ERR, "Internal error, this should not happen" }, { LDNS_STATUS_SSL_ERR, "Error in SSL library" }, { LDNS_STATUS_ERR, "General LDNS error" }, { LDNS_STATUS_INVALID_INT, "Conversion error, integer expected" }, { LDNS_STATUS_INVALID_IP4, "Conversion error, ip4 addr expected" }, { LDNS_STATUS_INVALID_IP6, "Conversion error, ip6 addr expected" }, { LDNS_STATUS_INVALID_STR, "Conversion error, string expected" }, { LDNS_STATUS_INVALID_B32_EXT, "Conversion error, b32 ext encoding expected" }, { LDNS_STATUS_INVALID_B64, "Conversion error, b64 encoding expected" }, { LDNS_STATUS_INVALID_HEX, "Conversion error, hex encoding expected" }, { LDNS_STATUS_INVALID_TIME, "Conversion error, time encoding expected" }, { LDNS_STATUS_NETWORK_ERR, "Could not send or receive, because of network error" }, { LDNS_STATUS_ADDRESS_ERR, "Could not start AXFR, because of address error" }, { LDNS_STATUS_FILE_ERR, "Could not open the files" }, { LDNS_STATUS_UNKNOWN_INET, "Uknown address family" }, { LDNS_STATUS_NOT_IMPL, "This function is not implemented (yet), please notify the developers - or not..." }, { LDNS_STATUS_NULL, "Supplied value pointer null" }, { LDNS_STATUS_CRYPTO_UNKNOWN_ALGO, "Unknown cryptographic algorithm" }, { LDNS_STATUS_CRYPTO_ALGO_NOT_IMPL, "Cryptographic algorithm not implemented" }, { LDNS_STATUS_CRYPTO_NO_RRSIG, "No DNSSEC signature(s)" }, { LDNS_STATUS_CRYPTO_NO_DNSKEY, "No DNSSEC public key(s)" }, { LDNS_STATUS_CRYPTO_TYPE_COVERED_ERR, "The signature does not cover this RRset" }, { LDNS_STATUS_CRYPTO_NO_TRUSTED_DNSKEY, "No signatures found for trusted DNSSEC public key(s)" }, { LDNS_STATUS_CRYPTO_NO_DS, "No DS record(s)" }, { LDNS_STATUS_CRYPTO_NO_TRUSTED_DS, "Could not validate DS record(s)" }, { LDNS_STATUS_CRYPTO_NO_MATCHING_KEYTAG_DNSKEY, "No keys with the keytag and algorithm from the RRSIG found" }, { LDNS_STATUS_CRYPTO_VALIDATED, "Valid DNSSEC signature" }, { LDNS_STATUS_CRYPTO_BOGUS, "Bogus DNSSEC signature" }, { LDNS_STATUS_CRYPTO_SIG_EXPIRED, "DNSSEC signature has expired" }, { LDNS_STATUS_CRYPTO_SIG_NOT_INCEPTED, "DNSSEC signature not incepted yet" }, { LDNS_STATUS_CRYPTO_TSIG_BOGUS, "Bogus TSIG signature" }, { LDNS_STATUS_CRYPTO_TSIG_ERR, "Could not create TSIG signature" }, { LDNS_STATUS_CRYPTO_EXPIRATION_BEFORE_INCEPTION, "DNSSEC signature has expiration date earlier than inception date" }, { LDNS_STATUS_ENGINE_KEY_NOT_LOADED, "Unable to load private key from engine" }, { LDNS_STATUS_NSEC3_ERR, "Error in NSEC3 denial of existence proof" }, { LDNS_STATUS_RES_NO_NS, "No (valid) nameservers defined in the resolver" }, { LDNS_STATUS_RES_QUERY, "No correct query given to resolver" }, { LDNS_STATUS_WIRE_INCOMPLETE_HEADER, "header section incomplete" }, { LDNS_STATUS_WIRE_INCOMPLETE_QUESTION, "question section incomplete" }, { LDNS_STATUS_WIRE_INCOMPLETE_ANSWER, "answer section incomplete" }, { LDNS_STATUS_WIRE_INCOMPLETE_AUTHORITY, "authority section incomplete" }, { LDNS_STATUS_WIRE_INCOMPLETE_ADDITIONAL, "additional section incomplete" }, { LDNS_STATUS_NO_DATA, "No data" }, { LDNS_STATUS_EXISTS_ERR, "Element already exists" }, { LDNS_STATUS_CERT_BAD_ALGORITHM, "Bad algorithm type for CERT record" }, { LDNS_STATUS_SYNTAX_TYPE_ERR, "Syntax error, could not parse the RR's type" }, { LDNS_STATUS_SYNTAX_CLASS_ERR, "Syntax error, could not parse the RR's class" }, { LDNS_STATUS_SYNTAX_TTL_ERR, "Syntax error, could not parse the RR's TTL" }, { LDNS_STATUS_SYNTAX_INCLUDE_ERR_NOTIMPL, "Syntax error, $INCLUDE not implemented" }, { LDNS_STATUS_SYNTAX_RDATA_ERR, "Syntax error, could not parse the RR's rdata" }, { LDNS_STATUS_SYNTAX_DNAME_ERR, "Syntax error, could not parse the RR's dname(s)" }, { LDNS_STATUS_SYNTAX_VERSION_ERR, "Syntax error, version mismatch" }, { LDNS_STATUS_SYNTAX_ALG_ERR, "Syntax error, algorithm unknown or non parseable" }, { LDNS_STATUS_SYNTAX_KEYWORD_ERR, "Syntax error, unknown keyword in input" }, { LDNS_STATUS_SYNTAX_ERR, "Syntax error, could not parse the RR" }, { LDNS_STATUS_SYNTAX_EMPTY, "Empty line was returned" }, { LDNS_STATUS_SYNTAX_TTL, "$TTL directive was seen in the zone" }, { LDNS_STATUS_SYNTAX_ORIGIN, "$ORIGIN directive was seen in the zone" }, { LDNS_STATUS_SYNTAX_INCLUDE, "$INCLUDE directive was seen in the zone" }, { LDNS_STATUS_SYNTAX_ITERATIONS_OVERFLOW, "Iterations count for NSEC3 record higher than maximum" }, { LDNS_STATUS_SYNTAX_MISSING_VALUE_ERR, "Syntax error, value expected" }, { LDNS_STATUS_SYNTAX_INTEGER_OVERFLOW, "Syntax error, integer value too large" }, { LDNS_STATUS_SYNTAX_BAD_ESCAPE, "Syntax error, bad escape sequence" }, { LDNS_STATUS_SOCKET_ERROR, "Error creating socket" }, { LDNS_STATUS_DNSSEC_EXISTENCE_DENIED, "Existence denied by NSEC" }, { LDNS_STATUS_DNSSEC_NSEC_RR_NOT_COVERED, "RR not covered by the given NSEC RRs" }, { LDNS_STATUS_DNSSEC_NSEC_WILDCARD_NOT_COVERED, "wildcard not covered by the given NSEC RRs" }, { LDNS_STATUS_DNSSEC_NSEC3_ORIGINAL_NOT_FOUND, "original of NSEC3 hashed name could not be found" }, { LDNS_STATUS_MISSING_RDATA_FIELDS_RRSIG, "The RRSIG has to few rdata fields" }, { LDNS_STATUS_MISSING_RDATA_FIELDS_KEY, "The DNSKEY has to few rdata fields" }, { LDNS_STATUS_CRYPTO_SIG_EXPIRED_WITHIN_MARGIN, "DNSSEC signature will expire too soon" }, { LDNS_STATUS_CRYPTO_SIG_NOT_INCEPTED_WITHIN_MARGIN, "DNSSEC signature not incepted long enough" }, { LDNS_STATUS_DANE_UNKNOWN_CERTIFICATE_USAGE, "Unknown TLSA Certificate Usage" }, { LDNS_STATUS_DANE_UNKNOWN_SELECTOR, "Unknown TLSA Selector" }, { LDNS_STATUS_DANE_UNKNOWN_MATCHING_TYPE, "Unknown TLSA Matching Type" }, { LDNS_STATUS_DANE_UNKNOWN_PROTOCOL, "Unknown protocol. Only IPv4 and IPv6 are understood" }, { LDNS_STATUS_DANE_UNKNOWN_TRANSPORT, "Unknown transport. Should be one of {tcp, udp, sctp}" }, { LDNS_STATUS_DANE_MISSING_EXTRA_CERTS, /* Trust anchor assertion */ "More than one certificate should be provided" }, { LDNS_STATUS_DANE_EXTRA_CERTS_NOT_USED, /* Trust anchor assertion */ "Non of the extra certificates is used to sign the first" }, { LDNS_STATUS_DANE_OFFSET_OUT_OF_RANGE, /* Trust anchor assertion */ "The offset was out of range" }, { LDNS_STATUS_DANE_INSECURE, /* Unused by library */ "The queried resource records were insecure" }, { LDNS_STATUS_DANE_BOGUS, /* Unused by library */ "The queried resource records were bogus" }, { LDNS_STATUS_DANE_TLSA_DID_NOT_MATCH, "The TLSA record(s) " "did not match with the server certificate (chain)" }, { LDNS_STATUS_DANE_NON_CA_CERTIFICATE, "The certificate was not a CA certificate" }, { LDNS_STATUS_DANE_PKIX_DID_NOT_VALIDATE, "Could not PKIX validate" }, { LDNS_STATUS_DANE_PKIX_NO_SELF_SIGNED_TRUST_ANCHOR, "The validation path " "did not end in a self-signed certificate" }, { LDNS_STATUS_INVALID_ILNP64, "Conversion error, 4 colon separated hex numbers expected" }, { LDNS_STATUS_INVALID_EUI48, "Conversion error, 6 two character hex numbers " "separated by dashes expected (i.e. xx-xx-xx-xx-xx-xx" }, { LDNS_STATUS_INVALID_EUI64, "Conversion error, 8 two character hex numbers " "separated by dashes expected (i.e. xx-xx-xx-xx-xx-xx-xx-xx" }, { LDNS_STATUS_WIRE_RDATA_ERR, "invalid rdata in wire format" }, { LDNS_STATUS_INVALID_TAG, "Conversion error, a non-zero sequence of US-ASCII letters " "and numbers in lower case expected" }, { LDNS_STATUS_TYPE_NOT_IN_BITMAP, "The RR type bitmap rdata field did not have " "a bit reserved for the specific RR type" }, { LDNS_STATUS_INVALID_RDF_TYPE, "The rdata field was not of the expected type" }, { LDNS_STATUS_RDATA_OVERFLOW, "Rdata size overflow" }, { 0, NULL } }; const char * ldns_get_errorstr_by_id(ldns_status err) { ldns_lookup_table *lt; lt = ldns_lookup_by_id(ldns_error_str, err); if (lt) { return lt->name; } return NULL; } ldns-1.6.17/dnssec_verify.c0000664000175100017510000021426112264060151015130 0ustar willemwillem#include #include #include #include #ifdef HAVE_SSL /* this entire file is rather useless when you don't have * crypto... */ #include #include #include #include #include ldns_dnssec_data_chain * ldns_dnssec_data_chain_new(void) { ldns_dnssec_data_chain *nc = LDNS_CALLOC(ldns_dnssec_data_chain, 1); if(!nc) return NULL; /* * not needed anymore because CALLOC initalizes everything to zero. nc->rrset = NULL; nc->parent_type = 0; nc->parent = NULL; nc->signatures = NULL; nc->packet_rcode = 0; nc->packet_qtype = 0; nc->packet_nodata = false; */ return nc; } void ldns_dnssec_data_chain_free(ldns_dnssec_data_chain *chain) { LDNS_FREE(chain); } void ldns_dnssec_data_chain_deep_free(ldns_dnssec_data_chain *chain) { ldns_rr_list_deep_free(chain->rrset); ldns_rr_list_deep_free(chain->signatures); if (chain->parent) { ldns_dnssec_data_chain_deep_free(chain->parent); } LDNS_FREE(chain); } void ldns_dnssec_data_chain_print_fmt(FILE *out, const ldns_output_format *fmt, const ldns_dnssec_data_chain *chain) { ldns_lookup_table *rcode; const ldns_rr_descriptor *rr_descriptor; if (chain) { ldns_dnssec_data_chain_print_fmt(out, fmt, chain->parent); if (ldns_rr_list_rr_count(chain->rrset) > 0) { rcode = ldns_lookup_by_id(ldns_rcodes, (int) chain->packet_rcode); if (rcode) { fprintf(out, ";; rcode: %s\n", rcode->name); } rr_descriptor = ldns_rr_descript(chain->packet_qtype); if (rr_descriptor && rr_descriptor->_name) { fprintf(out, ";; qtype: %s\n", rr_descriptor->_name); } else if (chain->packet_qtype != 0) { fprintf(out, "TYPE%u", chain->packet_qtype); } if (chain->packet_nodata) { fprintf(out, ";; NODATA response\n"); } fprintf(out, "rrset:\n"); ldns_rr_list_print_fmt(out, fmt, chain->rrset); fprintf(out, "sigs:\n"); ldns_rr_list_print_fmt(out, fmt, chain->signatures); fprintf(out, "---\n"); } else { fprintf(out, "\n"); } } } void ldns_dnssec_data_chain_print(FILE *out, const ldns_dnssec_data_chain *chain) { ldns_dnssec_data_chain_print_fmt( out, ldns_output_format_default, chain); } static void ldns_dnssec_build_data_chain_dnskey(ldns_resolver *res, uint16_t qflags, const ldns_pkt *pkt, ldns_rr_list *signatures, ldns_dnssec_data_chain *new_chain, ldns_rdf *key_name, ldns_rr_class c) { ldns_rr_list *keys; ldns_pkt *my_pkt; if (signatures && ldns_rr_list_rr_count(signatures) > 0) { new_chain->signatures = ldns_rr_list_clone(signatures); new_chain->parent_type = 0; keys = ldns_pkt_rr_list_by_name_and_type( pkt, key_name, LDNS_RR_TYPE_DNSKEY, LDNS_SECTION_ANY_NOQUESTION ); if (!keys) { my_pkt = ldns_resolver_query(res, key_name, LDNS_RR_TYPE_DNSKEY, c, qflags); if (my_pkt) { keys = ldns_pkt_rr_list_by_name_and_type( my_pkt, key_name, LDNS_RR_TYPE_DNSKEY, LDNS_SECTION_ANY_NOQUESTION ); new_chain->parent = ldns_dnssec_build_data_chain(res, qflags, keys, my_pkt, NULL); new_chain->parent->packet_qtype = LDNS_RR_TYPE_DNSKEY; ldns_pkt_free(my_pkt); } } else { new_chain->parent = ldns_dnssec_build_data_chain(res, qflags, keys, pkt, NULL); new_chain->parent->packet_qtype = LDNS_RR_TYPE_DNSKEY; } ldns_rr_list_deep_free(keys); } } static void ldns_dnssec_build_data_chain_other(ldns_resolver *res, uint16_t qflags, ldns_dnssec_data_chain *new_chain, ldns_rdf *key_name, ldns_rr_class c, ldns_rr_list *dss) { /* 'self-signed', parent is a DS */ /* okay, either we have other keys signing the current one, * or the current * one should have a DS record in the parent zone. * How do we find this out? Try both? * * request DNSKEYS for current zone, * add all signatures to current level */ ldns_pkt *my_pkt; ldns_rr_list *signatures2; new_chain->parent_type = 1; my_pkt = ldns_resolver_query(res, key_name, LDNS_RR_TYPE_DS, c, qflags); if (my_pkt) { dss = ldns_pkt_rr_list_by_name_and_type(my_pkt, key_name, LDNS_RR_TYPE_DS, LDNS_SECTION_ANY_NOQUESTION ); if (dss) { new_chain->parent = ldns_dnssec_build_data_chain(res, qflags, dss, my_pkt, NULL); new_chain->parent->packet_qtype = LDNS_RR_TYPE_DS; ldns_rr_list_deep_free(dss); } ldns_pkt_free(my_pkt); } my_pkt = ldns_resolver_query(res, key_name, LDNS_RR_TYPE_DNSKEY, c, qflags); if (my_pkt) { signatures2 = ldns_pkt_rr_list_by_name_and_type(my_pkt, key_name, LDNS_RR_TYPE_RRSIG, LDNS_SECTION_ANSWER); if (signatures2) { if (new_chain->signatures) { printf("There were already sigs!\n"); ldns_rr_list_deep_free(new_chain->signatures); printf("replacing the old sigs\n"); } new_chain->signatures = signatures2; } ldns_pkt_free(my_pkt); } } static ldns_dnssec_data_chain * ldns_dnssec_build_data_chain_nokeyname(ldns_resolver *res, uint16_t qflags, ldns_rr *orig_rr, const ldns_rr_list *rrset, ldns_dnssec_data_chain *new_chain) { ldns_rdf *possible_parent_name; ldns_pkt *my_pkt; /* apparently we were not able to find a signing key, so we assume the chain ends here */ /* try parents for auth denial of DS */ if (orig_rr) { possible_parent_name = ldns_rr_owner(orig_rr); } else if (rrset && ldns_rr_list_rr_count(rrset) > 0) { possible_parent_name = ldns_rr_owner(ldns_rr_list_rr(rrset, 0)); } else { /* no information to go on, give up */ return new_chain; } my_pkt = ldns_resolver_query(res, possible_parent_name, LDNS_RR_TYPE_DS, LDNS_RR_CLASS_IN, qflags); if (!my_pkt) { return new_chain; } if (ldns_pkt_ancount(my_pkt) > 0) { /* add error, no sigs but DS in parent */ /*ldns_pkt_print(stdout, my_pkt);*/ ldns_pkt_free(my_pkt); } else { /* are there signatures? */ new_chain->parent = ldns_dnssec_build_data_chain(res, qflags, NULL, my_pkt, NULL); new_chain->parent->packet_qtype = LDNS_RR_TYPE_DS; } return new_chain; } ldns_dnssec_data_chain * ldns_dnssec_build_data_chain(ldns_resolver *res, uint16_t qflags, const ldns_rr_list *rrset, const ldns_pkt *pkt, ldns_rr *orig_rr) { ldns_rr_list *signatures = NULL; ldns_rr_list *dss = NULL; ldns_rr_list *my_rrset; ldns_pkt *my_pkt; ldns_rdf *name = NULL, *key_name = NULL; ldns_rr_type type = 0; ldns_rr_class c = 0; bool other_rrset = false; ldns_dnssec_data_chain *new_chain = ldns_dnssec_data_chain_new(); assert(pkt != NULL); if (!ldns_dnssec_pkt_has_rrsigs(pkt)) { /* hmm. no dnssec data in the packet. go up to try and deny * DS? */ return new_chain; } if (orig_rr) { new_chain->rrset = ldns_rr_list_new(); ldns_rr_list_push_rr(new_chain->rrset, orig_rr); new_chain->parent = ldns_dnssec_build_data_chain(res, qflags, rrset, pkt, NULL); new_chain->packet_rcode = ldns_pkt_get_rcode(pkt); new_chain->packet_qtype = ldns_rr_get_type(orig_rr); if (ldns_pkt_ancount(pkt) == 0) { new_chain->packet_nodata = true; } return new_chain; } if (!rrset || ldns_rr_list_rr_count(rrset) < 1) { /* hmm, no data, do we have denial? only works if pkt was given, otherwise caller has to do the check himself */ new_chain->packet_nodata = true; if (pkt) { my_rrset = ldns_pkt_rr_list_by_type(pkt, LDNS_RR_TYPE_NSEC, LDNS_SECTION_ANY_NOQUESTION ); if (my_rrset) { if (ldns_rr_list_rr_count(my_rrset) > 0) { type = LDNS_RR_TYPE_NSEC; other_rrset = true; } else { ldns_rr_list_deep_free(my_rrset); my_rrset = NULL; } } else { /* nothing, try nsec3 */ my_rrset = ldns_pkt_rr_list_by_type(pkt, LDNS_RR_TYPE_NSEC3, LDNS_SECTION_ANY_NOQUESTION); if (my_rrset) { if (ldns_rr_list_rr_count(my_rrset) > 0) { type = LDNS_RR_TYPE_NSEC3; other_rrset = true; } else { ldns_rr_list_deep_free(my_rrset); my_rrset = NULL; } } else { /* nothing, stop */ /* try parent zone? for denied insecure? */ return new_chain; } } } else { return new_chain; } } else { my_rrset = (ldns_rr_list *) rrset; } if (my_rrset && ldns_rr_list_rr_count(my_rrset) > 0) { new_chain->rrset = ldns_rr_list_clone(my_rrset); name = ldns_rr_owner(ldns_rr_list_rr(my_rrset, 0)); type = ldns_rr_get_type(ldns_rr_list_rr(my_rrset, 0)); c = ldns_rr_get_class(ldns_rr_list_rr(my_rrset, 0)); } if (other_rrset) { ldns_rr_list_deep_free(my_rrset); } /* normally there will only be 1 signature 'set' but there can be more than 1 denial (wildcards) so check for NSEC */ if (type == LDNS_RR_TYPE_NSEC || type == LDNS_RR_TYPE_NSEC3) { /* just throw in all signatures, the tree builder must sort this out */ if (pkt) { signatures = ldns_dnssec_pkt_get_rrsigs_for_type(pkt, type); } else { my_pkt = ldns_resolver_query(res, name, type, c, qflags); if (my_pkt) { signatures = ldns_dnssec_pkt_get_rrsigs_for_type(pkt, type); ldns_pkt_free(my_pkt); } } } else { if (pkt) { signatures = ldns_dnssec_pkt_get_rrsigs_for_name_and_type(pkt, name, type); } if (!signatures) { my_pkt = ldns_resolver_query(res, name, type, c, qflags); if (my_pkt) { signatures = ldns_dnssec_pkt_get_rrsigs_for_name_and_type(my_pkt, name, type); ldns_pkt_free(my_pkt); } } } if (signatures && ldns_rr_list_rr_count(signatures) > 0) { key_name = ldns_rr_rdf(ldns_rr_list_rr(signatures, 0), 7); } if (!key_name) { if (signatures) { ldns_rr_list_deep_free(signatures); } return ldns_dnssec_build_data_chain_nokeyname(res, qflags, orig_rr, rrset, new_chain); } if (type != LDNS_RR_TYPE_DNSKEY) { ldns_dnssec_build_data_chain_dnskey(res, qflags, pkt, signatures, new_chain, key_name, c ); } else { ldns_dnssec_build_data_chain_other(res, qflags, new_chain, key_name, c, dss ); } if (signatures) { ldns_rr_list_deep_free(signatures); } return new_chain; } ldns_dnssec_trust_tree * ldns_dnssec_trust_tree_new(void) { ldns_dnssec_trust_tree *new_tree = LDNS_XMALLOC(ldns_dnssec_trust_tree, 1); if(!new_tree) return NULL; new_tree->rr = NULL; new_tree->rrset = NULL; new_tree->parent_count = 0; return new_tree; } void ldns_dnssec_trust_tree_free(ldns_dnssec_trust_tree *tree) { size_t i; if (tree) { for (i = 0; i < tree->parent_count; i++) { ldns_dnssec_trust_tree_free(tree->parents[i]); } } LDNS_FREE(tree); } size_t ldns_dnssec_trust_tree_depth(ldns_dnssec_trust_tree *tree) { size_t result = 0; size_t parent = 0; size_t i; for (i = 0; i < tree->parent_count; i++) { parent = ldns_dnssec_trust_tree_depth(tree->parents[i]); if (parent > result) { result = parent; } } return 1 + result; } /* TODO ldns_ */ static void print_tabs(FILE *out, size_t nr, uint8_t *map, size_t treedepth) { size_t i; for (i = 0; i < nr; i++) { if (i == nr - 1) { fprintf(out, "|---"); } else if (map && i < treedepth && map[i] == 1) { fprintf(out, "| "); } else { fprintf(out, " "); } } } static void ldns_dnssec_trust_tree_print_sm_fmt(FILE *out, const ldns_output_format *fmt, ldns_dnssec_trust_tree *tree, size_t tabs, bool extended, uint8_t *sibmap, size_t treedepth) { size_t i; const ldns_rr_descriptor *descriptor; bool mapset = false; if (!sibmap) { treedepth = ldns_dnssec_trust_tree_depth(tree); sibmap = LDNS_XMALLOC(uint8_t, treedepth); if(!sibmap) return; /* mem err */ memset(sibmap, 0, treedepth); mapset = true; } if (tree) { if (tree->rr) { print_tabs(out, tabs, sibmap, treedepth); ldns_rdf_print(out, ldns_rr_owner(tree->rr)); descriptor = ldns_rr_descript(ldns_rr_get_type(tree->rr)); if (descriptor->_name) { fprintf(out, " (%s", descriptor->_name); } else { fprintf(out, " (TYPE%d", ldns_rr_get_type(tree->rr)); } if (tabs > 0) { if (ldns_rr_get_type(tree->rr) == LDNS_RR_TYPE_DNSKEY) { fprintf(out, " keytag: %u", (unsigned int) ldns_calc_keytag(tree->rr)); fprintf(out, " alg: "); ldns_rdf_print(out, ldns_rr_rdf(tree->rr, 2)); fprintf(out, " flags: "); ldns_rdf_print(out, ldns_rr_rdf(tree->rr, 0)); } else if (ldns_rr_get_type(tree->rr) == LDNS_RR_TYPE_DS) { fprintf(out, " keytag: "); ldns_rdf_print(out, ldns_rr_rdf(tree->rr, 0)); fprintf(out, " digest type: "); ldns_rdf_print(out, ldns_rr_rdf(tree->rr, 2)); } if (ldns_rr_get_type(tree->rr) == LDNS_RR_TYPE_NSEC) { fprintf(out, " "); ldns_rdf_print(out, ldns_rr_rdf(tree->rr, 0)); fprintf(out, " "); ldns_rdf_print(out, ldns_rr_rdf(tree->rr, 1)); } } fprintf(out, ")\n"); for (i = 0; i < tree->parent_count; i++) { if (tree->parent_count > 1 && i < tree->parent_count - 1) { sibmap[tabs] = 1; } else { sibmap[tabs] = 0; } /* only print errors */ if (ldns_rr_get_type(tree->parents[i]->rr) == LDNS_RR_TYPE_NSEC || ldns_rr_get_type(tree->parents[i]->rr) == LDNS_RR_TYPE_NSEC3) { if (tree->parent_status[i] == LDNS_STATUS_OK) { print_tabs(out, tabs + 1, sibmap, treedepth); if (tabs == 0 && ldns_rr_get_type(tree->rr) == LDNS_RR_TYPE_NS && ldns_rr_rd_count(tree->rr) > 0) { fprintf(out, "Existence of DS is denied by:\n"); } else { fprintf(out, "Existence is denied by:\n"); } } else { /* NS records aren't signed */ if (ldns_rr_get_type(tree->rr) == LDNS_RR_TYPE_NS) { fprintf(out, "Existence of DS is denied by:\n"); } else { print_tabs(out, tabs + 1, sibmap, treedepth); fprintf(out, "Error in denial of existence: %s\n", ldns_get_errorstr_by_id( tree->parent_status[i])); } } } else if (tree->parent_status[i] != LDNS_STATUS_OK) { print_tabs(out, tabs + 1, sibmap, treedepth); fprintf(out, "%s:\n", ldns_get_errorstr_by_id( tree->parent_status[i])); if (tree->parent_status[i] == LDNS_STATUS_SSL_ERR) { printf("; SSL Error: "); ERR_load_crypto_strings(); ERR_print_errors_fp(stdout); printf("\n"); } ldns_rr_print_fmt(out, fmt, tree-> parent_signature[i]); printf("For RRset:\n"); ldns_rr_list_print_fmt(out, fmt, tree->rrset); printf("With key:\n"); ldns_rr_print_fmt(out, fmt, tree->parents[i]->rr); } ldns_dnssec_trust_tree_print_sm_fmt(out, fmt, tree->parents[i], tabs+1, extended, sibmap, treedepth); } } else { print_tabs(out, tabs, sibmap, treedepth); fprintf(out, "\n"); } } else { fprintf(out, "\n"); } if (mapset) { LDNS_FREE(sibmap); } } void ldns_dnssec_trust_tree_print_fmt(FILE *out, const ldns_output_format *fmt, ldns_dnssec_trust_tree *tree, size_t tabs, bool extended) { ldns_dnssec_trust_tree_print_sm_fmt(out, fmt, tree, tabs, extended, NULL, 0); } void ldns_dnssec_trust_tree_print(FILE *out, ldns_dnssec_trust_tree *tree, size_t tabs, bool extended) { ldns_dnssec_trust_tree_print_fmt(out, ldns_output_format_default, tree, tabs, extended); } ldns_status ldns_dnssec_trust_tree_add_parent(ldns_dnssec_trust_tree *tree, const ldns_dnssec_trust_tree *parent, const ldns_rr *signature, const ldns_status parent_status) { if (tree && parent && tree->parent_count < LDNS_DNSSEC_TRUST_TREE_MAX_PARENTS) { /* printf("Add parent for: "); ldns_rr_print(stdout, tree->rr); printf("parent: "); ldns_rr_print(stdout, parent->rr); */ tree->parents[tree->parent_count] = (ldns_dnssec_trust_tree *) parent; tree->parent_status[tree->parent_count] = parent_status; tree->parent_signature[tree->parent_count] = (ldns_rr *) signature; tree->parent_count++; return LDNS_STATUS_OK; } else { return LDNS_STATUS_ERR; } } /* if rr is null, take the first from the rrset */ 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 *cur_rrset; ldns_rr_list *cur_sigs; ldns_rr *cur_rr = NULL; ldns_rr *cur_sig_rr; size_t i, j; ldns_dnssec_trust_tree *new_tree = ldns_dnssec_trust_tree_new(); if(!new_tree) return NULL; if (data_chain && data_chain->rrset) { cur_rrset = data_chain->rrset; cur_sigs = data_chain->signatures; if (rr) { cur_rr = rr; } if (!cur_rr && ldns_rr_list_rr_count(cur_rrset) > 0) { cur_rr = ldns_rr_list_rr(cur_rrset, 0); } if (cur_rr) { new_tree->rr = cur_rr; new_tree->rrset = cur_rrset; /* there are three possibilities: 1 - 'normal' rrset, signed by a key 2 - dnskey signed by other dnskey 3 - dnskey proven by higher level DS (data denied by nsec is a special case that can occur in multiple places) */ if (cur_sigs) { for (i = 0; i < ldns_rr_list_rr_count(cur_sigs); i++) { /* find the appropriate key in the parent list */ cur_sig_rr = ldns_rr_list_rr(cur_sigs, i); if (ldns_rr_get_type(cur_rr) == LDNS_RR_TYPE_NSEC) { if (ldns_dname_compare(ldns_rr_owner(cur_sig_rr), ldns_rr_owner(cur_rr))) { /* find first that does match */ for (j = 0; j < ldns_rr_list_rr_count(cur_rrset) && ldns_dname_compare(ldns_rr_owner(cur_sig_rr),ldns_rr_owner(cur_rr)) != 0; j++) { cur_rr = ldns_rr_list_rr(cur_rrset, j); } if (ldns_dname_compare(ldns_rr_owner(cur_sig_rr), ldns_rr_owner(cur_rr))) { break; } } } /* option 1 */ if (data_chain->parent) { ldns_dnssec_derive_trust_tree_normal_rrset_time( new_tree, data_chain, cur_sig_rr, check_time); } /* option 2 */ ldns_dnssec_derive_trust_tree_dnskey_rrset_time( new_tree, data_chain, cur_rr, cur_sig_rr, check_time); } ldns_dnssec_derive_trust_tree_ds_rrset_time( new_tree, data_chain, cur_rr, check_time); } else { /* no signatures? maybe it's nsec data */ /* just add every rr from parent as new parent */ ldns_dnssec_derive_trust_tree_no_sig_time( new_tree, data_chain, check_time); } } } return new_tree; } ldns_dnssec_trust_tree * ldns_dnssec_derive_trust_tree(ldns_dnssec_data_chain *data_chain, ldns_rr *rr) { return ldns_dnssec_derive_trust_tree_time(data_chain, rr, ldns_time(NULL)); } void ldns_dnssec_derive_trust_tree_normal_rrset_time( ldns_dnssec_trust_tree *new_tree, ldns_dnssec_data_chain *data_chain, ldns_rr *cur_sig_rr, time_t check_time) { size_t i, j; ldns_rr_list *cur_rrset = ldns_rr_list_clone(data_chain->rrset); ldns_dnssec_trust_tree *cur_parent_tree; ldns_rr *cur_parent_rr; uint16_t cur_keytag; ldns_rr_list *tmp_rrset = NULL; ldns_status cur_status; cur_keytag = ldns_rdf2native_int16(ldns_rr_rrsig_keytag(cur_sig_rr)); for (j = 0; j < ldns_rr_list_rr_count(data_chain->parent->rrset); j++) { cur_parent_rr = ldns_rr_list_rr(data_chain->parent->rrset, j); if (ldns_rr_get_type(cur_parent_rr) == LDNS_RR_TYPE_DNSKEY) { if (ldns_calc_keytag(cur_parent_rr) == cur_keytag) { /* TODO: check wildcard nsec too */ if (cur_rrset && ldns_rr_list_rr_count(cur_rrset) > 0) { tmp_rrset = cur_rrset; if (ldns_rr_get_type(ldns_rr_list_rr(cur_rrset, 0)) == LDNS_RR_TYPE_NSEC || ldns_rr_get_type(ldns_rr_list_rr(cur_rrset, 0)) == LDNS_RR_TYPE_NSEC3) { /* might contain different names! sort and split */ ldns_rr_list_sort(cur_rrset); assert(tmp_rrset == cur_rrset); tmp_rrset = ldns_rr_list_pop_rrset(cur_rrset); /* with nsecs, this might be the wrong one */ while (tmp_rrset && ldns_rr_list_rr_count(cur_rrset) > 0 && ldns_dname_compare( ldns_rr_owner(ldns_rr_list_rr( tmp_rrset, 0)), ldns_rr_owner(cur_sig_rr)) != 0) { ldns_rr_list_deep_free(tmp_rrset); tmp_rrset = ldns_rr_list_pop_rrset(cur_rrset); } } cur_status = ldns_verify_rrsig_time( tmp_rrset, cur_sig_rr, cur_parent_rr, check_time); if (tmp_rrset && tmp_rrset != cur_rrset ) { ldns_rr_list_deep_free( tmp_rrset); tmp_rrset = NULL; } /* avoid dupes */ for (i = 0; i < new_tree->parent_count; i++) { if (cur_parent_rr == new_tree->parents[i]->rr) { goto done; } } cur_parent_tree = ldns_dnssec_derive_trust_tree_time( data_chain->parent, cur_parent_rr, check_time); (void)ldns_dnssec_trust_tree_add_parent(new_tree, cur_parent_tree, cur_sig_rr, cur_status); } } } } done: ldns_rr_list_deep_free(cur_rrset); } void ldns_dnssec_derive_trust_tree_normal_rrset(ldns_dnssec_trust_tree *new_tree, ldns_dnssec_data_chain *data_chain, ldns_rr *cur_sig_rr) { ldns_dnssec_derive_trust_tree_normal_rrset_time( new_tree, data_chain, cur_sig_rr, ldns_time(NULL)); } void ldns_dnssec_derive_trust_tree_dnskey_rrset_time( ldns_dnssec_trust_tree *new_tree, ldns_dnssec_data_chain *data_chain, ldns_rr *cur_rr, ldns_rr *cur_sig_rr, time_t check_time) { size_t j; ldns_rr_list *cur_rrset = data_chain->rrset; ldns_dnssec_trust_tree *cur_parent_tree; ldns_rr *cur_parent_rr; uint16_t cur_keytag; ldns_status cur_status; cur_keytag = ldns_rdf2native_int16(ldns_rr_rrsig_keytag(cur_sig_rr)); for (j = 0; j < ldns_rr_list_rr_count(cur_rrset); j++) { cur_parent_rr = ldns_rr_list_rr(cur_rrset, j); if (cur_parent_rr != cur_rr && ldns_rr_get_type(cur_parent_rr) == LDNS_RR_TYPE_DNSKEY) { if (ldns_calc_keytag(cur_parent_rr) == cur_keytag ) { cur_parent_tree = ldns_dnssec_trust_tree_new(); cur_parent_tree->rr = cur_parent_rr; cur_parent_tree->rrset = cur_rrset; cur_status = ldns_verify_rrsig_time( cur_rrset, cur_sig_rr, cur_parent_rr, check_time); (void) ldns_dnssec_trust_tree_add_parent(new_tree, cur_parent_tree, cur_sig_rr, cur_status); } } } } void ldns_dnssec_derive_trust_tree_dnskey_rrset(ldns_dnssec_trust_tree *new_tree, ldns_dnssec_data_chain *data_chain, ldns_rr *cur_rr, ldns_rr *cur_sig_rr) { ldns_dnssec_derive_trust_tree_dnskey_rrset_time( new_tree, data_chain, cur_rr, cur_sig_rr, ldns_time(NULL)); } void ldns_dnssec_derive_trust_tree_ds_rrset_time( ldns_dnssec_trust_tree *new_tree, ldns_dnssec_data_chain *data_chain, ldns_rr *cur_rr, time_t check_time) { size_t j, h; ldns_rr_list *cur_rrset = data_chain->rrset; ldns_dnssec_trust_tree *cur_parent_tree; ldns_rr *cur_parent_rr; /* try the parent to see whether there are DSs there */ if (ldns_rr_get_type(cur_rr) == LDNS_RR_TYPE_DNSKEY && data_chain->parent && data_chain->parent->rrset ) { for (j = 0; j < ldns_rr_list_rr_count(data_chain->parent->rrset); j++) { cur_parent_rr = ldns_rr_list_rr(data_chain->parent->rrset, j); if (ldns_rr_get_type(cur_parent_rr) == LDNS_RR_TYPE_DS) { for (h = 0; h < ldns_rr_list_rr_count(cur_rrset); h++) { cur_rr = ldns_rr_list_rr(cur_rrset, h); if (ldns_rr_compare_ds(cur_rr, cur_parent_rr)) { cur_parent_tree = ldns_dnssec_derive_trust_tree_time( data_chain->parent, cur_parent_rr, check_time); (void) ldns_dnssec_trust_tree_add_parent( new_tree, cur_parent_tree, NULL, LDNS_STATUS_OK); } else { /*ldns_rr_print(stdout, cur_parent_rr);*/ } } } } } } void ldns_dnssec_derive_trust_tree_ds_rrset(ldns_dnssec_trust_tree *new_tree, ldns_dnssec_data_chain *data_chain, ldns_rr *cur_rr) { ldns_dnssec_derive_trust_tree_ds_rrset_time( new_tree, data_chain, cur_rr, ldns_time(NULL)); } void ldns_dnssec_derive_trust_tree_no_sig_time( ldns_dnssec_trust_tree *new_tree, ldns_dnssec_data_chain *data_chain, time_t check_time) { size_t i; ldns_rr_list *cur_rrset; ldns_rr *cur_parent_rr; ldns_dnssec_trust_tree *cur_parent_tree; ldns_status result; if (data_chain->parent && data_chain->parent->rrset) { cur_rrset = data_chain->parent->rrset; /* nsec? */ if (cur_rrset && ldns_rr_list_rr_count(cur_rrset) > 0) { if (ldns_rr_get_type(ldns_rr_list_rr(cur_rrset, 0)) == LDNS_RR_TYPE_NSEC3) { result = ldns_dnssec_verify_denial_nsec3( new_tree->rr, cur_rrset, data_chain->parent->signatures, data_chain->packet_rcode, data_chain->packet_qtype, data_chain->packet_nodata); } else if (ldns_rr_get_type(ldns_rr_list_rr(cur_rrset, 0)) == LDNS_RR_TYPE_NSEC) { result = ldns_dnssec_verify_denial( new_tree->rr, cur_rrset, data_chain->parent->signatures); } else { /* unsigned zone, unsigned parent */ result = LDNS_STATUS_OK; } } else { result = LDNS_STATUS_DNSSEC_NSEC_RR_NOT_COVERED; } for (i = 0; i < ldns_rr_list_rr_count(cur_rrset); i++) { cur_parent_rr = ldns_rr_list_rr(cur_rrset, i); cur_parent_tree = ldns_dnssec_derive_trust_tree_time( data_chain->parent, cur_parent_rr, check_time); (void) ldns_dnssec_trust_tree_add_parent(new_tree, cur_parent_tree, NULL, result); } } } void ldns_dnssec_derive_trust_tree_no_sig(ldns_dnssec_trust_tree *new_tree, ldns_dnssec_data_chain *data_chain) { ldns_dnssec_derive_trust_tree_no_sig_time( new_tree, data_chain, ldns_time(NULL)); } /* * returns OK if there is a path from tree to key with only OK * the (first) error in between otherwise * or NOT_FOUND if the key wasn't present at all */ ldns_status ldns_dnssec_trust_tree_contains_keys(ldns_dnssec_trust_tree *tree, ldns_rr_list *trusted_keys) { size_t i; ldns_status result = LDNS_STATUS_CRYPTO_NO_DNSKEY; bool equal; ldns_status parent_result; if (tree && trusted_keys && ldns_rr_list_rr_count(trusted_keys) > 0) { if (tree->rr) { for (i = 0; i < ldns_rr_list_rr_count(trusted_keys); i++) { equal = ldns_rr_compare_ds( tree->rr, ldns_rr_list_rr(trusted_keys, i)); if (equal) { result = LDNS_STATUS_OK; return result; } } } for (i = 0; i < tree->parent_count; i++) { parent_result = ldns_dnssec_trust_tree_contains_keys(tree->parents[i], trusted_keys); if (parent_result != LDNS_STATUS_CRYPTO_NO_DNSKEY) { if (tree->parent_status[i] != LDNS_STATUS_OK) { result = tree->parent_status[i]; } else { if (tree->rr && ldns_rr_get_type(tree->rr) == LDNS_RR_TYPE_NSEC && parent_result == LDNS_STATUS_OK ) { result = LDNS_STATUS_DNSSEC_EXISTENCE_DENIED; } else { result = parent_result; } } } } } else { result = LDNS_STATUS_ERR; } return result; } ldns_status ldns_verify_time( ldns_rr_list *rrset, ldns_rr_list *rrsig, const ldns_rr_list *keys, time_t check_time, ldns_rr_list *good_keys ) { uint16_t i; ldns_status verify_result = LDNS_STATUS_ERR; if (!rrset || !rrsig || !keys) { return LDNS_STATUS_ERR; } if (ldns_rr_list_rr_count(rrset) < 1) { return LDNS_STATUS_ERR; } if (ldns_rr_list_rr_count(rrsig) < 1) { return LDNS_STATUS_CRYPTO_NO_RRSIG; } if (ldns_rr_list_rr_count(keys) < 1) { verify_result = LDNS_STATUS_CRYPTO_NO_TRUSTED_DNSKEY; } else { for (i = 0; i < ldns_rr_list_rr_count(rrsig); i++) { ldns_status s = ldns_verify_rrsig_keylist_time( rrset, ldns_rr_list_rr(rrsig, i), keys, check_time, good_keys); /* try a little to get more descriptive error */ if(s == LDNS_STATUS_OK) { verify_result = LDNS_STATUS_OK; } else if(verify_result == LDNS_STATUS_ERR) verify_result = s; else if(s != LDNS_STATUS_ERR && verify_result == LDNS_STATUS_CRYPTO_NO_MATCHING_KEYTAG_DNSKEY) verify_result = s; } } return verify_result; } ldns_status ldns_verify(ldns_rr_list *rrset, ldns_rr_list *rrsig, const ldns_rr_list *keys, ldns_rr_list *good_keys) { return ldns_verify_time(rrset, rrsig, keys, ldns_time(NULL), good_keys); } ldns_status ldns_verify_notime(ldns_rr_list *rrset, ldns_rr_list *rrsig, const ldns_rr_list *keys, ldns_rr_list *good_keys) { uint16_t i; ldns_status verify_result = LDNS_STATUS_ERR; if (!rrset || !rrsig || !keys) { return LDNS_STATUS_ERR; } if (ldns_rr_list_rr_count(rrset) < 1) { return LDNS_STATUS_ERR; } if (ldns_rr_list_rr_count(rrsig) < 1) { return LDNS_STATUS_CRYPTO_NO_RRSIG; } if (ldns_rr_list_rr_count(keys) < 1) { verify_result = LDNS_STATUS_CRYPTO_NO_TRUSTED_DNSKEY; } else { for (i = 0; i < ldns_rr_list_rr_count(rrsig); i++) { ldns_status s = ldns_verify_rrsig_keylist_notime(rrset, ldns_rr_list_rr(rrsig, i), keys, good_keys); /* try a little to get more descriptive error */ if (s == LDNS_STATUS_OK) { verify_result = LDNS_STATUS_OK; } else if (verify_result == LDNS_STATUS_ERR) { verify_result = s; } else if (s != LDNS_STATUS_ERR && verify_result == LDNS_STATUS_CRYPTO_NO_MATCHING_KEYTAG_DNSKEY) { verify_result = s; } } } return verify_result; } 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 * trusted_keys = NULL; ldns_rr_list * ds_keys = NULL; ldns_rdf * prev_parent_domain; ldns_rdf * parent_domain; ldns_rr_list * parent_keys = NULL; if (res && domain && keys) { if ((trusted_keys = ldns_validate_domain_dnskey_time(res, domain, keys, check_time))) { *status = LDNS_STATUS_OK; } else { /* No trusted keys in this domain, we'll have to find some in the parent domain */ *status = LDNS_STATUS_CRYPTO_NO_TRUSTED_DNSKEY; parent_domain = ldns_dname_left_chop(domain); while (parent_domain && /* Fail if we are at the root*/ ldns_rdf_size(parent_domain) > 0) { if ((parent_keys = ldns_fetch_valid_domain_keys_time(res, parent_domain, keys, check_time, status))) { /* Check DS records */ if ((ds_keys = ldns_validate_domain_ds_time(res, domain, parent_keys, check_time))) { trusted_keys = ldns_fetch_valid_domain_keys_time( res, domain, ds_keys, check_time, status); ldns_rr_list_deep_free(ds_keys); } else { /* No valid DS at the parent -- fail */ *status = LDNS_STATUS_CRYPTO_NO_TRUSTED_DS ; } ldns_rr_list_deep_free(parent_keys); break; } else { parent_domain = ldns_dname_left_chop(( prev_parent_domain = parent_domain )); ldns_rdf_deep_free(prev_parent_domain); } } if (parent_domain) { ldns_rdf_deep_free(parent_domain); } } } return trusted_keys; } ldns_rr_list * ldns_fetch_valid_domain_keys(const ldns_resolver *res, const ldns_rdf *domain, const ldns_rr_list *keys, ldns_status *status) { return ldns_fetch_valid_domain_keys_time( res, domain, keys, ldns_time(NULL), 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_pkt * keypkt; ldns_rr * cur_key; uint16_t key_i; uint16_t key_j; uint16_t key_k; uint16_t sig_i; ldns_rr * cur_sig; ldns_rr_list * domain_keys = NULL; ldns_rr_list * domain_sigs = NULL; ldns_rr_list * trusted_keys = NULL; /* Fetch keys for the domain */ keypkt = ldns_resolver_query(res, domain, LDNS_RR_TYPE_DNSKEY, LDNS_RR_CLASS_IN, LDNS_RD); if (keypkt) { domain_keys = ldns_pkt_rr_list_by_type(keypkt, LDNS_RR_TYPE_DNSKEY, LDNS_SECTION_ANSWER); domain_sigs = ldns_pkt_rr_list_by_type(keypkt, LDNS_RR_TYPE_RRSIG, LDNS_SECTION_ANSWER); /* Try to validate the record using our keys */ for (key_i=0; key_i< ldns_rr_list_rr_count(domain_keys); key_i++) { cur_key = ldns_rr_list_rr(domain_keys, key_i); for (key_j=0; key_j= ldns_dname_label_count(ldns_rr_owner(rr))) { /* Query name *is* the "next closer". */ hashed_next_closer = hashed_name; } else { /* "next closer" has less labels than the query name. * Create the name and hash it. */ next_closer = ldns_dname_clone_from( ldns_rr_owner(rr), ldns_dname_label_count(ldns_rr_owner(rr)) - (ldns_dname_label_count(closest_encloser) + 1) ); hashed_next_closer = ldns_nsec3_hash_name_frm_nsec3( ldns_rr_list_rr(nsecs, 0), next_closer ); (void) ldns_dname_cat(hashed_next_closer, zone_name); } /* Find the NSEC3 that covers the "next closer" */ for (i = 0; i < ldns_rr_list_rr_count(nsecs); i++) { if (ldns_nsec_covers_name(ldns_rr_list_rr(nsecs, i), hashed_next_closer) && ldns_nsec3_optout(ldns_rr_list_rr(nsecs, i))) { result = LDNS_STATUS_OK; if (match) { *match = ldns_rr_list_rr(nsecs, i); } break; } } if (ldns_dname_label_count(closest_encloser) + 1 < ldns_dname_label_count(ldns_rr_owner(rr))) { /* "next closer" has less labels than the query name. * Dispose of the temporary variables that held that name. */ ldns_rdf_deep_free(hashed_next_closer); ldns_rdf_deep_free(next_closer); } ldns_rdf_deep_free(closest_encloser); } done: ldns_rdf_deep_free(zone_name); return result; } ldns_status ldns_dnssec_verify_denial_nsec3(ldns_rr *rr, ldns_rr_list *nsecs, ldns_rr_list *rrsigs, ldns_pkt_rcode packet_rcode, ldns_rr_type packet_qtype, bool packet_nodata) { return ldns_dnssec_verify_denial_nsec3_match( rr, nsecs, rrsigs, packet_rcode, packet_qtype, packet_nodata, NULL ); } #ifdef USE_GOST EVP_PKEY* ldns_gost2pkey_raw(unsigned char* key, size_t keylen) { /* prefix header for X509 encoding */ uint8_t asn[37] = { 0x30, 0x63, 0x30, 0x1c, 0x06, 0x06, 0x2a, 0x85, 0x03, 0x02, 0x02, 0x13, 0x30, 0x12, 0x06, 0x07, 0x2a, 0x85, 0x03, 0x02, 0x02, 0x23, 0x01, 0x06, 0x07, 0x2a, 0x85, 0x03, 0x02, 0x02, 0x1e, 0x01, 0x03, 0x43, 0x00, 0x04, 0x40}; unsigned char encoded[37+64]; const unsigned char* pp; if(keylen != 64) { /* key wrong size */ return NULL; } /* create evp_key */ memmove(encoded, asn, 37); memmove(encoded+37, key, 64); pp = (unsigned char*)&encoded[0]; return d2i_PUBKEY(NULL, &pp, (int)sizeof(encoded)); } static ldns_status ldns_verify_rrsig_gost_raw(unsigned char* sig, size_t siglen, ldns_buffer* rrset, unsigned char* key, size_t keylen) { EVP_PKEY *evp_key; ldns_status result; (void) ldns_key_EVP_load_gost_id(); evp_key = ldns_gost2pkey_raw(key, keylen); if(!evp_key) { /* could not convert key */ return LDNS_STATUS_CRYPTO_BOGUS; } /* verify signature */ result = ldns_verify_rrsig_evp_raw(sig, siglen, rrset, evp_key, EVP_get_digestbyname("md_gost94")); EVP_PKEY_free(evp_key); return result; } #endif #ifdef USE_ECDSA EVP_PKEY* ldns_ecdsa2pkey_raw(unsigned char* key, size_t keylen, uint8_t algo) { unsigned char buf[256+2]; /* sufficient for 2*384/8+1 */ const unsigned char* pp = buf; EVP_PKEY *evp_key; EC_KEY *ec; /* check length, which uncompressed must be 2 bignums */ if(algo == LDNS_ECDSAP256SHA256) { if(keylen != 2*256/8) return NULL; ec = EC_KEY_new_by_curve_name(NID_X9_62_prime256v1); } else if(algo == LDNS_ECDSAP384SHA384) { if(keylen != 2*384/8) return NULL; ec = EC_KEY_new_by_curve_name(NID_secp384r1); } else ec = NULL; if(!ec) return NULL; if(keylen+1 > sizeof(buf)) return NULL; /* sanity check */ /* prepend the 0x02 (from docs) (or actually 0x04 from implementation * of openssl) for uncompressed data */ buf[0] = POINT_CONVERSION_UNCOMPRESSED; memmove(buf+1, key, keylen); if(!o2i_ECPublicKey(&ec, &pp, (int)keylen+1)) { EC_KEY_free(ec); return NULL; } evp_key = EVP_PKEY_new(); if(!evp_key) { EC_KEY_free(ec); return NULL; } if (!EVP_PKEY_assign_EC_KEY(evp_key, ec)) { EVP_PKEY_free(evp_key); EC_KEY_free(ec); return NULL; } return evp_key; } static ldns_status ldns_verify_rrsig_ecdsa_raw(unsigned char* sig, size_t siglen, ldns_buffer* rrset, unsigned char* key, size_t keylen, uint8_t algo) { EVP_PKEY *evp_key; ldns_status result; const EVP_MD *d; evp_key = ldns_ecdsa2pkey_raw(key, keylen, algo); if(!evp_key) { /* could not convert key */ return LDNS_STATUS_CRYPTO_BOGUS; } if(algo == LDNS_ECDSAP256SHA256) d = EVP_sha256(); else d = EVP_sha384(); /* LDNS_ECDSAP384SHA384 */ result = ldns_verify_rrsig_evp_raw(sig, siglen, rrset, evp_key, d); EVP_PKEY_free(evp_key); return result; } #endif ldns_status ldns_verify_rrsig_buffers(ldns_buffer *rawsig_buf, ldns_buffer *verify_buf, ldns_buffer *key_buf, uint8_t algo) { return ldns_verify_rrsig_buffers_raw( (unsigned char*)ldns_buffer_begin(rawsig_buf), ldns_buffer_position(rawsig_buf), verify_buf, (unsigned char*)ldns_buffer_begin(key_buf), ldns_buffer_position(key_buf), algo); } ldns_status ldns_verify_rrsig_buffers_raw(unsigned char* sig, size_t siglen, ldns_buffer *verify_buf, unsigned char* key, size_t keylen, uint8_t algo) { /* check for right key */ switch(algo) { case LDNS_DSA: case LDNS_DSA_NSEC3: return ldns_verify_rrsig_dsa_raw(sig, siglen, verify_buf, key, keylen); break; case LDNS_RSASHA1: case LDNS_RSASHA1_NSEC3: return ldns_verify_rrsig_rsasha1_raw(sig, siglen, verify_buf, key, keylen); break; #ifdef USE_SHA2 case LDNS_RSASHA256: return ldns_verify_rrsig_rsasha256_raw(sig, siglen, verify_buf, key, keylen); break; case LDNS_RSASHA512: return ldns_verify_rrsig_rsasha512_raw(sig, siglen, verify_buf, key, keylen); break; #endif #ifdef USE_GOST case LDNS_ECC_GOST: return ldns_verify_rrsig_gost_raw(sig, siglen, verify_buf, key, keylen); break; #endif #ifdef USE_ECDSA case LDNS_ECDSAP256SHA256: case LDNS_ECDSAP384SHA384: return ldns_verify_rrsig_ecdsa_raw(sig, siglen, verify_buf, key, keylen, algo); break; #endif case LDNS_RSAMD5: return ldns_verify_rrsig_rsamd5_raw(sig, siglen, verify_buf, key, keylen); break; default: /* do you know this alg?! */ return LDNS_STATUS_CRYPTO_UNKNOWN_ALGO; } } /** * Reset the ttl in the rrset with the orig_ttl from the sig * and update owner name if it was wildcard * Also canonicalizes the rrset. * @param rrset: rrset to modify * @param sig: signature to take TTL and wildcard values from */ static void ldns_rrset_use_signature_ttl(ldns_rr_list* rrset_clone, ldns_rr* rrsig) { uint32_t orig_ttl; uint16_t i; uint8_t label_count; ldns_rdf *wildcard_name; ldns_rdf *wildcard_chopped; ldns_rdf *wildcard_chopped_tmp; if ((rrsig == NULL) || ldns_rr_rd_count(rrsig) < 4) { return; } orig_ttl = ldns_rdf2native_int32( ldns_rr_rdf(rrsig, 3)); label_count = ldns_rdf2native_int8(ldns_rr_rdf(rrsig, 2)); for(i = 0; i < ldns_rr_list_rr_count(rrset_clone); i++) { if (label_count < ldns_dname_label_count( ldns_rr_owner(ldns_rr_list_rr(rrset_clone, i)))) { (void) ldns_str2rdf_dname(&wildcard_name, "*"); wildcard_chopped = ldns_rdf_clone(ldns_rr_owner( ldns_rr_list_rr(rrset_clone, i))); while (label_count < ldns_dname_label_count(wildcard_chopped)) { wildcard_chopped_tmp = ldns_dname_left_chop( wildcard_chopped); ldns_rdf_deep_free(wildcard_chopped); wildcard_chopped = wildcard_chopped_tmp; } (void) ldns_dname_cat(wildcard_name, wildcard_chopped); ldns_rdf_deep_free(wildcard_chopped); ldns_rdf_deep_free(ldns_rr_owner(ldns_rr_list_rr( rrset_clone, i))); ldns_rr_set_owner(ldns_rr_list_rr(rrset_clone, i), wildcard_name); } ldns_rr_set_ttl(ldns_rr_list_rr(rrset_clone, i), orig_ttl); /* convert to lowercase */ ldns_rr2canonical(ldns_rr_list_rr(rrset_clone, i)); } } /** * Make raw signature buffer out of rrsig * @param rawsig_buf: raw signature buffer for result * @param rrsig: signature to convert * @return OK or more specific error. */ static ldns_status ldns_rrsig2rawsig_buffer(ldns_buffer* rawsig_buf, ldns_rr* rrsig) { uint8_t sig_algo; if (rrsig == NULL) { return LDNS_STATUS_CRYPTO_NO_RRSIG; } if (ldns_rr_rdf(rrsig, 1) == NULL) { return LDNS_STATUS_MISSING_RDATA_FIELDS_RRSIG; } sig_algo = ldns_rdf2native_int8(ldns_rr_rdf(rrsig, 1)); /* check for known and implemented algo's now (otherwise * the function could return a wrong error */ /* create a buffer with signature rdata */ /* for some algorithms we need other data than for others... */ /* (the DSA API wants DER encoding for instance) */ switch(sig_algo) { case LDNS_RSAMD5: case LDNS_RSASHA1: case LDNS_RSASHA1_NSEC3: #ifdef USE_SHA2 case LDNS_RSASHA256: case LDNS_RSASHA512: #endif #ifdef USE_GOST case LDNS_ECC_GOST: #endif if (ldns_rr_rdf(rrsig, 8) == NULL) { return LDNS_STATUS_MISSING_RDATA_FIELDS_RRSIG; } if (ldns_rdf2buffer_wire(rawsig_buf, ldns_rr_rdf(rrsig, 8)) != LDNS_STATUS_OK) { return LDNS_STATUS_MEM_ERR; } break; case LDNS_DSA: case LDNS_DSA_NSEC3: /* EVP takes rfc2459 format, which is a tad longer than dns format */ if (ldns_rr_rdf(rrsig, 8) == NULL) { return LDNS_STATUS_MISSING_RDATA_FIELDS_RRSIG; } if (ldns_convert_dsa_rrsig_rdf2asn1( rawsig_buf, ldns_rr_rdf(rrsig, 8)) != LDNS_STATUS_OK) { /* if (ldns_rdf2buffer_wire(rawsig_buf, ldns_rr_rdf(rrsig, 8)) != LDNS_STATUS_OK) { */ return LDNS_STATUS_MEM_ERR; } break; #ifdef USE_ECDSA case LDNS_ECDSAP256SHA256: case LDNS_ECDSAP384SHA384: /* EVP produces an ASN prefix on the signature, which is * not used in the DNS */ if (ldns_rr_rdf(rrsig, 8) == NULL) { return LDNS_STATUS_MISSING_RDATA_FIELDS_RRSIG; } if (ldns_convert_ecdsa_rrsig_rdf2asn1( rawsig_buf, ldns_rr_rdf(rrsig, 8)) != LDNS_STATUS_OK) { return LDNS_STATUS_MEM_ERR; } break; #endif case LDNS_DH: case LDNS_ECC: case LDNS_INDIRECT: return LDNS_STATUS_CRYPTO_ALGO_NOT_IMPL; default: return LDNS_STATUS_CRYPTO_UNKNOWN_ALGO; } return LDNS_STATUS_OK; } /** * Check RRSIG timestamps against the given 'now' time. * @param rrsig: signature to check. * @param now: the current time in seconds epoch. * @return status code LDNS_STATUS_OK if all is fine. */ static ldns_status ldns_rrsig_check_timestamps(ldns_rr* rrsig, time_t now) { int32_t inception, expiration; /* check the signature time stamps */ inception = (int32_t)ldns_rdf2native_time_t( ldns_rr_rrsig_inception(rrsig)); expiration = (int32_t)ldns_rdf2native_time_t( ldns_rr_rrsig_expiration(rrsig)); if (expiration - inception < 0) { /* bad sig, expiration before inception?? Tsssg */ return LDNS_STATUS_CRYPTO_EXPIRATION_BEFORE_INCEPTION; } if (((int32_t) now) - inception < 0) { /* bad sig, inception date has not yet come to pass */ return LDNS_STATUS_CRYPTO_SIG_NOT_INCEPTED; } if (expiration - ((int32_t) now) < 0) { /* bad sig, expiration date has passed */ return LDNS_STATUS_CRYPTO_SIG_EXPIRED; } return LDNS_STATUS_OK; } /** * Prepare for verification. * @param rawsig_buf: raw signature buffer made ready. * @param verify_buf: data for verification buffer made ready. * @param rrset_clone: made ready. * @param rrsig: signature to prepare for. * @return LDNS_STATUS_OK is all went well. Otherwise specific error. */ static ldns_status ldns_prepare_for_verify(ldns_buffer* rawsig_buf, ldns_buffer* verify_buf, ldns_rr_list* rrset_clone, ldns_rr* rrsig) { ldns_status result; /* canonicalize the sig */ ldns_dname2canonical(ldns_rr_owner(rrsig)); /* check if the typecovered is equal to the type checked */ if (ldns_rdf2rr_type(ldns_rr_rrsig_typecovered(rrsig)) != ldns_rr_get_type(ldns_rr_list_rr(rrset_clone, 0))) return LDNS_STATUS_CRYPTO_TYPE_COVERED_ERR; /* create a buffer with b64 signature rdata */ result = ldns_rrsig2rawsig_buffer(rawsig_buf, rrsig); if(result != LDNS_STATUS_OK) return result; /* use TTL from signature. Use wildcard names for wildcards */ /* also canonicalizes rrset_clone */ ldns_rrset_use_signature_ttl(rrset_clone, rrsig); /* sort the rrset in canonical order */ ldns_rr_list_sort(rrset_clone); /* put the signature rr (without the b64) to the verify_buf */ if (ldns_rrsig2buffer_wire(verify_buf, rrsig) != LDNS_STATUS_OK) return LDNS_STATUS_MEM_ERR; /* add the rrset in verify_buf */ if(ldns_rr_list2buffer_wire(verify_buf, rrset_clone) != LDNS_STATUS_OK) return LDNS_STATUS_MEM_ERR; return LDNS_STATUS_OK; } /** * Check if a key matches a signature. * Checks keytag, sigalgo and signature. * @param rawsig_buf: raw signature buffer for verify * @param verify_buf: raw data buffer for verify * @param rrsig: the rrsig * @param key: key to attempt. * @return LDNS_STATUS_OK if OK, else some specific error. */ static ldns_status ldns_verify_test_sig_key(ldns_buffer* rawsig_buf, ldns_buffer* verify_buf, ldns_rr* rrsig, ldns_rr* key) { uint8_t sig_algo; if (rrsig == NULL) { return LDNS_STATUS_CRYPTO_NO_RRSIG; } if (ldns_rr_rdf(rrsig, 1) == NULL) { return LDNS_STATUS_MISSING_RDATA_FIELDS_RRSIG; } sig_algo = ldns_rdf2native_int8(ldns_rr_rdf(rrsig, 1)); /* before anything, check if the keytags match */ if (ldns_calc_keytag(key) == ldns_rdf2native_int16(ldns_rr_rrsig_keytag(rrsig)) ) { ldns_buffer* key_buf = ldns_buffer_new(LDNS_MAX_PACKETLEN); ldns_status result = LDNS_STATUS_ERR; /* put the key-data in a buffer, that's the third rdf, with * the base64 encoded key data */ if (ldns_rr_rdf(key, 3) == NULL) { ldns_buffer_free(key_buf); return LDNS_STATUS_MISSING_RDATA_FIELDS_KEY; } if (ldns_rdf2buffer_wire(key_buf, ldns_rr_rdf(key, 3)) != LDNS_STATUS_OK) { ldns_buffer_free(key_buf); /* returning is bad might screw up good keys later in the list what to do? */ return LDNS_STATUS_ERR; } if (ldns_rr_rdf(key, 2) == NULL) { result = LDNS_STATUS_MISSING_RDATA_FIELDS_KEY; } else if (sig_algo == ldns_rdf2native_int8( ldns_rr_rdf(key, 2))) { result = ldns_verify_rrsig_buffers(rawsig_buf, verify_buf, key_buf, sig_algo); } else { /* No keys with the corresponding algorithm are found */ result = LDNS_STATUS_CRYPTO_NO_MATCHING_KEYTAG_DNSKEY; } ldns_buffer_free(key_buf); return result; } else { /* No keys with the corresponding keytag are found */ return LDNS_STATUS_CRYPTO_NO_MATCHING_KEYTAG_DNSKEY; } } /* * to verify: * - create the wire fmt of the b64 key rdata * - create the wire fmt of the sorted rrset * - create the wire fmt of the b64 sig rdata * - create the wire fmt of the sig without the b64 rdata * - cat the sig data (without b64 rdata) to the rrset * - verify the rrset+sig, with the b64 data and the b64 key data */ ldns_status ldns_verify_rrsig_keylist_time( ldns_rr_list *rrset, ldns_rr *rrsig, const ldns_rr_list *keys, time_t check_time, ldns_rr_list *good_keys) { ldns_status result; ldns_rr_list *valid = ldns_rr_list_new(); if (!valid) return LDNS_STATUS_MEM_ERR; result = ldns_verify_rrsig_keylist_notime(rrset, rrsig, keys, valid); if(result != LDNS_STATUS_OK) { ldns_rr_list_free(valid); return result; } /* check timestamps last; its OK except time */ result = ldns_rrsig_check_timestamps(rrsig, check_time); if(result != LDNS_STATUS_OK) { ldns_rr_list_free(valid); return result; } ldns_rr_list_cat(good_keys, valid); ldns_rr_list_free(valid); return LDNS_STATUS_OK; } /* * to verify: * - create the wire fmt of the b64 key rdata * - create the wire fmt of the sorted rrset * - create the wire fmt of the b64 sig rdata * - create the wire fmt of the sig without the b64 rdata * - cat the sig data (without b64 rdata) to the rrset * - verify the rrset+sig, with the b64 data and the b64 key data */ ldns_status ldns_verify_rrsig_keylist(ldns_rr_list *rrset, ldns_rr *rrsig, const ldns_rr_list *keys, ldns_rr_list *good_keys) { return ldns_verify_rrsig_keylist_time( rrset, rrsig, keys, ldns_time(NULL), good_keys); } ldns_status ldns_verify_rrsig_keylist_notime(ldns_rr_list *rrset, ldns_rr *rrsig, const ldns_rr_list *keys, ldns_rr_list *good_keys) { ldns_buffer *rawsig_buf; ldns_buffer *verify_buf; uint16_t i; ldns_status result, status; ldns_rr_list *rrset_clone; ldns_rr_list *validkeys; if (!rrset) { return LDNS_STATUS_ERR; } validkeys = ldns_rr_list_new(); if (!validkeys) { return LDNS_STATUS_MEM_ERR; } /* clone the rrset so that we can fiddle with it */ rrset_clone = ldns_rr_list_clone(rrset); /* create the buffers which will certainly hold the raw data */ rawsig_buf = ldns_buffer_new(LDNS_MAX_PACKETLEN); verify_buf = ldns_buffer_new(LDNS_MAX_PACKETLEN); result = ldns_prepare_for_verify(rawsig_buf, verify_buf, rrset_clone, rrsig); if(result != LDNS_STATUS_OK) { ldns_buffer_free(verify_buf); ldns_buffer_free(rawsig_buf); ldns_rr_list_deep_free(rrset_clone); ldns_rr_list_free(validkeys); return result; } result = LDNS_STATUS_CRYPTO_NO_MATCHING_KEYTAG_DNSKEY; for(i = 0; i < ldns_rr_list_rr_count(keys); i++) { status = ldns_verify_test_sig_key(rawsig_buf, verify_buf, rrsig, ldns_rr_list_rr(keys, i)); if (status == LDNS_STATUS_OK) { /* one of the keys has matched, don't break * here, instead put the 'winning' key in * the validkey list and return the list * later */ if (!ldns_rr_list_push_rr(validkeys, ldns_rr_list_rr(keys,i))) { /* couldn't push the key?? */ ldns_buffer_free(rawsig_buf); ldns_buffer_free(verify_buf); ldns_rr_list_deep_free(rrset_clone); ldns_rr_list_free(validkeys); return LDNS_STATUS_MEM_ERR; } result = status; } if (result == LDNS_STATUS_CRYPTO_NO_MATCHING_KEYTAG_DNSKEY) { result = status; } } /* no longer needed */ ldns_rr_list_deep_free(rrset_clone); ldns_buffer_free(rawsig_buf); ldns_buffer_free(verify_buf); if (ldns_rr_list_rr_count(validkeys) == 0) { /* no keys were added, return last error */ ldns_rr_list_free(validkeys); return result; } /* do not check timestamps */ ldns_rr_list_cat(good_keys, validkeys); ldns_rr_list_free(validkeys); return LDNS_STATUS_OK; } ldns_status ldns_verify_rrsig_time( ldns_rr_list *rrset, ldns_rr *rrsig, ldns_rr *key, time_t check_time) { ldns_buffer *rawsig_buf; ldns_buffer *verify_buf; ldns_status result; ldns_rr_list *rrset_clone; if (!rrset) { return LDNS_STATUS_NO_DATA; } /* clone the rrset so that we can fiddle with it */ rrset_clone = ldns_rr_list_clone(rrset); /* create the buffers which will certainly hold the raw data */ rawsig_buf = ldns_buffer_new(LDNS_MAX_PACKETLEN); verify_buf = ldns_buffer_new(LDNS_MAX_PACKETLEN); result = ldns_prepare_for_verify(rawsig_buf, verify_buf, rrset_clone, rrsig); if(result != LDNS_STATUS_OK) { ldns_rr_list_deep_free(rrset_clone); ldns_buffer_free(rawsig_buf); ldns_buffer_free(verify_buf); return result; } result = ldns_verify_test_sig_key(rawsig_buf, verify_buf, rrsig, key); /* no longer needed */ ldns_rr_list_deep_free(rrset_clone); ldns_buffer_free(rawsig_buf); ldns_buffer_free(verify_buf); /* check timestamp last, apart from time its OK */ if(result == LDNS_STATUS_OK) result = ldns_rrsig_check_timestamps(rrsig, check_time); return result; } ldns_status ldns_verify_rrsig(ldns_rr_list *rrset, ldns_rr *rrsig, ldns_rr *key) { return ldns_verify_rrsig_time(rrset, rrsig, key, ldns_time(NULL)); } ldns_status ldns_verify_rrsig_evp(ldns_buffer *sig, ldns_buffer *rrset, EVP_PKEY *key, const EVP_MD *digest_type) { return ldns_verify_rrsig_evp_raw( (unsigned char*)ldns_buffer_begin(sig), ldns_buffer_position(sig), rrset, key, digest_type); } ldns_status ldns_verify_rrsig_evp_raw(unsigned char *sig, size_t siglen, ldns_buffer *rrset, EVP_PKEY *key, const EVP_MD *digest_type) { EVP_MD_CTX ctx; int res; EVP_MD_CTX_init(&ctx); EVP_VerifyInit(&ctx, digest_type); EVP_VerifyUpdate(&ctx, ldns_buffer_begin(rrset), ldns_buffer_position(rrset)); res = EVP_VerifyFinal(&ctx, sig, (unsigned int) siglen, key); EVP_MD_CTX_cleanup(&ctx); if (res == 1) { return LDNS_STATUS_OK; } else if (res == 0) { return LDNS_STATUS_CRYPTO_BOGUS; } /* TODO how to communicate internal SSL error? let caller use ssl's get_error() */ return LDNS_STATUS_SSL_ERR; } ldns_status ldns_verify_rrsig_dsa(ldns_buffer *sig, ldns_buffer *rrset, ldns_buffer *key) { return ldns_verify_rrsig_dsa_raw( (unsigned char*) ldns_buffer_begin(sig), ldns_buffer_position(sig), rrset, (unsigned char*) ldns_buffer_begin(key), ldns_buffer_position(key)); } ldns_status ldns_verify_rrsig_rsasha1(ldns_buffer *sig, ldns_buffer *rrset, ldns_buffer *key) { return ldns_verify_rrsig_rsasha1_raw( (unsigned char*)ldns_buffer_begin(sig), ldns_buffer_position(sig), rrset, (unsigned char*) ldns_buffer_begin(key), ldns_buffer_position(key)); } ldns_status ldns_verify_rrsig_rsamd5(ldns_buffer *sig, ldns_buffer *rrset, ldns_buffer *key) { return ldns_verify_rrsig_rsamd5_raw( (unsigned char*)ldns_buffer_begin(sig), ldns_buffer_position(sig), rrset, (unsigned char*) ldns_buffer_begin(key), ldns_buffer_position(key)); } ldns_status ldns_verify_rrsig_dsa_raw(unsigned char* sig, size_t siglen, ldns_buffer* rrset, unsigned char* key, size_t keylen) { EVP_PKEY *evp_key; ldns_status result; evp_key = EVP_PKEY_new(); if (EVP_PKEY_assign_DSA(evp_key, ldns_key_buf2dsa_raw(key, keylen))) { result = ldns_verify_rrsig_evp_raw(sig, siglen, rrset, evp_key, EVP_dss1()); } else { result = LDNS_STATUS_SSL_ERR; } EVP_PKEY_free(evp_key); return result; } ldns_status ldns_verify_rrsig_rsasha1_raw(unsigned char* sig, size_t siglen, ldns_buffer* rrset, unsigned char* key, size_t keylen) { EVP_PKEY *evp_key; ldns_status result; evp_key = EVP_PKEY_new(); if (EVP_PKEY_assign_RSA(evp_key, ldns_key_buf2rsa_raw(key, keylen))) { result = ldns_verify_rrsig_evp_raw(sig, siglen, rrset, evp_key, EVP_sha1()); } else { result = LDNS_STATUS_SSL_ERR; } EVP_PKEY_free(evp_key); return result; } ldns_status ldns_verify_rrsig_rsasha256_raw(unsigned char* sig, size_t siglen, ldns_buffer* rrset, unsigned char* key, size_t keylen) { #ifdef USE_SHA2 EVP_PKEY *evp_key; ldns_status result; evp_key = EVP_PKEY_new(); if (EVP_PKEY_assign_RSA(evp_key, ldns_key_buf2rsa_raw(key, keylen))) { result = ldns_verify_rrsig_evp_raw(sig, siglen, rrset, evp_key, EVP_sha256()); } else { result = LDNS_STATUS_SSL_ERR; } EVP_PKEY_free(evp_key); return result; #else /* touch these to prevent compiler warnings */ (void) sig; (void) siglen; (void) rrset; (void) key; (void) keylen; return LDNS_STATUS_CRYPTO_UNKNOWN_ALGO; #endif } ldns_status ldns_verify_rrsig_rsasha512_raw(unsigned char* sig, size_t siglen, ldns_buffer* rrset, unsigned char* key, size_t keylen) { #ifdef USE_SHA2 EVP_PKEY *evp_key; ldns_status result; evp_key = EVP_PKEY_new(); if (EVP_PKEY_assign_RSA(evp_key, ldns_key_buf2rsa_raw(key, keylen))) { result = ldns_verify_rrsig_evp_raw(sig, siglen, rrset, evp_key, EVP_sha512()); } else { result = LDNS_STATUS_SSL_ERR; } EVP_PKEY_free(evp_key); return result; #else /* touch these to prevent compiler warnings */ (void) sig; (void) siglen; (void) rrset; (void) key; (void) keylen; return LDNS_STATUS_CRYPTO_UNKNOWN_ALGO; #endif } ldns_status ldns_verify_rrsig_rsamd5_raw(unsigned char* sig, size_t siglen, ldns_buffer* rrset, unsigned char* key, size_t keylen) { EVP_PKEY *evp_key; ldns_status result; evp_key = EVP_PKEY_new(); if (EVP_PKEY_assign_RSA(evp_key, ldns_key_buf2rsa_raw(key, keylen))) { result = ldns_verify_rrsig_evp_raw(sig, siglen, rrset, evp_key, EVP_md5()); } else { result = LDNS_STATUS_SSL_ERR; } EVP_PKEY_free(evp_key); return result; } #endif ldns-1.6.17/packet.c0000664000175100017510000005774012264060151013543 0ustar willemwillem/* * packet.c * * dns packet implementation * * a Net::DNS like library for C * * (c) NLnet Labs, 2004-2006 * * See the file LICENSE for the license */ #include #include #include #include #ifdef HAVE_SSL #include #endif /* Access functions * do this as functions to get type checking */ #define LDNS_EDNS_MASK_DO_BIT 0x8000 /* TODO defines for 3600 */ /* convert to and from numerical flag values */ ldns_lookup_table ldns_edns_flags[] = { { 3600, "do"}, { 0, NULL} }; /* read */ uint16_t ldns_pkt_id(const ldns_pkt *packet) { return packet->_header->_id; } bool ldns_pkt_qr(const ldns_pkt *packet) { return packet->_header->_qr; } bool ldns_pkt_aa(const ldns_pkt *packet) { return packet->_header->_aa; } bool ldns_pkt_tc(const ldns_pkt *packet) { return packet->_header->_tc; } bool ldns_pkt_rd(const ldns_pkt *packet) { return packet->_header->_rd; } bool ldns_pkt_cd(const ldns_pkt *packet) { return packet->_header->_cd; } bool ldns_pkt_ra(const ldns_pkt *packet) { return packet->_header->_ra; } bool ldns_pkt_ad(const ldns_pkt *packet) { return packet->_header->_ad; } ldns_pkt_opcode ldns_pkt_get_opcode(const ldns_pkt *packet) { return packet->_header->_opcode; } ldns_pkt_rcode ldns_pkt_get_rcode(const ldns_pkt *packet) { return packet->_header->_rcode; } uint16_t ldns_pkt_qdcount(const ldns_pkt *packet) { return packet->_header->_qdcount; } uint16_t ldns_pkt_ancount(const ldns_pkt *packet) { return packet->_header->_ancount; } uint16_t ldns_pkt_nscount(const ldns_pkt *packet) { return packet->_header->_nscount; } uint16_t ldns_pkt_arcount(const ldns_pkt *packet) { return packet->_header->_arcount; } ldns_rr_list * ldns_pkt_question(const ldns_pkt *packet) { return packet->_question; } ldns_rr_list * ldns_pkt_answer(const ldns_pkt *packet) { return packet->_answer; } ldns_rr_list * ldns_pkt_authority(const ldns_pkt *packet) { return packet->_authority; } ldns_rr_list * ldns_pkt_additional(const ldns_pkt *packet) { return packet->_additional; } /* return ALL section concatenated */ ldns_rr_list * ldns_pkt_all(const ldns_pkt *packet) { ldns_rr_list *all, *prev_all; all = ldns_rr_list_cat_clone( ldns_pkt_question(packet), ldns_pkt_answer(packet)); prev_all = all; all = ldns_rr_list_cat_clone(all, ldns_pkt_authority(packet)); ldns_rr_list_deep_free(prev_all); prev_all = all; all = ldns_rr_list_cat_clone(all, ldns_pkt_additional(packet)); ldns_rr_list_deep_free(prev_all); return all; } ldns_rr_list * ldns_pkt_all_noquestion(const ldns_pkt *packet) { ldns_rr_list *all, *all2; all = ldns_rr_list_cat_clone( ldns_pkt_answer(packet), ldns_pkt_authority(packet)); all2 = ldns_rr_list_cat_clone(all, ldns_pkt_additional(packet)); ldns_rr_list_deep_free(all); return all2; } size_t ldns_pkt_size(const ldns_pkt *packet) { return packet->_size; } uint32_t ldns_pkt_querytime(const ldns_pkt *packet) { return packet->_querytime; } ldns_rdf * ldns_pkt_answerfrom(const ldns_pkt *packet) { return packet->_answerfrom; } struct timeval ldns_pkt_timestamp(const ldns_pkt *packet) { return packet->timestamp; } uint16_t ldns_pkt_edns_udp_size(const ldns_pkt *packet) { return packet->_edns_udp_size; } uint8_t ldns_pkt_edns_extended_rcode(const ldns_pkt *packet) { return packet->_edns_extended_rcode; } uint8_t ldns_pkt_edns_version(const ldns_pkt *packet) { return packet->_edns_version; } uint16_t ldns_pkt_edns_z(const ldns_pkt *packet) { return packet->_edns_z; } bool ldns_pkt_edns_do(const ldns_pkt *packet) { return (packet->_edns_z & LDNS_EDNS_MASK_DO_BIT); } void ldns_pkt_set_edns_do(ldns_pkt *packet, bool value) { if (value) { packet->_edns_z = packet->_edns_z | LDNS_EDNS_MASK_DO_BIT; } else { packet->_edns_z = packet->_edns_z & ~LDNS_EDNS_MASK_DO_BIT; } } ldns_rdf * ldns_pkt_edns_data(const ldns_pkt *packet) { return packet->_edns_data; } /* return only those rr that share the ownername */ ldns_rr_list * ldns_pkt_rr_list_by_name(ldns_pkt *packet, ldns_rdf *ownername, ldns_pkt_section sec) { ldns_rr_list *rrs; ldns_rr_list *ret; uint16_t i; if (!packet) { return NULL; } rrs = ldns_pkt_get_section_clone(packet, sec); ret = NULL; for(i = 0; i < ldns_rr_list_rr_count(rrs); i++) { if (ldns_dname_compare(ldns_rr_owner( ldns_rr_list_rr(rrs, i)), ownername) == 0) { /* owner names match */ if (ret == NULL) { ret = ldns_rr_list_new(); } ldns_rr_list_push_rr(ret, ldns_rr_list_rr(rrs, i)); } } return ret; } /* return only those rr that share a type */ ldns_rr_list * ldns_pkt_rr_list_by_type(const ldns_pkt *packet, ldns_rr_type type, ldns_pkt_section sec) { ldns_rr_list *rrs; ldns_rr_list *new; uint16_t i; if(!packet) { return NULL; } rrs = ldns_pkt_get_section_clone(packet, sec); new = ldns_rr_list_new(); for(i = 0; i < ldns_rr_list_rr_count(rrs); i++) { if (type == ldns_rr_get_type(ldns_rr_list_rr(rrs, i))) { /* types match */ ldns_rr_list_push_rr(new, ldns_rr_clone( ldns_rr_list_rr(rrs, i)) ); } } ldns_rr_list_deep_free(rrs); if (ldns_rr_list_rr_count(new) == 0) { ldns_rr_list_free(new); return NULL; } else { return new; } } /* return only those rrs that share name and type */ ldns_rr_list * ldns_pkt_rr_list_by_name_and_type(const ldns_pkt *packet, const ldns_rdf *ownername, ldns_rr_type type, ldns_pkt_section sec) { ldns_rr_list *rrs; ldns_rr_list *new; ldns_rr_list *ret; uint16_t i; if(!packet) { return NULL; } rrs = ldns_pkt_get_section_clone(packet, sec); new = ldns_rr_list_new(); ret = NULL; for(i = 0; i < ldns_rr_list_rr_count(rrs); i++) { if (type == ldns_rr_get_type(ldns_rr_list_rr(rrs, i)) && ldns_dname_compare(ldns_rr_owner(ldns_rr_list_rr(rrs, i)), ownername ) == 0 ) { /* types match */ ldns_rr_list_push_rr(new, ldns_rr_clone(ldns_rr_list_rr(rrs, i))); ret = new; } } ldns_rr_list_deep_free(rrs); if (!ret) { ldns_rr_list_free(new); } return ret; } bool ldns_pkt_rr(ldns_pkt *pkt, ldns_pkt_section sec, ldns_rr *rr) { bool result = false; switch (sec) { case LDNS_SECTION_QUESTION: return ldns_rr_list_contains_rr(ldns_pkt_question(pkt), rr); case LDNS_SECTION_ANSWER: return ldns_rr_list_contains_rr(ldns_pkt_answer(pkt), rr); case LDNS_SECTION_AUTHORITY: return ldns_rr_list_contains_rr(ldns_pkt_authority(pkt), rr); case LDNS_SECTION_ADDITIONAL: return ldns_rr_list_contains_rr(ldns_pkt_additional(pkt), rr); case LDNS_SECTION_ANY: result = ldns_rr_list_contains_rr(ldns_pkt_question(pkt), rr); case LDNS_SECTION_ANY_NOQUESTION: result = result || ldns_rr_list_contains_rr(ldns_pkt_answer(pkt), rr) || ldns_rr_list_contains_rr(ldns_pkt_authority(pkt), rr) || ldns_rr_list_contains_rr(ldns_pkt_additional(pkt), rr); } return result; } uint16_t ldns_pkt_section_count(const ldns_pkt *packet, ldns_pkt_section s) { switch(s) { case LDNS_SECTION_QUESTION: return ldns_pkt_qdcount(packet); case LDNS_SECTION_ANSWER: return ldns_pkt_ancount(packet); case LDNS_SECTION_AUTHORITY: return ldns_pkt_nscount(packet); case LDNS_SECTION_ADDITIONAL: return ldns_pkt_arcount(packet); case LDNS_SECTION_ANY: return ldns_pkt_qdcount(packet) + ldns_pkt_ancount(packet) + ldns_pkt_nscount(packet) + ldns_pkt_arcount(packet); case LDNS_SECTION_ANY_NOQUESTION: return ldns_pkt_ancount(packet) + ldns_pkt_nscount(packet) + ldns_pkt_arcount(packet); default: return 0; } } bool ldns_pkt_empty(ldns_pkt *p) { if (!p) { return true; /* NULL is empty? */ } if (ldns_pkt_section_count(p, LDNS_SECTION_ANY) > 0) { return false; } else { return true; } } ldns_rr_list * ldns_pkt_get_section_clone(const ldns_pkt *packet, ldns_pkt_section s) { switch(s) { case LDNS_SECTION_QUESTION: return ldns_rr_list_clone(ldns_pkt_question(packet)); case LDNS_SECTION_ANSWER: return ldns_rr_list_clone(ldns_pkt_answer(packet)); case LDNS_SECTION_AUTHORITY: return ldns_rr_list_clone(ldns_pkt_authority(packet)); case LDNS_SECTION_ADDITIONAL: return ldns_rr_list_clone(ldns_pkt_additional(packet)); case LDNS_SECTION_ANY: /* these are already clones */ return ldns_pkt_all(packet); case LDNS_SECTION_ANY_NOQUESTION: return ldns_pkt_all_noquestion(packet); default: return NULL; } } ldns_rr *ldns_pkt_tsig(const ldns_pkt *pkt) { return pkt->_tsig_rr; } /* write */ void ldns_pkt_set_id(ldns_pkt *packet, uint16_t id) { packet->_header->_id = id; } void ldns_pkt_set_random_id(ldns_pkt *packet) { uint16_t rid = ldns_get_random(); ldns_pkt_set_id(packet, rid); } void ldns_pkt_set_qr(ldns_pkt *packet, bool qr) { packet->_header->_qr = qr; } void ldns_pkt_set_aa(ldns_pkt *packet, bool aa) { packet->_header->_aa = aa; } void ldns_pkt_set_tc(ldns_pkt *packet, bool tc) { packet->_header->_tc = tc; } void ldns_pkt_set_rd(ldns_pkt *packet, bool rd) { packet->_header->_rd = rd; } void ldns_pkt_set_additional(ldns_pkt *p, ldns_rr_list *rr) { p->_additional = rr; } void ldns_pkt_set_question(ldns_pkt *p, ldns_rr_list *rr) { p->_question = rr; } void ldns_pkt_set_answer(ldns_pkt *p, ldns_rr_list *rr) { p->_answer = rr; } void ldns_pkt_set_authority(ldns_pkt *p, ldns_rr_list *rr) { p->_authority = rr; } void ldns_pkt_set_cd(ldns_pkt *packet, bool cd) { packet->_header->_cd = cd; } void ldns_pkt_set_ra(ldns_pkt *packet, bool ra) { packet->_header->_ra = ra; } void ldns_pkt_set_ad(ldns_pkt *packet, bool ad) { packet->_header->_ad = ad; } void ldns_pkt_set_opcode(ldns_pkt *packet, ldns_pkt_opcode opcode) { packet->_header->_opcode = opcode; } void ldns_pkt_set_rcode(ldns_pkt *packet, uint8_t rcode) { packet->_header->_rcode = rcode; } void ldns_pkt_set_qdcount(ldns_pkt *packet, uint16_t qdcount) { packet->_header->_qdcount = qdcount; } void ldns_pkt_set_ancount(ldns_pkt *packet, uint16_t ancount) { packet->_header->_ancount = ancount; } void ldns_pkt_set_nscount(ldns_pkt *packet, uint16_t nscount) { packet->_header->_nscount = nscount; } void ldns_pkt_set_arcount(ldns_pkt *packet, uint16_t arcount) { packet->_header->_arcount = arcount; } void ldns_pkt_set_querytime(ldns_pkt *packet, uint32_t time) { packet->_querytime = time; } void ldns_pkt_set_answerfrom(ldns_pkt *packet, ldns_rdf *answerfrom) { packet->_answerfrom = answerfrom; } void ldns_pkt_set_timestamp(ldns_pkt *packet, struct timeval timeval) { packet->timestamp.tv_sec = timeval.tv_sec; packet->timestamp.tv_usec = timeval.tv_usec; } void ldns_pkt_set_size(ldns_pkt *packet, size_t s) { packet->_size = s; } void ldns_pkt_set_edns_udp_size(ldns_pkt *packet, uint16_t s) { packet->_edns_udp_size = s; } void ldns_pkt_set_edns_extended_rcode(ldns_pkt *packet, uint8_t c) { packet->_edns_extended_rcode = c; } void ldns_pkt_set_edns_version(ldns_pkt *packet, uint8_t v) { packet->_edns_version = v; } void ldns_pkt_set_edns_z(ldns_pkt *packet, uint16_t z) { packet->_edns_z = z; } void ldns_pkt_set_edns_data(ldns_pkt *packet, ldns_rdf *data) { packet->_edns_data = data; } void ldns_pkt_set_section_count(ldns_pkt *packet, ldns_pkt_section s, uint16_t count) { switch(s) { case LDNS_SECTION_QUESTION: ldns_pkt_set_qdcount(packet, count); break; case LDNS_SECTION_ANSWER: ldns_pkt_set_ancount(packet, count); break; case LDNS_SECTION_AUTHORITY: ldns_pkt_set_nscount(packet, count); break; case LDNS_SECTION_ADDITIONAL: ldns_pkt_set_arcount(packet, count); break; case LDNS_SECTION_ANY: case LDNS_SECTION_ANY_NOQUESTION: break; } } void ldns_pkt_set_tsig(ldns_pkt *pkt, ldns_rr *rr) { pkt->_tsig_rr = rr; } bool ldns_pkt_push_rr(ldns_pkt *packet, ldns_pkt_section section, ldns_rr *rr) { switch(section) { case LDNS_SECTION_QUESTION: if (!ldns_rr_list_push_rr(ldns_pkt_question(packet), rr)) { return false; } ldns_pkt_set_qdcount(packet, ldns_pkt_qdcount(packet) + 1); break; case LDNS_SECTION_ANSWER: if (!ldns_rr_list_push_rr(ldns_pkt_answer(packet), rr)) { return false; } ldns_pkt_set_ancount(packet, ldns_pkt_ancount(packet) + 1); break; case LDNS_SECTION_AUTHORITY: if (!ldns_rr_list_push_rr(ldns_pkt_authority(packet), rr)) { return false; } ldns_pkt_set_nscount(packet, ldns_pkt_nscount(packet) + 1); break; case LDNS_SECTION_ADDITIONAL: if (!ldns_rr_list_push_rr(ldns_pkt_additional(packet), rr)) { return false; } ldns_pkt_set_arcount(packet, ldns_pkt_arcount(packet) + 1); break; case LDNS_SECTION_ANY: case LDNS_SECTION_ANY_NOQUESTION: /* shouldn't this error? */ break; } return true; } bool ldns_pkt_safe_push_rr(ldns_pkt *pkt, ldns_pkt_section sec, ldns_rr *rr) { /* check to see if its there */ if (ldns_pkt_rr(pkt, sec, rr)) { /* already there */ return false; } return ldns_pkt_push_rr(pkt, sec, rr); } bool ldns_pkt_push_rr_list(ldns_pkt *p, ldns_pkt_section s, ldns_rr_list *list) { size_t i; for(i = 0; i < ldns_rr_list_rr_count(list); i++) { if (!ldns_pkt_push_rr(p, s, ldns_rr_list_rr(list, i))) { return false; } } return true; } bool ldns_pkt_safe_push_rr_list(ldns_pkt *p, ldns_pkt_section s, ldns_rr_list *list) { size_t i; for(i = 0; i < ldns_rr_list_rr_count(list); i++) { if (!ldns_pkt_safe_push_rr(p, s, ldns_rr_list_rr(list, i))) { return false; } } return true; } bool ldns_pkt_edns(const ldns_pkt *pkt) { return (ldns_pkt_edns_udp_size(pkt) > 0 || ldns_pkt_edns_extended_rcode(pkt) > 0 || ldns_pkt_edns_data(pkt) || ldns_pkt_edns_do(pkt) ); } /* Create/destroy/convert functions */ ldns_pkt * ldns_pkt_new(void) { ldns_pkt *packet; packet = LDNS_MALLOC(ldns_pkt); if (!packet) { return NULL; } packet->_header = LDNS_MALLOC(ldns_hdr); if (!packet->_header) { LDNS_FREE(packet); return NULL; } packet->_question = ldns_rr_list_new(); packet->_answer = ldns_rr_list_new(); packet->_authority = ldns_rr_list_new(); packet->_additional = ldns_rr_list_new(); /* default everything to false */ ldns_pkt_set_qr(packet, false); ldns_pkt_set_aa(packet, false); ldns_pkt_set_tc(packet, false); ldns_pkt_set_rd(packet, false); ldns_pkt_set_ra(packet, false); ldns_pkt_set_ad(packet, false); ldns_pkt_set_cd(packet, false); ldns_pkt_set_opcode(packet, LDNS_PACKET_QUERY); ldns_pkt_set_rcode(packet, 0); ldns_pkt_set_id(packet, 0); ldns_pkt_set_size(packet, 0); ldns_pkt_set_querytime(packet, 0); memset(&packet->timestamp, 0, sizeof(packet->timestamp)); ldns_pkt_set_answerfrom(packet, NULL); ldns_pkt_set_section_count(packet, LDNS_SECTION_QUESTION, 0); ldns_pkt_set_section_count(packet, LDNS_SECTION_ANSWER, 0); ldns_pkt_set_section_count(packet, LDNS_SECTION_AUTHORITY, 0); ldns_pkt_set_section_count(packet, LDNS_SECTION_ADDITIONAL, 0); ldns_pkt_set_edns_udp_size(packet, 0); ldns_pkt_set_edns_extended_rcode(packet, 0); ldns_pkt_set_edns_version(packet, 0); ldns_pkt_set_edns_z(packet, 0); ldns_pkt_set_edns_data(packet, NULL); ldns_pkt_set_tsig(packet, NULL); return packet; } void ldns_pkt_free(ldns_pkt *packet) { if (packet) { LDNS_FREE(packet->_header); ldns_rr_list_deep_free(packet->_question); ldns_rr_list_deep_free(packet->_answer); ldns_rr_list_deep_free(packet->_authority); ldns_rr_list_deep_free(packet->_additional); ldns_rr_free(packet->_tsig_rr); ldns_rdf_deep_free(packet->_edns_data); ldns_rdf_deep_free(packet->_answerfrom); LDNS_FREE(packet); } } bool ldns_pkt_set_flags(ldns_pkt *packet, uint16_t flags) { if (!packet) { return false; } if ((flags & LDNS_QR) == LDNS_QR) { ldns_pkt_set_qr(packet, true); } if ((flags & LDNS_AA) == LDNS_AA) { ldns_pkt_set_aa(packet, true); } if ((flags & LDNS_RD) == LDNS_RD) { ldns_pkt_set_rd(packet, true); } if ((flags & LDNS_TC) == LDNS_TC) { ldns_pkt_set_tc(packet, true); } if ((flags & LDNS_CD) == LDNS_CD) { ldns_pkt_set_cd(packet, true); } if ((flags & LDNS_RA) == LDNS_RA) { ldns_pkt_set_ra(packet, true); } if ((flags & LDNS_AD) == LDNS_AD) { ldns_pkt_set_ad(packet, true); } return true; } static ldns_rr* ldns_pkt_authsoa(ldns_rdf* rr_name, ldns_rr_class rr_class) { ldns_rr* soa_rr = ldns_rr_new(); ldns_rdf *owner_rdf; ldns_rdf *mname_rdf; ldns_rdf *rname_rdf; ldns_rdf *serial_rdf; ldns_rdf *refresh_rdf; ldns_rdf *retry_rdf; ldns_rdf *expire_rdf; ldns_rdf *minimum_rdf; if (!soa_rr) { return NULL; } owner_rdf = ldns_rdf_clone(rr_name); if (!owner_rdf) { ldns_rr_free(soa_rr); return NULL; } ldns_rr_set_owner(soa_rr, owner_rdf); ldns_rr_set_type(soa_rr, LDNS_RR_TYPE_SOA); ldns_rr_set_class(soa_rr, rr_class); ldns_rr_set_question(soa_rr, false); if (ldns_str2rdf_dname(&mname_rdf, ".") != LDNS_STATUS_OK) { ldns_rr_free(soa_rr); return NULL; } else { ldns_rr_push_rdf(soa_rr, mname_rdf); } if (ldns_str2rdf_dname(&rname_rdf, ".") != LDNS_STATUS_OK) { ldns_rr_free(soa_rr); return NULL; } else { ldns_rr_push_rdf(soa_rr, rname_rdf); } serial_rdf = ldns_native2rdf_int32(LDNS_RDF_TYPE_INT32, 0); if (!serial_rdf) { ldns_rr_free(soa_rr); return NULL; } else { ldns_rr_push_rdf(soa_rr, serial_rdf); } refresh_rdf = ldns_native2rdf_int32(LDNS_RDF_TYPE_INT32, 0); if (!refresh_rdf) { ldns_rr_free(soa_rr); return NULL; } else { ldns_rr_push_rdf(soa_rr, refresh_rdf); } retry_rdf = ldns_native2rdf_int32(LDNS_RDF_TYPE_INT32, 0); if (!retry_rdf) { ldns_rr_free(soa_rr); return NULL; } else { ldns_rr_push_rdf(soa_rr, retry_rdf); } expire_rdf = ldns_native2rdf_int32(LDNS_RDF_TYPE_INT32, 0); if (!expire_rdf) { ldns_rr_free(soa_rr); return NULL; } else { ldns_rr_push_rdf(soa_rr, expire_rdf); } minimum_rdf = ldns_native2rdf_int32(LDNS_RDF_TYPE_INT32, 0); if (!minimum_rdf) { ldns_rr_free(soa_rr); return NULL; } else { ldns_rr_push_rdf(soa_rr, minimum_rdf); } return soa_rr; } static ldns_status ldns_pkt_query_new_frm_str_internal(ldns_pkt **p, const char *name, ldns_rr_type rr_type, ldns_rr_class rr_class, uint16_t flags, ldns_rr* authsoa_rr) { ldns_pkt *packet; ldns_rr *question_rr; ldns_rdf *name_rdf; packet = ldns_pkt_new(); if (!packet) { return LDNS_STATUS_MEM_ERR; } if (!ldns_pkt_set_flags(packet, flags)) { return LDNS_STATUS_ERR; } question_rr = ldns_rr_new(); if (!question_rr) { return LDNS_STATUS_MEM_ERR; } if (rr_type == 0) { rr_type = LDNS_RR_TYPE_A; } if (rr_class == 0) { rr_class = LDNS_RR_CLASS_IN; } if (ldns_str2rdf_dname(&name_rdf, name) == LDNS_STATUS_OK) { ldns_rr_set_owner(question_rr, name_rdf); ldns_rr_set_type(question_rr, rr_type); ldns_rr_set_class(question_rr, rr_class); ldns_rr_set_question(question_rr, true); ldns_pkt_push_rr(packet, LDNS_SECTION_QUESTION, question_rr); } else { ldns_rr_free(question_rr); ldns_pkt_free(packet); return LDNS_STATUS_ERR; } if (authsoa_rr) { ldns_pkt_push_rr(packet, LDNS_SECTION_AUTHORITY, authsoa_rr); } packet->_tsig_rr = NULL; ldns_pkt_set_answerfrom(packet, NULL); if (p) { *p = packet; return LDNS_STATUS_OK; } else { ldns_pkt_free(packet); return LDNS_STATUS_NULL; } } ldns_status ldns_pkt_query_new_frm_str(ldns_pkt **p, const char *name, ldns_rr_type rr_type, ldns_rr_class rr_class, uint16_t flags) { return ldns_pkt_query_new_frm_str_internal(p, name, rr_type, rr_class, flags, NULL); } ldns_status ldns_pkt_ixfr_request_new_frm_str(ldns_pkt **p, const char *name, ldns_rr_class rr_class, uint16_t flags, ldns_rr *soa) { ldns_rr* authsoa_rr = soa; if (!authsoa_rr) { ldns_rdf *name_rdf; if (ldns_str2rdf_dname(&name_rdf, name) == LDNS_STATUS_OK) { authsoa_rr = ldns_pkt_authsoa(name_rdf, rr_class); } ldns_rdf_free(name_rdf); } return ldns_pkt_query_new_frm_str_internal(p, name, LDNS_RR_TYPE_IXFR, rr_class, flags, authsoa_rr); } static ldns_pkt * ldns_pkt_query_new_internal(ldns_rdf *rr_name, ldns_rr_type rr_type, ldns_rr_class rr_class, uint16_t flags, ldns_rr* authsoa_rr) { ldns_pkt *packet; ldns_rr *question_rr; packet = ldns_pkt_new(); if (!packet) { return NULL; } if (!ldns_pkt_set_flags(packet, flags)) { return NULL; } question_rr = ldns_rr_new(); if (!question_rr) { ldns_pkt_free(packet); return NULL; } if (rr_type == 0) { rr_type = LDNS_RR_TYPE_A; } if (rr_class == 0) { rr_class = LDNS_RR_CLASS_IN; } ldns_rr_set_owner(question_rr, rr_name); ldns_rr_set_type(question_rr, rr_type); ldns_rr_set_class(question_rr, rr_class); ldns_rr_set_question(question_rr, true); ldns_pkt_push_rr(packet, LDNS_SECTION_QUESTION, question_rr); if (authsoa_rr) { ldns_pkt_push_rr(packet, LDNS_SECTION_AUTHORITY, authsoa_rr); } packet->_tsig_rr = NULL; return packet; } ldns_pkt * ldns_pkt_query_new(ldns_rdf *rr_name, ldns_rr_type rr_type, ldns_rr_class rr_class, uint16_t flags) { return ldns_pkt_query_new_internal(rr_name, rr_type, rr_class, flags, NULL); } ldns_pkt * ldns_pkt_ixfr_request_new(ldns_rdf *rr_name, ldns_rr_class rr_class, uint16_t flags, ldns_rr* soa) { ldns_rr* authsoa_rr = soa; if (!authsoa_rr) { authsoa_rr = ldns_pkt_authsoa(rr_name, rr_class); } return ldns_pkt_query_new_internal(rr_name, LDNS_RR_TYPE_IXFR, rr_class, flags, authsoa_rr); } ldns_pkt_type ldns_pkt_reply_type(ldns_pkt *p) { ldns_rr_list *tmp; if (!p) { return LDNS_PACKET_UNKNOWN; } if (ldns_pkt_get_rcode(p) == LDNS_RCODE_NXDOMAIN) { return LDNS_PACKET_NXDOMAIN; } if (ldns_pkt_ancount(p) == 0 && ldns_pkt_arcount(p) == 0 && ldns_pkt_nscount(p) == 1) { /* check for SOA */ tmp = ldns_pkt_rr_list_by_type(p, LDNS_RR_TYPE_SOA, LDNS_SECTION_AUTHORITY); if (tmp) { ldns_rr_list_deep_free(tmp); return LDNS_PACKET_NODATA; } else { /* I have no idea ... */ } } if (ldns_pkt_ancount(p) == 0 && ldns_pkt_nscount(p) > 0) { tmp = ldns_pkt_rr_list_by_type(p, LDNS_RR_TYPE_NS, LDNS_SECTION_AUTHORITY); if (tmp) { /* there are nameservers here */ ldns_rr_list_deep_free(tmp); return LDNS_PACKET_REFERRAL; } else { /* I have no idea */ } ldns_rr_list_deep_free(tmp); } /* if we cannot determine the packet type, we say it's an * answer... */ return LDNS_PACKET_ANSWER; } ldns_pkt * ldns_pkt_clone(ldns_pkt *pkt) { ldns_pkt *new_pkt; if (!pkt) { return NULL; } new_pkt = ldns_pkt_new(); ldns_pkt_set_id(new_pkt, ldns_pkt_id(pkt)); ldns_pkt_set_qr(new_pkt, ldns_pkt_qr(pkt)); ldns_pkt_set_aa(new_pkt, ldns_pkt_aa(pkt)); ldns_pkt_set_tc(new_pkt, ldns_pkt_tc(pkt)); ldns_pkt_set_rd(new_pkt, ldns_pkt_rd(pkt)); ldns_pkt_set_cd(new_pkt, ldns_pkt_cd(pkt)); ldns_pkt_set_ra(new_pkt, ldns_pkt_ra(pkt)); ldns_pkt_set_ad(new_pkt, ldns_pkt_ad(pkt)); ldns_pkt_set_opcode(new_pkt, ldns_pkt_get_opcode(pkt)); ldns_pkt_set_rcode(new_pkt, ldns_pkt_get_rcode(pkt)); ldns_pkt_set_qdcount(new_pkt, ldns_pkt_qdcount(pkt)); ldns_pkt_set_ancount(new_pkt, ldns_pkt_ancount(pkt)); ldns_pkt_set_nscount(new_pkt, ldns_pkt_nscount(pkt)); ldns_pkt_set_arcount(new_pkt, ldns_pkt_arcount(pkt)); if (ldns_pkt_answerfrom(pkt)) ldns_pkt_set_answerfrom(new_pkt, ldns_rdf_clone(ldns_pkt_answerfrom(pkt))); ldns_pkt_set_querytime(new_pkt, ldns_pkt_querytime(pkt)); ldns_pkt_set_size(new_pkt, ldns_pkt_size(pkt)); ldns_pkt_set_tsig(new_pkt, ldns_rr_clone(ldns_pkt_tsig(pkt))); ldns_pkt_set_edns_udp_size(new_pkt, ldns_pkt_edns_udp_size(pkt)); ldns_pkt_set_edns_extended_rcode(new_pkt, ldns_pkt_edns_extended_rcode(pkt)); ldns_pkt_set_edns_version(new_pkt, ldns_pkt_edns_version(pkt)); ldns_pkt_set_edns_z(new_pkt, ldns_pkt_edns_z(pkt)); if(ldns_pkt_edns_data(pkt)) ldns_pkt_set_edns_data(new_pkt, ldns_rdf_clone(ldns_pkt_edns_data(pkt))); ldns_pkt_set_edns_do(new_pkt, ldns_pkt_edns_do(pkt)); ldns_rr_list_deep_free(new_pkt->_question); ldns_rr_list_deep_free(new_pkt->_answer); ldns_rr_list_deep_free(new_pkt->_authority); ldns_rr_list_deep_free(new_pkt->_additional); new_pkt->_question = ldns_rr_list_clone(ldns_pkt_question(pkt)); new_pkt->_answer = ldns_rr_list_clone(ldns_pkt_answer(pkt)); new_pkt->_authority = ldns_rr_list_clone(ldns_pkt_authority(pkt)); new_pkt->_additional = ldns_rr_list_clone(ldns_pkt_additional(pkt)); return new_pkt; } ldns-1.6.17/Makefile.in0000664000175100017510000022751412264060151014173 0ustar willemwillem# Standard installation pathnames # See the file LICENSE for the license SHELL = @SHELL@ VERSION = @PACKAGE_VERSION@ version_info = @VERSION_INFO@ srcdir = @srcdir@ prefix = @prefix@ exec_prefix = @exec_prefix@ bindir = @bindir@ mandir = @mandir@ datarootdir = @datarootdir@ datadir = @datadir@ libdir = @libdir@ includedir = @includedir@ doxygen = @doxygen@ pywrapdir = $(srcdir)/contrib/python pyldnsxwrapdir = $(srcdir)/contrib/ldnsx p5_dns_ldns_dir = $(srcdir)/contrib/DNS-LDNS PERL = @PERL@ swig = @swig@ swigpy_flags = -python @SWIGPY3@ python_site = @PYTHON_SITE_PKG@ pyldns_inst = @PYLDNSINST@ pyldns_uninst = @PYLDNSUNINST@ pyldnsx_inst = @PYLDNSXINST@ pyldnsx_uninst = @PYLDNSXUNINST@ libtool = @libtool@ CONFIG_FILES = @CONFIG_FILES@ # override $U variable which is used by autotools for deansification (for # K&R C compilers), but causes problems if $U is defined in the env). U= CC = @CC@ CFLAGS = @CFLAGS@ CPPFLAGS = -I. -I$(srcdir) @CPPFLAGS@ @DEFS@ LDFLAGS = @LDFLAGS@ LIBS = @LIBS@ LIBOBJDIR = compat/ LIBOBJS = @LIBOBJS@ PYTHON_CPPFLAGS = @PYTHON_CPPFLAGS@ PYTHON_LDFLAGS = @PYTHON_LDFLAGS@ PYTHON_X_CFLAGS = @PYTHON_X_CFLAGS@ LIBSSL_CPPFLAGS = @LIBSSL_CPPFLAGS@ LIBSSL_LDFLAGS = @LIBSSL_LDFLAGS@ LIBSSL_LIBS = @LIBSSL_LIBS@ LIBSSL_SSL_LIBS = @LIBSSL_SSL_LIBS@ LIBPCAP_LIBS = @LIBPCAP_LIBS@ RUNTIME_PATH = @RUNTIME_PATH@ LIBTOOL = $(libtool) --tag=CC --quiet LINT = splint LINTFLAGS = +quiet -weak -warnposix -unrecog -Din_addr_t=uint32_t -Du_int=unsigned -Du_char=uint8_t -preproc -Drlimit=rlimit64 -D__gnuc_va_list=va_list # Extra flags from configure LINTFLAGS += @LINTFLAGS@ LINTFLAGS += "-DBN_ULONG=unsigned long" -Dkrb5_int32=int "-Dkrb5_ui_4=unsigned int" -DPQ_64BIT=uint64_t -DRC4_INT=unsigned -fixedformalarray -D"ENGINE=unsigned" -D"RSA=unsigned" -D"DSA=unsigned" -D"EVP_PKEY=unsigned" -D"EVP_MD=unsigned" -D"SSL=unsigned" -D"SSL_CTX=unsigned" -D"X509=unsigned" -D"RC4_KEY=unsigned" -D"EVP_MD_CTX=unsigned" -D"EC_KEY=unsigned" -D"EC_POINT=unsigned" -D"EC_GROUP=unsigned" -D"EVP_PKEY_ASN1_METHOD=struct evp_pkey_asn1_method_st" -D"EVP_PKEY_CTX=struct evp_pkey_ctx_st" # compat with OpenBSD LINTFLAGS += "-Dsigset_t=long" # FreeBSD8 LINTFLAGS += "-D__uint16_t=uint16_t" -D"__pure2=" -D"__wchar_t=wchar_t" -D"__packed=" -D"__aligned(x)=" # Ubuntu oneiric" LINTFLAGS += -D"__BEGIN_DECLS=" -D"__ssize_t=ssize_t" -D"__intptr_t=intptr_t" -D"__nonnull(x)=" -D"__THROW=" -D"__wur=" -D"__off_t=unsigned" -D"__off64_t=unsigned" -D"__useconds_t=unsigned" -D"__uid_t=unsigned" -D"__gid_t=unsigned" -D"__attribute_deprecated__=" -D"__pid_t=unsigned" -D"__restrict=" -D"__END_DECLS=" -D"__BEGIN_NAMESPACE_STD=" -D"__END_NAMESPACE_STD=" -D"__BEGIN_NAMESPACE_C99=" -D"__END_NAMESPACE_C99=" -D"__socklen_t=unsigned" -D"sa_family_t=unsigned " -D"__mode_t=unsigned" -D"u_int16_t=uint16_t" -D"u_int32_t=uint32_t" -D"u_int8_t=uint8_t" -D"u_short=unsigned short" -D"__u16=uint16_t" -D"__u32=uint32_t" -D"__u64=uint64_t" # FreeBSD 9 LINTFLAGS += -D"_RuneLocale=int" DEPFLAG = @DEPFLAG@ INSTALL = $(srcdir)/install-sh LIBLOBJS = $(LIBOBJS:.o=.lo) LDNS_LOBJS = buffer.lo dane.lo dname.lo dnssec.lo dnssec_sign.lo dnssec_verify.lo dnssec_zone.lo duration.lo error.lo higher.lo host2str.lo host2wire.lo keys.lo net.lo packet.lo parse.lo radix.lo rbtree.lo rdata.lo resolver.lo rr.lo rr_functions.lo sha1.lo sha2.lo str2host.lo tsig.lo update.lo util.lo wire2host.lo zone.lo LDNS_LOBJS_EX = ^linktest\.c$$ LDNS_ALL_LOBJS = $(LDNS_LOBJS) $(LIBLOBJS) LIB = libldns.la LDNS_HEADERS = buffer.h dane.h dname.h dnssec.h dnssec_sign.h dnssec_verify.h dnssec_zone.h duration.h error.h higher.h host2str.h host2wire.h keys.h ldns.h packet.h parse.h radix.h rbtree.h rdata.h resolver.h rr_functions.h rr.h sha1.h sha2.h str2host.h tsig.h update.h wire2host.h zone.h LDNS_HEADERS_EX = ^config\.h|common\.h|util\.h|net\.h$$ LDNS_HEADERS_GEN= common.h util.h net.h PYLDNS_I_FILES = $(pywrapdir)/file_py3.i $(pywrapdir)/ldns_buffer.i $(pywrapdir)/ldns_dname.i $(pywrapdir)/ldns_dnssec.i $(pywrapdir)/ldns.i $(pywrapdir)/ldns_key.i $(pywrapdir)/ldns_packet.i $(pywrapdir)/ldns_rdf.i $(pywrapdir)/ldns_resolver.i $(pywrapdir)/ldns_rr.i $(pywrapdir)/ldns_zone.i DRILL_LOBJS = drill/chasetrace.lo drill/dnssec.lo drill/drill.lo drill/drill_util.lo drill/error.lo drill/root.lo drill/securetrace.lo drill/work.lo EXAMPLE_LOBJS = examples/ldns-chaos.lo examples/ldns-compare-zones.lo examples/ldns-dane.lo examples/ldnsd.lo examples/ldns-dpa.lo examples/ldns-gen-zone.lo examples/ldns-key2ds.lo examples/ldns-keyfetcher.lo examples/ldns-keygen.lo examples/ldns-mx.lo examples/ldns-notify.lo examples/ldns-nsec3-hash.lo examples/ldns-read-zone.lo examples/ldns-resolver.lo examples/ldns-revoke.lo examples/ldns-rrsig.lo examples/ldns-signzone.lo examples/ldns-test-edns.lo examples/ldns-testns.lo examples/ldns-testpkts.lo examples/ldns-update.lo examples/ldns-verify-zone.lo examples/ldns-version.lo examples/ldns-walk.lo examples/ldns-zcat.lo examples/ldns-zsplit.lo EXAMPLE_PROGS = examples/ldns-chaos examples/ldns-compare-zones examples/ldnsd examples/ldns-gen-zone examples/ldns-key2ds examples/ldns-keyfetcher examples/ldns-keygen examples/ldns-mx examples/ldns-notify examples/ldns-read-zone examples/ldns-resolver examples/ldns-rrsig examples/ldns-test-edns examples/ldns-update examples/ldns-version examples/ldns-walk examples/ldns-zcat examples/ldns-zsplit EX_PROGS_BASENM = ldns-chaos ldns-compare-zones ldns-dane ldnsd ldns-dpa ldns-gen-zone ldns-key2ds ldns-keyfetcher ldns-keygen ldns-mx ldns-notify ldns-nsec3-hash ldns-read-zone ldns-resolver ldns-revoke ldns-rrsig ldns-signzone ldns-test-edns ldns-testns ldns-testpkts ldns-update ldns-verify-zone ldns-version ldns-walk ldns-zcat ldns-zsplit EXAMPLE_PROGS_EX= ^examples/ldns-testpkts\.c|examples/ldns-testns\.c|examples/ldns-dane\.c|examples/ldns-dpa\.c|examples/ldns-nsec3-hash\.c|examples/ldns-revoke\.c|examples/ldns-signzone\.c|examples/ldns-verify-zone\.c$$ TESTNS = examples/ldns-testns TESTNS_LOBJS = examples/ldns-testns.lo examples/ldns-testpkts.lo LDNS_DPA = examples/ldns-dpa LDNS_DPA_LOBJS = examples/ldns-dpa.lo LDNS_DANE = examples/ldns-dane LDNS_DANE_LOBJS = examples/ldns-dane.lo EX_SSL_PROGS = examples/ldns-nsec3-hash examples/ldns-revoke examples/ldns-signzone examples/ldns-verify-zone EX_SSL_LOBJS = examples/ldns-nsec3-hash.lo examples/ldns-revoke.lo examples/ldns-signzone.lo examples/ldns-verify-zone.lo COMPILE = $(CC) $(CPPFLAGS) $(CFLAGS) COMP_LIB = $(LIBTOOL) --mode=compile $(CC) $(CPPFLAGS) $(CFLAGS) LINK = $(CC) $(CFLAGS) $(LDFLAGS) $(LIBS) LINK_LIB = $(LIBTOOL) --mode=link $(CC) $(CFLAGS) $(LDFLAGS) $(LIBS) -version-number $(version_info) -no-undefined LINK_EXE = $(LIBTOOL) --mode=link $(CC) $(CFLAGS) $(LDFLAGS) $(LIBSSL_LDFLAGS) .PHONY: clean realclean docclean manpages doc lint all lib pyldns test .PHONY: install uninstall install-doc uninstall-doc uninstall-pyldns .PHONY: install-h uninstall-h install-lib uninstall-lib install-pyldns all: setup-builddir lib linktest manpages @P5_DNS_LDNS@ @PYLDNS@ @DRILL@ @EXAMPLES@ .SUFFIXES: .c .o .a .lo .h .i .c.lo: $(COMP_LIB) $(LIBSSL_CPPFLAGS) -c $< -o $@ $(LDNS_LOBJS) $(LIBLOBJS) $(DRILL_LOBJS) $(EXAMPLE_LOBJS): $(COMP_LIB) $(LIBSSL_CPPFLAGS) -c $(srcdir)/$(@:.lo=.c) -o $@ setup-builddir: @if test ! -d compat ; then mkdir compat ; fi @if test ! -d drill ; then mkdir drill ; fi @if test ! -d examples ; then mkdir examples ; fi @if test ! -h config.h ; then ln -s ldns/config.h . ; fi @if test ! -h lib ; then ln -s .libs lib ; fi ; @if test ! -d include ; then $(INSTALL) -d include; fi @if test ! -h include/ldns ; then ln -s ../ldns include/ldns || echo "include/ldns exists"; fi putdown-builddir: rm -f include/ldns lib config.h test ! -d include || rmdir include || : if test -d examples -a ! -f examples/README; then rmdir examples || : ; fi if test -d drill -a ! -f drill/README ; then rmdir drill || : ; fi if test -d compat -a ! -f compat/malloc.c; then rmdir compat || : ; fi drill: no-drill-config-h drill/drill no-drill-config-h: @if test -e $(srcdir)/drill/config.h -o -e drill/config.h ; \ then echo "A config.h was detected in the drill subdirectory." ; \ echo "This does not work when building drill from here." ; \ echo "Either remove the config.h from the subdirectory" ; \ echo "or build drill there." ; \ exit -1 ; \ fi drill/drill: $(DRILL_LOBJS) $(LIB) $(LINK_EXE) $(DRILL_LOBJS) $(LIBS) $(LIBSSL_LIBS) -lldns -o drill/drill install-drill: drill/drill $(INSTALL) -m 755 -d $(DESTDIR)$(bindir) $(INSTALL) -m 755 -d $(DESTDIR)$(mandir) $(INSTALL) -m 755 -d $(DESTDIR)$(mandir)/man1 $(LIBTOOL) --mode=install cp drill/drill $(DESTDIR)$(bindir) $(INSTALL) -m 644 drill/drill.1 $(DESTDIR)$(mandir)/man1/drill.1 uninstall-drill: rm -f $(DESTDIR)$(bindir)/drill $(DESTDIR)$(mandir)/man1/drill.1 test ! -d $(DESTDIR)$(mandir) || rmdir -p $(DESTDIR)$(mandir)/man1 || :; test ! -d $(DESTDIR)$(bindir) || rmdir -p $(DESTDIR)$(bindir) || : ; clean-drill: $(LIBTOOL) --mode clean rm -f $(DRILL_LOBJS) drill/drill examples: no-examples-config-h $(EXAMPLE_PROGS) $(TESTNS) $(LDNS_DPA) $(LDNS_DANE) $(EX_SSL_PROGS) no-examples-config-h: @if test -e $(srcdir)/examples/config.h -o -e examples/config.h ; \ then echo "A config.h was detected in the examples subdirectory." ; \ echo "This does not work when building examples from here." ; \ echo "Either remove the config.h from the subdirectory" ; \ echo "or build examples there." ; \ exit -1 ; \ fi $(EXAMPLE_PROGS): $(LINK_EXE) $@.lo $(LIBS) -lldns -o $@ $(TESTNS): $(LINK_EXE) $(TESTNS_LOBJS) $(LIBS) -lldns -o $(TESTNS) $(LDNS_DPA): $(LINK_EXE) $(LDNS_DPA_LOBJS) $(LIBS) $(LIBPCAP_LIBS) -lldns \ -o $(LDNS_DPA) $(LDNS_DANE): $(LINK_EXE) $(LDNS_DANE_LOBJS) $(LIBS) $(LIBSSL_SSL_LIBS) -lldns \ -o $(LDNS_DANE) $(EX_SSL_PROGS): $(LINK_EXE) $@.lo $(LIBS) $(LIBSSL_LIBS) -lldns -o $@ install-examples: $(EXAMPLE_PROGS) $(TESTNS) $(LDNS_DPA) $(LDNS_DANE) $(EX_SSL_PROGS) $(INSTALL) -m 755 -d $(DESTDIR)$(bindir) $(INSTALL) -m 755 -d $(DESTDIR)$(mandir) $(INSTALL) -m 755 -d $(DESTDIR)$(mandir)/man1 for p in $(EXAMPLE_PROGS) $(TESTNS) $(LDNS_DPA) $(LDNS_DANE) $(EX_SSL_PROGS) ; do \ $(LIBTOOL) --mode=install cp $$p $(DESTDIR)$(bindir) ; \ if test -f $$p.1 ; \ then $(INSTALL) -m 644 $$p.1 $(DESTDIR)$(mandir)/man1 ; \ else $(INSTALL) -m 644 $(srcdir)/$$p.1 $(DESTDIR)$(mandir)/man1 ; \ fi ; \ done uninstall-examples: for p in $(EX_PROGS_BASENM) ; do \ rm -f $(DESTDIR)$(bindir)/$$p $(DESTDIR)$(mandir)/man1/$$p.1 ;\ done test ! -d $(DESTDIR)$(mandir) || rmdir -p $(DESTDIR)$(mandir)/man1 || :; test ! -d $(DESTDIR)$(bindir) || rmdir -p $(DESTDIR)$(bindir) || : ; clean-examples: $(LIBTOOL) --mode clean rm -f $(EXAMPLE_PROGS) $(LIBTOOL) --mode clean rm -f $(TESTNS) $(LDNS_DPA) $(LDNS_DANE) $(EX_SSL_PROGS) $(LIBTOOL) --mode clean rm -f $(EXAMPLE_LOBJS) linktest: $(srcdir)/linktest.c libldns.la $(COMP_LIB) $(LIBSSL_CPPFLAGS) -c $(srcdir)/linktest.c -o linktest.lo $(LINK_EXE) linktest.lo $(LIBS) $(LIBSSL_LIBS) -lldns -o linktest lib: libldns.la lib-export-all: libldns.la-export-all libldns.la: $(LDNS_ALL_LOBJS) $(LINK_LIB) $(LIBSSL_LDFLAGS) $(LIBSSL_LIBS) -export-symbols-regex '^(ldns_|b32_[pn]to[pn]|mktime_from_utc|qsort_rr_compare_nsec3)' -o libldns.la $(LDNS_ALL_LOBJS) -rpath $(libdir) $(RUNTIME_PATH) libldns.la-export-all: $(LDNS_ALL_LOBJS) $(LINK_LIB) -o libldns.la $(LDNS_ALL_LOBJS) -rpath $(libdir) $(RUNTIME_PATH) mancheck: sh -c 'find . -name \*.\[13\] -exec troff -z {} \;' 2>&1 | sed "s/^\.\///" | sed "s/\(:[0\-9]\+:\)/\1 warning:/g" doxygen: manpages if test ! -e doc/header.html ; then \ $(INSTALL) -c -m 644 $(srcdir)/doc/header.html doc/ ; \ fi ; $(doxygen) $(srcdir)/libdns.doxygen doc: manpages $(doxygen) @$(INSTALL) -d doc manpages: $(srcdir)/doc/function_manpages @$(INSTALL) -d doc @cat $(srcdir)/ldns/*.h \ | $(srcdir)/doc/doxyparse.pl \ -m $(srcdir)/doc/function_manpages 2>&1 \ | grep -v ^doxygen | grep -v ^cat > doc/ldns_manpages pyldns: _ldns.la $(pywrapdir)/ldns_wrapper.c: $(PYLDNS_I_FILES) ldns/config.h $(swig) $(swigpy_flags) -o $@ $(CPPFLAGS) $(PYTHON_CPPFLAGS) $(pywrapdir)/ldns.i ldns_wrapper.lo: $(pywrapdir)/ldns_wrapper.c ldns/config.h $(COMP_LIB) -I./include/ldns $(PYTHON_CPPFLAGS) $(PYTHON_X_CFLAGS) -c $(pywrapdir)/ldns_wrapper.c -o $@ _ldns.la: ldns_wrapper.lo libldns.la $(LIBTOOL) --tag=CC --mode=link $(CC) $(CFLAGS) $(PYTHON_CFLAGS) $(LDFLAGS) $(PYTHON_LDFLAGS) -module -version-number $(version_info) -no-undefined -o $@ ldns_wrapper.lo -rpath $(python_site) -L. -L.libs -lldns $(LIBS) $(p5_dns_ldns_dir)/Makefile: $(p5_dns_ldns_dir)/Makefile.PL BUILDDIR=`pwd`; cd $(p5_dns_ldns_dir); $(PERL) Makefile.PL PREFIX="$(prefix)" LIBS="-L$$BUILDDIR/.libs -lldns" INC="-I$$BUILDDIR" $(p5_dns_ldns_dir)/blib/arch/auto/DNS/LDNS/LDNS.so: $(p5_dns_ldns_dir)/Makefile cd $(p5_dns_ldns_dir); $(MAKE) p5-dns-ldns: $(p5_dns_ldns_dir)/blib/arch/auto/DNS/LDNS/LDNS.so install-p5-dns-ldns: $(p5_dns_ldns_dir)/Makefile cd $(p5_dns_ldns_dir); $(MAKE) install uninstall-p5-dns-ldns: $(p5_dns_ldns_dir)/Makefile cd $(p5_dns_ldns_dir); $(MAKE) uninstall clean-p5-dns-ldns: $(p5_dns_ldns_dir)/Makefile cd $(p5_dns_ldns_dir); $(MAKE) clean test-p5-dns-ldns: $(p5_dns_ldns_dir)/Makefile cd $(p5_dns_ldns_dir); $(MAKE) test install: install-h install-lib @INSTALL_CONFIG@ install-manpages $(pyldns_inst) $(pyldnsx_inst) @INSTALL_P5_DNS_LDNS@ @INSTALL_DRILL@ @INSTALL_EXAMPLES@ uninstall: uninstall-manpages @UNINSTALL_CONFIG@ uninstall-h uninstall-lib $(pyldns_uninst) $(pyldnsx_uninst) @UNINSTALL_P5_DNS_LDNS@ @UNINSTALL_DRILL@ @UNINSTALL_EXAMPLES@ destclean: uninstall install-config: $(INSTALL) -d $(DESTDIR)$(bindir) $(INSTALL) -c -m 755 packaging/ldns-config $(DESTDIR)$(bindir) uninstall-config: rm -f $(DESTDIR)$(bindir)/ldns-config test ! -d $(DESTDIR)$(bindir) || rmdir -p $(DESTDIR)$(bindir) || echo "ok, dir already gone" install-config-manpage: ${INSTALL} -d $(DESTDIR)$(mandir)/man1 ${INSTALL} -c -m 444 $(srcdir)/packaging/ldns-config.1 $(DESTDIR)$(mandir)/man1/ uninstall-config-manpage: rm -f $(DESTDIR)$(mandir)/man1/ldns-config.1 test ! -d $(DESTDIR)$(mandir)/man1 || rmdir -p $(DESTDIR)$(mandir)/man1 || echo "ok, dir already gone" install-manpages: manpages @INSTALL_CONFIG_MANPAGE@ ${INSTALL} -d $(DESTDIR)$(mandir)/man3 for f in doc/man/man3/*; do \ ${INSTALL} -c -m 444 $$f $(DESTDIR)$(mandir)/man3/; \ done uninstall-manpages: @UNINSTALL_CONFIG_MANPAGE@ for m in `cat $(srcdir)/ldns/*.h | perl $(srcdir)/doc/doxyparse.pl -m $(srcdir)/doc/function_manpages 2>&1 | grep -v ^doxygen | grep -v ^cat` ; do \ rm -f $(DESTDIR)$(mandir)/man3/$$m.3 ; done test ! -d $(DESTDIR)$(mandir)/man3 || rmdir -p $(DESTDIR)$(mandir)/man3 || echo "ok, dir already gone" install-h: lib $(INSTALL) -m 755 -d $(DESTDIR)$(includedir)/ldns for i in $(LDNS_HEADERS); do \ $(INSTALL) -c -m 644 $(srcdir)/ldns/$$i $(DESTDIR)$(includedir)/ldns/; done for i in $(LDNS_HEADERS_GEN); do \ $(INSTALL) -c -m 644 ldns/$$i $(DESTDIR)$(includedir)/ldns/; done uninstall-h: for i in $(LDNS_HEADERS) $(LDNS_HEADERS_GEN); do \ rm -f $(DESTDIR)$(includedir)/ldns/$$i; done test ! -d $(DESTDIR)$(includedir)/ldns || rmdir -p $(DESTDIR)$(includedir)/ldns || echo "ok, dir already gone" exit 0 install-lib: lib $(INSTALL) -m 755 -d $(DESTDIR)$(libdir) $(LIBTOOL) --mode=install cp libldns.la $(DESTDIR)$(libdir) $(LIBTOOL) --mode=finish $(DESTDIR)$(libdir) uninstall-lib: $(LIBTOOL) --mode=uninstall rm -f $(DESTDIR)$(libdir)/libldns.la test ! -d $(DESTDIR)$(libdir) || rmdir -p $(DESTDIR)$(libdir) || echo "ok, dir already gone" install-pyldns: @PYLDNS@ $(INSTALL) -m 755 -d $(DESTDIR)$(python_site)/ldns $(INSTALL) -c -m 644 $(pywrapdir)/ldns.py $(DESTDIR)$(python_site)/ldns.py $(LIBTOOL) --mode=install cp _ldns.la $(DESTDIR)$(python_site) $(LIBTOOL) --mode=finish $(DESTDIR)$(python_site) uninstall-pyldns: rm -f $(DESTDIR)$(python_site)/ldns/* test ! -d $(DESTDIR)$(python_site)/ldns || rmdir $(DESTDIR)$(python_site)/ldns || echo "ok, dir already gone" install-pyldnsx: $(INSTALL) -c -m 644 $(pyldnsxwrapdir)/ldnsx.py $(DESTDIR)$(python_site)/ldnsx.py uninstall-pyldnsx: rm -f $(DESTDIR)$(python_site)/ldnsx.py clean-manpages: for m in `cat $(srcdir)/ldns/*.h | $(srcdir)/doc/doxyparse.pl -m $(srcdir)/doc/function_manpages 2>&1 | grep -v ^doxygen | grep -v ^cat` ; do\ rm -f doc/man/man3/$${m}.3 ; done rm -f doc/ldns_manpages test ! -d doc/man/man3 || rmdir -p doc/man/man3 || : clean-lib: $(LIBTOOL) --mode clean rm -f $(LDNS_LOBJS) $(LIBLOBJS) $(LIBTOOL) --mode clean rm -f linktest libldns.la $(LIBTOOL) --mode clean rm -f $(pywrapdir)/ldns_wrapper.c $(LIBTOOL) --mode clean rm -f $(pywrapdir)/ldns.py clean: @CLEAN_DRILL@ @CLEAN_EXAMPLES@ @CLEAN_P5_DNS_LDNS@ clean-manpages clean-lib putdown-builddir realclean: clean docclean rm -f config.status rm -f config.log rm -f $(CONFIG_FILES) rm -f ldns/config.h if test -d packaging -a ! -f packaging/ldns-config.in ; then \ rmdir packaging || : ; fi rm -f libtool if test -d ldns ; then \ echo "is builddir srcdir" > ldns/YES ; \ if test -f $(srcdir)/ldns/YES ; then \ echo Leaving headers files because srcdir == builddir;\ rm -f ldns/YES; \ else \ echo Removing header files in builddir;\ for f in `(cd $(srcdir); echo ldns/*.h)`; do \ rm -f $$f ; done ; \ rm -f ldns/YES; \ test ! -d ldns || rmdir ldns || : ; \ fi ;\ fi docclean: rm -rf doc/html/ rm -rf doc/man/ rm -rf doc/latex/ rm -f doc/*.txt rm -f doc/*.tex rm -f doc/ldns_manpages distclean: realclean rm -fr autom4te.cache rm -f config.guess config.sub configure ltmain.sh ldns/config.h.in ## No need for changes here lint: lint-lib @LINT_DRILL@ @LINT_EXAMPLES@ lint-lib: for i in $(srcdir)/*.c; do \ $(LINT) $(LINTFLAGS) -I. -I$(srcdir) $(srcdir)/$$i ; \ if test $$? -ne 0 ; then exit 1 ; fi ; \ done lint-drill: for i in $(srcdir)/drill/*.c; do \ $(LINT) $(LINTFLAGS) -I. -I$(srcdir) $(srcdir)/$$i ; \ if test $$? -ne 0 ; then exit 1 ; fi ; \ done lint-examples: for i in $(srcdir)/examples/*.c; do \ $(LINT) $(LINTFLAGS) -I. -I$(srcdir) $(srcdir)/$$i ; \ if test $$? -ne 0 ; then exit 1 ; fi ; \ done tags: $(srcdir)/*.c ldns/*.[ch] ctags -f $(srcdir)/tags $(srcdir)/*.[ch] ldns/*.[ch] allclean: test-clean clean test-clean: tpkg -b test clean test: @TEST_P5_DNS_LDNS@ if test -x "`which bash`"; then bash test/test_all.sh; else sh test/test_all.sh; fi # Recreate symbols file, only needed when API changes # make clean first (and after this make clean; make again) symbols: lib-export-all nm -g lib/libldns.so | cut -d " " -f 3 | grep ldns | sort > $(srcdir)/ldns_symbols.def TMP_FILE=temporary.tmp sources: for mf in $(srcdir)/Makefile.in Makefile ; do \ if test -e $$mf ; then \ cp $$mf $$mf.bak ;\ sed -e 's/^LDNS_LOBJS[ ]*=.*$$/LDNS_LOBJS = '"`(cd $(srcdir); ls -1 *.c | egrep -v '$(LDNS_LOBJS_EX)' | sed 's/\.c/\.lo/g' | tr '\n' ' ')`"'/g' \ -e 's/^LDNS_HEADERS[ ]*=.*$$/LDNS_HEADERS = '"`(cd $(srcdir)/ldns; ls -1 *.h | egrep -v '$(LDNS_HEADERS_EX)' | tr '\n' ' ')`"'/g' \ -e 's?^PYLDNS_I_FILES[ ]*=.*$$?PYLDNS_I_FILES = '"`(cd $(srcdir)/contrib; echo python/*.i | sed 's/python/\$$(pywrapdir)/g')`"'?g' \ -e 's?^DRILL_LOBJS[ ]*=.*$$?DRILL_LOBJS = '"`(cd $(srcdir); echo drill/*.c | sed 's/\.c/\.lo/g')`"'?g' \ -e 's?^EXAMPLE_LOBJS[ ]*=.*$$?EXAMPLE_LOBJS = '"`(cd $(srcdir); echo examples/*.c | sed 's/\.c/\.lo/g')`"'?g' \ -e 's?^EXAMPLE_PROGS[ ]*=.*$$?EXAMPLE_PROGS = '"`(cd $(srcdir); ls -1 examples/*.c | egrep -v '$(EXAMPLE_PROGS_EX)' | sed 's/\.c//g' | tr '\n' ' ')`"'?g' \ -e 's?^EX_PROGS_BASENM[ ]*=.*$$?EX_PROGS_BASENM = '"`(cd $(srcdir); ls -1 examples/*.c | sed -e 's/\.c//g' -e 's?examples/??g' | tr '\n' ' ')`"'?g' \ $$mf > $(TMP_FILE) ;\ mv $(TMP_FILE) $$mf ;\ fi;\ done # dependency generation DEPEND_TMP=depend1073.tmp DEPEND_TMP2=depend1074.tmp DEPEND_TARGET=Makefile DEPEND_TARGET2=$(srcdir)/Makefile.in # actions: generate deplines from gcc, # then, filter out home/xx, /usr/xx and /opt/xx lines (some cc already do this) # then, remove empty " \" lines # then, add srcdir before .c and .h in deps. # then, remove srcdir from the (generated) parser and lexer. # and mention the .lo depend: if test ! -e config.h ; then ln -s ldns/config.h . ; fi echo "" > $(DEPEND_TMP) for builddir in `pwd` ; do \ for subdir in . compat examples drill; do \ (cd $(srcdir) ; $(CC) $(DEPFLAG) $(CPPFLAGS) $(CFLAGS) -I$$builddir -I$$subdir $$subdir/*.c) | \ sed -e 's!'$$HOME'[^ ]* !!g' -e 's!'$$HOME'[^ ]*$$!!g' \ -e 's!/usr[^ ]* !!g' -e 's!/usr[^ ]*$$!!g' \ -e 's!/opt[^ ]* !!g' -e 's!/opt[^ ]*$$!!g' | \ sed -e '/^ \\$$/d' | \ sed -e 's? *\([^ ]*\.[ch]\)? $$(srcdir)/\1?g' | \ sed -e 's? *\([^ ]*\.inc\)? $$(srcdir)/\1?g' | \ sed -e 's?$$(srcdir)/ldns/config.h?ldns/config.h?g' \ -e 's?$$(srcdir)/config.h?ldns/config.h?g' \ -e 's?$$(srcdir)/ldns/common.h?ldns/common.h?g' \ -e 's?$$(srcdir)/ldns/util.h?ldns/util.h?g' \ -e 's?$$(srcdir)/ldns/net.h?ldns/net.h?g' \ -e 's!\(.*\)\.o[ :]*!'"$$subdir/"'\1.lo '"$$subdir/"'\1.o: !g' \ -e 's?^\.\/??g' -e 's? \.\/? ?g' \ >> $(DEPEND_TMP) ;\ done; \ done for p in $(EXAMPLE_PROGS) $(LDNS_DPA) $(LDNS_DANE) $(EX_SSL_PROGS); do \ echo "$$p: $$p.lo $$p.o \$$(LIB)" >> $(DEPEND_TMP) ; done echo "$(TESTNS): `for o in $(TESTNS_LOBJS) ; do \ echo -n "$$o $${o%lo}o " ; done` \$$(LIB)" \ >> $(DEPEND_TMP) cp $(DEPEND_TARGET) $(DEPEND_TMP2) head -`egrep -n "# Dependencies" $(DEPEND_TARGET) | tail -1 | sed -e 's/:.*$$//'` $(DEPEND_TMP2) > $(DEPEND_TARGET) cat $(DEPEND_TMP) >> $(DEPEND_TARGET) @if diff $(DEPEND_TARGET) $(DEPEND_TMP2); then echo " $(DEPEND_TARGET) unchanged"; else echo " Updated $(DEPEND_TARGET))"; fi @if test -f $(DEPEND_TARGET2); then \ cp $(DEPEND_TARGET2) $(DEPEND_TMP2); \ head -`egrep -n "# Dependencies" $(DEPEND_TARGET2) | tail -1 | sed -e 's/:.*$$//'` $(DEPEND_TMP2) > $(DEPEND_TARGET2); \ cat $(DEPEND_TMP) >> $(DEPEND_TARGET2); \ if diff $(DEPEND_TARGET2) $(DEPEND_TMP2); then echo " $(DEPEND_TARGET2) unchanged"; else echo " Updated $(DEPEND_TARGET2))"; fi; \ fi rm -f $(DEPEND_TMP) $(DEPEND_TMP2) # Dependencies buffer.lo buffer.o: $(srcdir)/buffer.c ldns/config.h $(srcdir)/ldns/ldns.h ldns/util.h ldns/common.h \ $(srcdir)/ldns/buffer.h $(srcdir)/ldns/error.h $(srcdir)/ldns/dane.h $(srcdir)/ldns/rdata.h $(srcdir)/ldns/rr.h \ $(srcdir)/ldns/dname.h $(srcdir)/ldns/dnssec.h $(srcdir)/ldns/packet.h $(srcdir)/ldns/keys.h $(srcdir)/ldns/zone.h \ $(srcdir)/ldns/resolver.h $(srcdir)/ldns/tsig.h $(srcdir)/ldns/dnssec_zone.h $(srcdir)/ldns/rbtree.h \ $(srcdir)/ldns/host2str.h $(srcdir)/ldns/dnssec_verify.h $(srcdir)/ldns/dnssec_sign.h $(srcdir)/ldns/duration.h \ $(srcdir)/ldns/higher.h $(srcdir)/ldns/host2wire.h ldns/net.h $(srcdir)/ldns/str2host.h $(srcdir)/ldns/update.h \ $(srcdir)/ldns/wire2host.h $(srcdir)/ldns/rr_functions.h $(srcdir)/ldns/parse.h $(srcdir)/ldns/radix.h \ $(srcdir)/ldns/sha1.h $(srcdir)/ldns/sha2.h dane.lo dane.o: $(srcdir)/dane.c ldns/config.h $(srcdir)/ldns/ldns.h ldns/util.h ldns/common.h \ $(srcdir)/ldns/buffer.h $(srcdir)/ldns/error.h $(srcdir)/ldns/dane.h $(srcdir)/ldns/rdata.h $(srcdir)/ldns/rr.h \ $(srcdir)/ldns/dname.h $(srcdir)/ldns/dnssec.h $(srcdir)/ldns/packet.h $(srcdir)/ldns/keys.h $(srcdir)/ldns/zone.h \ $(srcdir)/ldns/resolver.h $(srcdir)/ldns/tsig.h $(srcdir)/ldns/dnssec_zone.h $(srcdir)/ldns/rbtree.h \ $(srcdir)/ldns/host2str.h $(srcdir)/ldns/dnssec_verify.h $(srcdir)/ldns/dnssec_sign.h $(srcdir)/ldns/duration.h \ $(srcdir)/ldns/higher.h $(srcdir)/ldns/host2wire.h ldns/net.h $(srcdir)/ldns/str2host.h $(srcdir)/ldns/update.h \ $(srcdir)/ldns/wire2host.h $(srcdir)/ldns/rr_functions.h $(srcdir)/ldns/parse.h $(srcdir)/ldns/radix.h \ $(srcdir)/ldns/sha1.h $(srcdir)/ldns/sha2.h dname.lo dname.o: $(srcdir)/dname.c ldns/config.h $(srcdir)/ldns/ldns.h ldns/util.h ldns/common.h \ $(srcdir)/ldns/buffer.h $(srcdir)/ldns/error.h $(srcdir)/ldns/dane.h $(srcdir)/ldns/rdata.h $(srcdir)/ldns/rr.h \ $(srcdir)/ldns/dname.h $(srcdir)/ldns/dnssec.h $(srcdir)/ldns/packet.h $(srcdir)/ldns/keys.h $(srcdir)/ldns/zone.h \ $(srcdir)/ldns/resolver.h $(srcdir)/ldns/tsig.h $(srcdir)/ldns/dnssec_zone.h $(srcdir)/ldns/rbtree.h \ $(srcdir)/ldns/host2str.h $(srcdir)/ldns/dnssec_verify.h $(srcdir)/ldns/dnssec_sign.h $(srcdir)/ldns/duration.h \ $(srcdir)/ldns/higher.h $(srcdir)/ldns/host2wire.h ldns/net.h $(srcdir)/ldns/str2host.h $(srcdir)/ldns/update.h \ $(srcdir)/ldns/wire2host.h $(srcdir)/ldns/rr_functions.h $(srcdir)/ldns/parse.h $(srcdir)/ldns/radix.h \ $(srcdir)/ldns/sha1.h $(srcdir)/ldns/sha2.h dnssec.lo dnssec.o: $(srcdir)/dnssec.c ldns/config.h $(srcdir)/ldns/ldns.h ldns/util.h ldns/common.h \ $(srcdir)/ldns/buffer.h $(srcdir)/ldns/error.h $(srcdir)/ldns/dane.h $(srcdir)/ldns/rdata.h $(srcdir)/ldns/rr.h \ $(srcdir)/ldns/dname.h $(srcdir)/ldns/dnssec.h $(srcdir)/ldns/packet.h $(srcdir)/ldns/keys.h $(srcdir)/ldns/zone.h \ $(srcdir)/ldns/resolver.h $(srcdir)/ldns/tsig.h $(srcdir)/ldns/dnssec_zone.h $(srcdir)/ldns/rbtree.h \ $(srcdir)/ldns/host2str.h $(srcdir)/ldns/dnssec_verify.h $(srcdir)/ldns/dnssec_sign.h $(srcdir)/ldns/duration.h \ $(srcdir)/ldns/higher.h $(srcdir)/ldns/host2wire.h ldns/net.h $(srcdir)/ldns/str2host.h $(srcdir)/ldns/update.h \ $(srcdir)/ldns/wire2host.h $(srcdir)/ldns/rr_functions.h $(srcdir)/ldns/parse.h $(srcdir)/ldns/radix.h \ $(srcdir)/ldns/sha1.h $(srcdir)/ldns/sha2.h dnssec_sign.lo dnssec_sign.o: $(srcdir)/dnssec_sign.c ldns/config.h $(srcdir)/ldns/ldns.h ldns/util.h \ ldns/common.h $(srcdir)/ldns/buffer.h $(srcdir)/ldns/error.h $(srcdir)/ldns/dane.h $(srcdir)/ldns/rdata.h \ $(srcdir)/ldns/rr.h $(srcdir)/ldns/dname.h $(srcdir)/ldns/dnssec.h $(srcdir)/ldns/packet.h $(srcdir)/ldns/keys.h \ $(srcdir)/ldns/zone.h $(srcdir)/ldns/resolver.h $(srcdir)/ldns/tsig.h $(srcdir)/ldns/dnssec_zone.h $(srcdir)/ldns/rbtree.h \ $(srcdir)/ldns/host2str.h $(srcdir)/ldns/dnssec_verify.h $(srcdir)/ldns/dnssec_sign.h $(srcdir)/ldns/duration.h \ $(srcdir)/ldns/higher.h $(srcdir)/ldns/host2wire.h ldns/net.h $(srcdir)/ldns/str2host.h $(srcdir)/ldns/update.h \ $(srcdir)/ldns/wire2host.h $(srcdir)/ldns/rr_functions.h $(srcdir)/ldns/parse.h $(srcdir)/ldns/radix.h \ $(srcdir)/ldns/sha1.h $(srcdir)/ldns/sha2.h dnssec_verify.lo dnssec_verify.o: $(srcdir)/dnssec_verify.c ldns/config.h $(srcdir)/ldns/ldns.h ldns/util.h \ ldns/common.h $(srcdir)/ldns/buffer.h $(srcdir)/ldns/error.h $(srcdir)/ldns/dane.h $(srcdir)/ldns/rdata.h \ $(srcdir)/ldns/rr.h $(srcdir)/ldns/dname.h $(srcdir)/ldns/dnssec.h $(srcdir)/ldns/packet.h $(srcdir)/ldns/keys.h \ $(srcdir)/ldns/zone.h $(srcdir)/ldns/resolver.h $(srcdir)/ldns/tsig.h $(srcdir)/ldns/dnssec_zone.h $(srcdir)/ldns/rbtree.h \ $(srcdir)/ldns/host2str.h $(srcdir)/ldns/dnssec_verify.h $(srcdir)/ldns/dnssec_sign.h $(srcdir)/ldns/duration.h \ $(srcdir)/ldns/higher.h $(srcdir)/ldns/host2wire.h ldns/net.h $(srcdir)/ldns/str2host.h $(srcdir)/ldns/update.h \ $(srcdir)/ldns/wire2host.h $(srcdir)/ldns/rr_functions.h $(srcdir)/ldns/parse.h $(srcdir)/ldns/radix.h \ $(srcdir)/ldns/sha1.h $(srcdir)/ldns/sha2.h dnssec_zone.lo dnssec_zone.o: $(srcdir)/dnssec_zone.c ldns/config.h $(srcdir)/ldns/ldns.h ldns/util.h \ ldns/common.h $(srcdir)/ldns/buffer.h $(srcdir)/ldns/error.h $(srcdir)/ldns/dane.h $(srcdir)/ldns/rdata.h \ $(srcdir)/ldns/rr.h $(srcdir)/ldns/dname.h $(srcdir)/ldns/dnssec.h $(srcdir)/ldns/packet.h $(srcdir)/ldns/keys.h \ $(srcdir)/ldns/zone.h $(srcdir)/ldns/resolver.h $(srcdir)/ldns/tsig.h $(srcdir)/ldns/dnssec_zone.h $(srcdir)/ldns/rbtree.h \ $(srcdir)/ldns/host2str.h $(srcdir)/ldns/dnssec_verify.h $(srcdir)/ldns/dnssec_sign.h $(srcdir)/ldns/duration.h \ $(srcdir)/ldns/higher.h $(srcdir)/ldns/host2wire.h ldns/net.h $(srcdir)/ldns/str2host.h $(srcdir)/ldns/update.h \ $(srcdir)/ldns/wire2host.h $(srcdir)/ldns/rr_functions.h $(srcdir)/ldns/parse.h $(srcdir)/ldns/radix.h \ $(srcdir)/ldns/sha1.h $(srcdir)/ldns/sha2.h duration.lo duration.o: $(srcdir)/duration.c ldns/config.h $(srcdir)/ldns/duration.h error.lo error.o: $(srcdir)/error.c ldns/config.h $(srcdir)/ldns/ldns.h ldns/util.h ldns/common.h \ $(srcdir)/ldns/buffer.h $(srcdir)/ldns/error.h $(srcdir)/ldns/dane.h $(srcdir)/ldns/rdata.h $(srcdir)/ldns/rr.h \ $(srcdir)/ldns/dname.h $(srcdir)/ldns/dnssec.h $(srcdir)/ldns/packet.h $(srcdir)/ldns/keys.h $(srcdir)/ldns/zone.h \ $(srcdir)/ldns/resolver.h $(srcdir)/ldns/tsig.h $(srcdir)/ldns/dnssec_zone.h $(srcdir)/ldns/rbtree.h \ $(srcdir)/ldns/host2str.h $(srcdir)/ldns/dnssec_verify.h $(srcdir)/ldns/dnssec_sign.h $(srcdir)/ldns/duration.h \ $(srcdir)/ldns/higher.h $(srcdir)/ldns/host2wire.h ldns/net.h $(srcdir)/ldns/str2host.h $(srcdir)/ldns/update.h \ $(srcdir)/ldns/wire2host.h $(srcdir)/ldns/rr_functions.h $(srcdir)/ldns/parse.h $(srcdir)/ldns/radix.h \ $(srcdir)/ldns/sha1.h $(srcdir)/ldns/sha2.h higher.lo higher.o: $(srcdir)/higher.c ldns/config.h $(srcdir)/ldns/ldns.h ldns/util.h ldns/common.h \ $(srcdir)/ldns/buffer.h $(srcdir)/ldns/error.h $(srcdir)/ldns/dane.h $(srcdir)/ldns/rdata.h $(srcdir)/ldns/rr.h \ $(srcdir)/ldns/dname.h $(srcdir)/ldns/dnssec.h $(srcdir)/ldns/packet.h $(srcdir)/ldns/keys.h $(srcdir)/ldns/zone.h \ $(srcdir)/ldns/resolver.h $(srcdir)/ldns/tsig.h $(srcdir)/ldns/dnssec_zone.h $(srcdir)/ldns/rbtree.h \ $(srcdir)/ldns/host2str.h $(srcdir)/ldns/dnssec_verify.h $(srcdir)/ldns/dnssec_sign.h $(srcdir)/ldns/duration.h \ $(srcdir)/ldns/higher.h $(srcdir)/ldns/host2wire.h ldns/net.h $(srcdir)/ldns/str2host.h $(srcdir)/ldns/update.h \ $(srcdir)/ldns/wire2host.h $(srcdir)/ldns/rr_functions.h $(srcdir)/ldns/parse.h $(srcdir)/ldns/radix.h \ $(srcdir)/ldns/sha1.h $(srcdir)/ldns/sha2.h host2str.lo host2str.o: $(srcdir)/host2str.c ldns/config.h $(srcdir)/ldns/ldns.h ldns/util.h \ ldns/common.h $(srcdir)/ldns/buffer.h $(srcdir)/ldns/error.h $(srcdir)/ldns/dane.h $(srcdir)/ldns/rdata.h \ $(srcdir)/ldns/rr.h $(srcdir)/ldns/dname.h $(srcdir)/ldns/dnssec.h $(srcdir)/ldns/packet.h $(srcdir)/ldns/keys.h \ $(srcdir)/ldns/zone.h $(srcdir)/ldns/resolver.h $(srcdir)/ldns/tsig.h $(srcdir)/ldns/dnssec_zone.h $(srcdir)/ldns/rbtree.h \ $(srcdir)/ldns/host2str.h $(srcdir)/ldns/dnssec_verify.h $(srcdir)/ldns/dnssec_sign.h $(srcdir)/ldns/duration.h \ $(srcdir)/ldns/higher.h $(srcdir)/ldns/host2wire.h ldns/net.h $(srcdir)/ldns/str2host.h $(srcdir)/ldns/update.h \ $(srcdir)/ldns/wire2host.h $(srcdir)/ldns/rr_functions.h $(srcdir)/ldns/parse.h $(srcdir)/ldns/radix.h \ $(srcdir)/ldns/sha1.h $(srcdir)/ldns/sha2.h host2wire.lo host2wire.o: $(srcdir)/host2wire.c ldns/config.h $(srcdir)/ldns/ldns.h ldns/util.h \ ldns/common.h $(srcdir)/ldns/buffer.h $(srcdir)/ldns/error.h $(srcdir)/ldns/dane.h $(srcdir)/ldns/rdata.h \ $(srcdir)/ldns/rr.h $(srcdir)/ldns/dname.h $(srcdir)/ldns/dnssec.h $(srcdir)/ldns/packet.h $(srcdir)/ldns/keys.h \ $(srcdir)/ldns/zone.h $(srcdir)/ldns/resolver.h $(srcdir)/ldns/tsig.h $(srcdir)/ldns/dnssec_zone.h $(srcdir)/ldns/rbtree.h \ $(srcdir)/ldns/host2str.h $(srcdir)/ldns/dnssec_verify.h $(srcdir)/ldns/dnssec_sign.h $(srcdir)/ldns/duration.h \ $(srcdir)/ldns/higher.h $(srcdir)/ldns/host2wire.h ldns/net.h $(srcdir)/ldns/str2host.h $(srcdir)/ldns/update.h \ $(srcdir)/ldns/wire2host.h $(srcdir)/ldns/rr_functions.h $(srcdir)/ldns/parse.h $(srcdir)/ldns/radix.h \ $(srcdir)/ldns/sha1.h $(srcdir)/ldns/sha2.h keys.lo keys.o: $(srcdir)/keys.c ldns/config.h $(srcdir)/ldns/ldns.h ldns/util.h ldns/common.h \ $(srcdir)/ldns/buffer.h $(srcdir)/ldns/error.h $(srcdir)/ldns/dane.h $(srcdir)/ldns/rdata.h $(srcdir)/ldns/rr.h \ $(srcdir)/ldns/dname.h $(srcdir)/ldns/dnssec.h $(srcdir)/ldns/packet.h $(srcdir)/ldns/keys.h $(srcdir)/ldns/zone.h \ $(srcdir)/ldns/resolver.h $(srcdir)/ldns/tsig.h $(srcdir)/ldns/dnssec_zone.h $(srcdir)/ldns/rbtree.h \ $(srcdir)/ldns/host2str.h $(srcdir)/ldns/dnssec_verify.h $(srcdir)/ldns/dnssec_sign.h $(srcdir)/ldns/duration.h \ $(srcdir)/ldns/higher.h $(srcdir)/ldns/host2wire.h ldns/net.h $(srcdir)/ldns/str2host.h $(srcdir)/ldns/update.h \ $(srcdir)/ldns/wire2host.h $(srcdir)/ldns/rr_functions.h $(srcdir)/ldns/parse.h $(srcdir)/ldns/radix.h \ $(srcdir)/ldns/sha1.h $(srcdir)/ldns/sha2.h linktest.lo linktest.o: $(srcdir)/linktest.c ldns/config.h $(srcdir)/ldns/ldns.h ldns/util.h \ ldns/common.h $(srcdir)/ldns/buffer.h $(srcdir)/ldns/error.h $(srcdir)/ldns/dane.h $(srcdir)/ldns/rdata.h \ $(srcdir)/ldns/rr.h $(srcdir)/ldns/dname.h $(srcdir)/ldns/dnssec.h $(srcdir)/ldns/packet.h $(srcdir)/ldns/keys.h \ $(srcdir)/ldns/zone.h $(srcdir)/ldns/resolver.h $(srcdir)/ldns/tsig.h $(srcdir)/ldns/dnssec_zone.h $(srcdir)/ldns/rbtree.h \ $(srcdir)/ldns/host2str.h $(srcdir)/ldns/dnssec_verify.h $(srcdir)/ldns/dnssec_sign.h $(srcdir)/ldns/duration.h \ $(srcdir)/ldns/higher.h $(srcdir)/ldns/host2wire.h ldns/net.h $(srcdir)/ldns/str2host.h $(srcdir)/ldns/update.h \ $(srcdir)/ldns/wire2host.h $(srcdir)/ldns/rr_functions.h $(srcdir)/ldns/parse.h $(srcdir)/ldns/radix.h \ $(srcdir)/ldns/sha1.h $(srcdir)/ldns/sha2.h net.lo net.o: $(srcdir)/net.c ldns/config.h $(srcdir)/ldns/ldns.h ldns/util.h ldns/common.h \ $(srcdir)/ldns/buffer.h $(srcdir)/ldns/error.h $(srcdir)/ldns/dane.h $(srcdir)/ldns/rdata.h $(srcdir)/ldns/rr.h \ $(srcdir)/ldns/dname.h $(srcdir)/ldns/dnssec.h $(srcdir)/ldns/packet.h $(srcdir)/ldns/keys.h $(srcdir)/ldns/zone.h \ $(srcdir)/ldns/resolver.h $(srcdir)/ldns/tsig.h $(srcdir)/ldns/dnssec_zone.h $(srcdir)/ldns/rbtree.h \ $(srcdir)/ldns/host2str.h $(srcdir)/ldns/dnssec_verify.h $(srcdir)/ldns/dnssec_sign.h $(srcdir)/ldns/duration.h \ $(srcdir)/ldns/higher.h $(srcdir)/ldns/host2wire.h ldns/net.h $(srcdir)/ldns/str2host.h $(srcdir)/ldns/update.h \ $(srcdir)/ldns/wire2host.h $(srcdir)/ldns/rr_functions.h $(srcdir)/ldns/parse.h $(srcdir)/ldns/radix.h \ $(srcdir)/ldns/sha1.h $(srcdir)/ldns/sha2.h packet.lo packet.o: $(srcdir)/packet.c ldns/config.h $(srcdir)/ldns/ldns.h ldns/util.h ldns/common.h \ $(srcdir)/ldns/buffer.h $(srcdir)/ldns/error.h $(srcdir)/ldns/dane.h $(srcdir)/ldns/rdata.h $(srcdir)/ldns/rr.h \ $(srcdir)/ldns/dname.h $(srcdir)/ldns/dnssec.h $(srcdir)/ldns/packet.h $(srcdir)/ldns/keys.h $(srcdir)/ldns/zone.h \ $(srcdir)/ldns/resolver.h $(srcdir)/ldns/tsig.h $(srcdir)/ldns/dnssec_zone.h $(srcdir)/ldns/rbtree.h \ $(srcdir)/ldns/host2str.h $(srcdir)/ldns/dnssec_verify.h $(srcdir)/ldns/dnssec_sign.h $(srcdir)/ldns/duration.h \ $(srcdir)/ldns/higher.h $(srcdir)/ldns/host2wire.h ldns/net.h $(srcdir)/ldns/str2host.h $(srcdir)/ldns/update.h \ $(srcdir)/ldns/wire2host.h $(srcdir)/ldns/rr_functions.h $(srcdir)/ldns/parse.h $(srcdir)/ldns/radix.h \ $(srcdir)/ldns/sha1.h $(srcdir)/ldns/sha2.h parse.lo parse.o: $(srcdir)/parse.c ldns/config.h $(srcdir)/ldns/ldns.h ldns/util.h ldns/common.h \ $(srcdir)/ldns/buffer.h $(srcdir)/ldns/error.h $(srcdir)/ldns/dane.h $(srcdir)/ldns/rdata.h $(srcdir)/ldns/rr.h \ $(srcdir)/ldns/dname.h $(srcdir)/ldns/dnssec.h $(srcdir)/ldns/packet.h $(srcdir)/ldns/keys.h $(srcdir)/ldns/zone.h \ $(srcdir)/ldns/resolver.h $(srcdir)/ldns/tsig.h $(srcdir)/ldns/dnssec_zone.h $(srcdir)/ldns/rbtree.h \ $(srcdir)/ldns/host2str.h $(srcdir)/ldns/dnssec_verify.h $(srcdir)/ldns/dnssec_sign.h $(srcdir)/ldns/duration.h \ $(srcdir)/ldns/higher.h $(srcdir)/ldns/host2wire.h ldns/net.h $(srcdir)/ldns/str2host.h $(srcdir)/ldns/update.h \ $(srcdir)/ldns/wire2host.h $(srcdir)/ldns/rr_functions.h $(srcdir)/ldns/parse.h $(srcdir)/ldns/radix.h \ $(srcdir)/ldns/sha1.h $(srcdir)/ldns/sha2.h radix.lo radix.o: $(srcdir)/radix.c ldns/config.h $(srcdir)/ldns/radix.h $(srcdir)/ldns/error.h ldns/util.h \ ldns/common.h rbtree.lo rbtree.o: $(srcdir)/rbtree.c ldns/config.h $(srcdir)/ldns/rbtree.h ldns/util.h ldns/common.h rdata.lo rdata.o: $(srcdir)/rdata.c ldns/config.h $(srcdir)/ldns/ldns.h ldns/util.h ldns/common.h \ $(srcdir)/ldns/buffer.h $(srcdir)/ldns/error.h $(srcdir)/ldns/dane.h $(srcdir)/ldns/rdata.h $(srcdir)/ldns/rr.h \ $(srcdir)/ldns/dname.h $(srcdir)/ldns/dnssec.h $(srcdir)/ldns/packet.h $(srcdir)/ldns/keys.h $(srcdir)/ldns/zone.h \ $(srcdir)/ldns/resolver.h $(srcdir)/ldns/tsig.h $(srcdir)/ldns/dnssec_zone.h $(srcdir)/ldns/rbtree.h \ $(srcdir)/ldns/host2str.h $(srcdir)/ldns/dnssec_verify.h $(srcdir)/ldns/dnssec_sign.h $(srcdir)/ldns/duration.h \ $(srcdir)/ldns/higher.h $(srcdir)/ldns/host2wire.h ldns/net.h $(srcdir)/ldns/str2host.h $(srcdir)/ldns/update.h \ $(srcdir)/ldns/wire2host.h $(srcdir)/ldns/rr_functions.h $(srcdir)/ldns/parse.h $(srcdir)/ldns/radix.h \ $(srcdir)/ldns/sha1.h $(srcdir)/ldns/sha2.h resolver.lo resolver.o: $(srcdir)/resolver.c ldns/config.h $(srcdir)/ldns/ldns.h ldns/util.h \ ldns/common.h $(srcdir)/ldns/buffer.h $(srcdir)/ldns/error.h $(srcdir)/ldns/dane.h $(srcdir)/ldns/rdata.h \ $(srcdir)/ldns/rr.h $(srcdir)/ldns/dname.h $(srcdir)/ldns/dnssec.h $(srcdir)/ldns/packet.h $(srcdir)/ldns/keys.h \ $(srcdir)/ldns/zone.h $(srcdir)/ldns/resolver.h $(srcdir)/ldns/tsig.h $(srcdir)/ldns/dnssec_zone.h $(srcdir)/ldns/rbtree.h \ $(srcdir)/ldns/host2str.h $(srcdir)/ldns/dnssec_verify.h $(srcdir)/ldns/dnssec_sign.h $(srcdir)/ldns/duration.h \ $(srcdir)/ldns/higher.h $(srcdir)/ldns/host2wire.h ldns/net.h $(srcdir)/ldns/str2host.h $(srcdir)/ldns/update.h \ $(srcdir)/ldns/wire2host.h $(srcdir)/ldns/rr_functions.h $(srcdir)/ldns/parse.h $(srcdir)/ldns/radix.h \ $(srcdir)/ldns/sha1.h $(srcdir)/ldns/sha2.h rr.lo rr.o: $(srcdir)/rr.c ldns/config.h $(srcdir)/ldns/ldns.h ldns/util.h ldns/common.h \ $(srcdir)/ldns/buffer.h $(srcdir)/ldns/error.h $(srcdir)/ldns/dane.h $(srcdir)/ldns/rdata.h $(srcdir)/ldns/rr.h \ $(srcdir)/ldns/dname.h $(srcdir)/ldns/dnssec.h $(srcdir)/ldns/packet.h $(srcdir)/ldns/keys.h $(srcdir)/ldns/zone.h \ $(srcdir)/ldns/resolver.h $(srcdir)/ldns/tsig.h $(srcdir)/ldns/dnssec_zone.h $(srcdir)/ldns/rbtree.h \ $(srcdir)/ldns/host2str.h $(srcdir)/ldns/dnssec_verify.h $(srcdir)/ldns/dnssec_sign.h $(srcdir)/ldns/duration.h \ $(srcdir)/ldns/higher.h $(srcdir)/ldns/host2wire.h ldns/net.h $(srcdir)/ldns/str2host.h $(srcdir)/ldns/update.h \ $(srcdir)/ldns/wire2host.h $(srcdir)/ldns/rr_functions.h $(srcdir)/ldns/parse.h $(srcdir)/ldns/radix.h \ $(srcdir)/ldns/sha1.h $(srcdir)/ldns/sha2.h rr_functions.lo rr_functions.o: $(srcdir)/rr_functions.c ldns/config.h $(srcdir)/ldns/ldns.h ldns/util.h \ ldns/common.h $(srcdir)/ldns/buffer.h $(srcdir)/ldns/error.h $(srcdir)/ldns/dane.h $(srcdir)/ldns/rdata.h \ $(srcdir)/ldns/rr.h $(srcdir)/ldns/dname.h $(srcdir)/ldns/dnssec.h $(srcdir)/ldns/packet.h $(srcdir)/ldns/keys.h \ $(srcdir)/ldns/zone.h $(srcdir)/ldns/resolver.h $(srcdir)/ldns/tsig.h $(srcdir)/ldns/dnssec_zone.h $(srcdir)/ldns/rbtree.h \ $(srcdir)/ldns/host2str.h $(srcdir)/ldns/dnssec_verify.h $(srcdir)/ldns/dnssec_sign.h $(srcdir)/ldns/duration.h \ $(srcdir)/ldns/higher.h $(srcdir)/ldns/host2wire.h ldns/net.h $(srcdir)/ldns/str2host.h $(srcdir)/ldns/update.h \ $(srcdir)/ldns/wire2host.h $(srcdir)/ldns/rr_functions.h $(srcdir)/ldns/parse.h $(srcdir)/ldns/radix.h \ $(srcdir)/ldns/sha1.h $(srcdir)/ldns/sha2.h sha1.lo sha1.o: $(srcdir)/sha1.c ldns/config.h $(srcdir)/ldns/ldns.h ldns/util.h ldns/common.h \ $(srcdir)/ldns/buffer.h $(srcdir)/ldns/error.h $(srcdir)/ldns/dane.h $(srcdir)/ldns/rdata.h $(srcdir)/ldns/rr.h \ $(srcdir)/ldns/dname.h $(srcdir)/ldns/dnssec.h $(srcdir)/ldns/packet.h $(srcdir)/ldns/keys.h $(srcdir)/ldns/zone.h \ $(srcdir)/ldns/resolver.h $(srcdir)/ldns/tsig.h $(srcdir)/ldns/dnssec_zone.h $(srcdir)/ldns/rbtree.h \ $(srcdir)/ldns/host2str.h $(srcdir)/ldns/dnssec_verify.h $(srcdir)/ldns/dnssec_sign.h $(srcdir)/ldns/duration.h \ $(srcdir)/ldns/higher.h $(srcdir)/ldns/host2wire.h ldns/net.h $(srcdir)/ldns/str2host.h $(srcdir)/ldns/update.h \ $(srcdir)/ldns/wire2host.h $(srcdir)/ldns/rr_functions.h $(srcdir)/ldns/parse.h $(srcdir)/ldns/radix.h \ $(srcdir)/ldns/sha1.h $(srcdir)/ldns/sha2.h sha2.lo sha2.o: $(srcdir)/sha2.c ldns/config.h $(srcdir)/ldns/sha2.h str2host.lo str2host.o: $(srcdir)/str2host.c ldns/config.h $(srcdir)/ldns/ldns.h ldns/util.h \ ldns/common.h $(srcdir)/ldns/buffer.h $(srcdir)/ldns/error.h $(srcdir)/ldns/dane.h $(srcdir)/ldns/rdata.h \ $(srcdir)/ldns/rr.h $(srcdir)/ldns/dname.h $(srcdir)/ldns/dnssec.h $(srcdir)/ldns/packet.h $(srcdir)/ldns/keys.h \ $(srcdir)/ldns/zone.h $(srcdir)/ldns/resolver.h $(srcdir)/ldns/tsig.h $(srcdir)/ldns/dnssec_zone.h $(srcdir)/ldns/rbtree.h \ $(srcdir)/ldns/host2str.h $(srcdir)/ldns/dnssec_verify.h $(srcdir)/ldns/dnssec_sign.h $(srcdir)/ldns/duration.h \ $(srcdir)/ldns/higher.h $(srcdir)/ldns/host2wire.h ldns/net.h $(srcdir)/ldns/str2host.h $(srcdir)/ldns/update.h \ $(srcdir)/ldns/wire2host.h $(srcdir)/ldns/rr_functions.h $(srcdir)/ldns/parse.h $(srcdir)/ldns/radix.h \ $(srcdir)/ldns/sha1.h $(srcdir)/ldns/sha2.h tsig.lo tsig.o: $(srcdir)/tsig.c ldns/config.h $(srcdir)/ldns/ldns.h ldns/util.h ldns/common.h \ $(srcdir)/ldns/buffer.h $(srcdir)/ldns/error.h $(srcdir)/ldns/dane.h $(srcdir)/ldns/rdata.h $(srcdir)/ldns/rr.h \ $(srcdir)/ldns/dname.h $(srcdir)/ldns/dnssec.h $(srcdir)/ldns/packet.h $(srcdir)/ldns/keys.h $(srcdir)/ldns/zone.h \ $(srcdir)/ldns/resolver.h $(srcdir)/ldns/tsig.h $(srcdir)/ldns/dnssec_zone.h $(srcdir)/ldns/rbtree.h \ $(srcdir)/ldns/host2str.h $(srcdir)/ldns/dnssec_verify.h $(srcdir)/ldns/dnssec_sign.h $(srcdir)/ldns/duration.h \ $(srcdir)/ldns/higher.h $(srcdir)/ldns/host2wire.h ldns/net.h $(srcdir)/ldns/str2host.h $(srcdir)/ldns/update.h \ $(srcdir)/ldns/wire2host.h $(srcdir)/ldns/rr_functions.h $(srcdir)/ldns/parse.h $(srcdir)/ldns/radix.h \ $(srcdir)/ldns/sha1.h $(srcdir)/ldns/sha2.h update.lo update.o: $(srcdir)/update.c ldns/config.h $(srcdir)/ldns/ldns.h ldns/util.h ldns/common.h \ $(srcdir)/ldns/buffer.h $(srcdir)/ldns/error.h $(srcdir)/ldns/dane.h $(srcdir)/ldns/rdata.h $(srcdir)/ldns/rr.h \ $(srcdir)/ldns/dname.h $(srcdir)/ldns/dnssec.h $(srcdir)/ldns/packet.h $(srcdir)/ldns/keys.h $(srcdir)/ldns/zone.h \ $(srcdir)/ldns/resolver.h $(srcdir)/ldns/tsig.h $(srcdir)/ldns/dnssec_zone.h $(srcdir)/ldns/rbtree.h \ $(srcdir)/ldns/host2str.h $(srcdir)/ldns/dnssec_verify.h $(srcdir)/ldns/dnssec_sign.h $(srcdir)/ldns/duration.h \ $(srcdir)/ldns/higher.h $(srcdir)/ldns/host2wire.h ldns/net.h $(srcdir)/ldns/str2host.h $(srcdir)/ldns/update.h \ $(srcdir)/ldns/wire2host.h $(srcdir)/ldns/rr_functions.h $(srcdir)/ldns/parse.h $(srcdir)/ldns/radix.h \ $(srcdir)/ldns/sha1.h $(srcdir)/ldns/sha2.h util.lo util.o: $(srcdir)/util.c ldns/config.h $(srcdir)/ldns/rdata.h ldns/common.h $(srcdir)/ldns/error.h \ ldns/util.h $(srcdir)/ldns/rr.h $(srcdir)/ldns/buffer.h wire2host.lo wire2host.o: $(srcdir)/wire2host.c ldns/config.h $(srcdir)/ldns/ldns.h ldns/util.h \ ldns/common.h $(srcdir)/ldns/buffer.h $(srcdir)/ldns/error.h $(srcdir)/ldns/dane.h $(srcdir)/ldns/rdata.h \ $(srcdir)/ldns/rr.h $(srcdir)/ldns/dname.h $(srcdir)/ldns/dnssec.h $(srcdir)/ldns/packet.h $(srcdir)/ldns/keys.h \ $(srcdir)/ldns/zone.h $(srcdir)/ldns/resolver.h $(srcdir)/ldns/tsig.h $(srcdir)/ldns/dnssec_zone.h $(srcdir)/ldns/rbtree.h \ $(srcdir)/ldns/host2str.h $(srcdir)/ldns/dnssec_verify.h $(srcdir)/ldns/dnssec_sign.h $(srcdir)/ldns/duration.h \ $(srcdir)/ldns/higher.h $(srcdir)/ldns/host2wire.h ldns/net.h $(srcdir)/ldns/str2host.h $(srcdir)/ldns/update.h \ $(srcdir)/ldns/wire2host.h $(srcdir)/ldns/rr_functions.h $(srcdir)/ldns/parse.h $(srcdir)/ldns/radix.h \ $(srcdir)/ldns/sha1.h $(srcdir)/ldns/sha2.h zone.lo zone.o: $(srcdir)/zone.c ldns/config.h $(srcdir)/ldns/ldns.h ldns/util.h ldns/common.h \ $(srcdir)/ldns/buffer.h $(srcdir)/ldns/error.h $(srcdir)/ldns/dane.h $(srcdir)/ldns/rdata.h $(srcdir)/ldns/rr.h \ $(srcdir)/ldns/dname.h $(srcdir)/ldns/dnssec.h $(srcdir)/ldns/packet.h $(srcdir)/ldns/keys.h $(srcdir)/ldns/zone.h \ $(srcdir)/ldns/resolver.h $(srcdir)/ldns/tsig.h $(srcdir)/ldns/dnssec_zone.h $(srcdir)/ldns/rbtree.h \ $(srcdir)/ldns/host2str.h $(srcdir)/ldns/dnssec_verify.h $(srcdir)/ldns/dnssec_sign.h $(srcdir)/ldns/duration.h \ $(srcdir)/ldns/higher.h $(srcdir)/ldns/host2wire.h ldns/net.h $(srcdir)/ldns/str2host.h $(srcdir)/ldns/update.h \ $(srcdir)/ldns/wire2host.h $(srcdir)/ldns/rr_functions.h $(srcdir)/ldns/parse.h $(srcdir)/ldns/radix.h \ $(srcdir)/ldns/sha1.h $(srcdir)/ldns/sha2.h compat/b64_ntop.lo compat/b64_ntop.o: $(srcdir)/compat/b64_ntop.c ldns/config.h compat/b64_pton.lo compat/b64_pton.o: $(srcdir)/compat/b64_pton.c ldns/config.h compat/calloc.lo compat/calloc.o: $(srcdir)/compat/calloc.c ldns/config.h compat/ctime_r.lo compat/ctime_r.o: $(srcdir)/compat/ctime_r.c ldns/config.h compat/fake-rfc2553.lo compat/fake-rfc2553.o: $(srcdir)/compat/fake-rfc2553.c ldns/config.h ldns/common.h \ $(srcdir)/compat/fake-rfc2553.h compat/gmtime_r.lo compat/gmtime_r.o: $(srcdir)/compat/gmtime_r.c ldns/config.h compat/inet_aton.lo compat/inet_aton.o: $(srcdir)/compat/inet_aton.c ldns/config.h compat/inet_ntop.lo compat/inet_ntop.o: $(srcdir)/compat/inet_ntop.c ldns/config.h compat/inet_pton.lo compat/inet_pton.o: $(srcdir)/compat/inet_pton.c ldns/config.h compat/isascii.lo compat/isascii.o: $(srcdir)/compat/isascii.c ldns/config.h compat/isblank.lo compat/isblank.o: $(srcdir)/compat/isblank.c ldns/config.h compat/localtime_r.lo compat/localtime_r.o: $(srcdir)/compat/localtime_r.c ldns/config.h compat/malloc.lo compat/malloc.o: $(srcdir)/compat/malloc.c ldns/config.h compat/memmove.lo compat/memmove.o: $(srcdir)/compat/memmove.c ldns/config.h compat/realloc.lo compat/realloc.o: $(srcdir)/compat/realloc.c ldns/config.h compat/snprintf.lo compat/snprintf.o: $(srcdir)/compat/snprintf.c ldns/config.h compat/strlcpy.lo compat/strlcpy.o: $(srcdir)/compat/strlcpy.c ldns/config.h compat/timegm.lo compat/timegm.o: $(srcdir)/compat/timegm.c ldns/config.h examples/ldns-chaos.lo examples/ldns-chaos.o: $(srcdir)/examples/ldns-chaos.c ldns/config.h $(srcdir)/ldns/ldns.h ldns/util.h \ ldns/common.h $(srcdir)/ldns/buffer.h $(srcdir)/ldns/error.h $(srcdir)/ldns/dane.h $(srcdir)/ldns/rdata.h \ $(srcdir)/ldns/rr.h $(srcdir)/ldns/dname.h $(srcdir)/ldns/dnssec.h $(srcdir)/ldns/packet.h $(srcdir)/ldns/keys.h \ $(srcdir)/ldns/zone.h $(srcdir)/ldns/resolver.h $(srcdir)/ldns/tsig.h $(srcdir)/ldns/dnssec_zone.h $(srcdir)/ldns/rbtree.h \ $(srcdir)/ldns/host2str.h $(srcdir)/ldns/dnssec_verify.h $(srcdir)/ldns/dnssec_sign.h $(srcdir)/ldns/duration.h \ $(srcdir)/ldns/higher.h $(srcdir)/ldns/host2wire.h ldns/net.h $(srcdir)/ldns/str2host.h $(srcdir)/ldns/update.h \ $(srcdir)/ldns/wire2host.h $(srcdir)/ldns/rr_functions.h $(srcdir)/ldns/parse.h $(srcdir)/ldns/radix.h \ $(srcdir)/ldns/sha1.h $(srcdir)/ldns/sha2.h examples/ldns-compare-zones.lo examples/ldns-compare-zones.o: $(srcdir)/examples/ldns-compare-zones.c ldns/config.h $(srcdir)/ldns/ldns.h \ ldns/util.h ldns/common.h $(srcdir)/ldns/buffer.h $(srcdir)/ldns/error.h $(srcdir)/ldns/dane.h \ $(srcdir)/ldns/rdata.h $(srcdir)/ldns/rr.h $(srcdir)/ldns/dname.h $(srcdir)/ldns/dnssec.h $(srcdir)/ldns/packet.h \ $(srcdir)/ldns/keys.h $(srcdir)/ldns/zone.h $(srcdir)/ldns/resolver.h $(srcdir)/ldns/tsig.h $(srcdir)/ldns/dnssec_zone.h \ $(srcdir)/ldns/rbtree.h $(srcdir)/ldns/host2str.h $(srcdir)/ldns/dnssec_verify.h $(srcdir)/ldns/dnssec_sign.h \ $(srcdir)/ldns/duration.h $(srcdir)/ldns/higher.h $(srcdir)/ldns/host2wire.h ldns/net.h \ $(srcdir)/ldns/str2host.h $(srcdir)/ldns/update.h $(srcdir)/ldns/wire2host.h $(srcdir)/ldns/rr_functions.h \ $(srcdir)/ldns/parse.h $(srcdir)/ldns/radix.h $(srcdir)/ldns/sha1.h $(srcdir)/ldns/sha2.h examples/ldns-dane.lo examples/ldns-dane.o: $(srcdir)/examples/ldns-dane.c ldns/config.h $(srcdir)/ldns/ldns.h ldns/util.h \ ldns/common.h $(srcdir)/ldns/buffer.h $(srcdir)/ldns/error.h $(srcdir)/ldns/dane.h $(srcdir)/ldns/rdata.h \ $(srcdir)/ldns/rr.h $(srcdir)/ldns/dname.h $(srcdir)/ldns/dnssec.h $(srcdir)/ldns/packet.h $(srcdir)/ldns/keys.h \ $(srcdir)/ldns/zone.h $(srcdir)/ldns/resolver.h $(srcdir)/ldns/tsig.h $(srcdir)/ldns/dnssec_zone.h $(srcdir)/ldns/rbtree.h \ $(srcdir)/ldns/host2str.h $(srcdir)/ldns/dnssec_verify.h $(srcdir)/ldns/dnssec_sign.h $(srcdir)/ldns/duration.h \ $(srcdir)/ldns/higher.h $(srcdir)/ldns/host2wire.h ldns/net.h $(srcdir)/ldns/str2host.h $(srcdir)/ldns/update.h \ $(srcdir)/ldns/wire2host.h $(srcdir)/ldns/rr_functions.h $(srcdir)/ldns/parse.h $(srcdir)/ldns/radix.h \ $(srcdir)/ldns/sha1.h $(srcdir)/ldns/sha2.h examples/ldnsd.lo examples/ldnsd.o: $(srcdir)/examples/ldnsd.c ldns/config.h $(srcdir)/ldns/ldns.h ldns/util.h ldns/common.h \ $(srcdir)/ldns/buffer.h $(srcdir)/ldns/error.h $(srcdir)/ldns/dane.h $(srcdir)/ldns/rdata.h $(srcdir)/ldns/rr.h \ $(srcdir)/ldns/dname.h $(srcdir)/ldns/dnssec.h $(srcdir)/ldns/packet.h $(srcdir)/ldns/keys.h $(srcdir)/ldns/zone.h \ $(srcdir)/ldns/resolver.h $(srcdir)/ldns/tsig.h $(srcdir)/ldns/dnssec_zone.h $(srcdir)/ldns/rbtree.h \ $(srcdir)/ldns/host2str.h $(srcdir)/ldns/dnssec_verify.h $(srcdir)/ldns/dnssec_sign.h $(srcdir)/ldns/duration.h \ $(srcdir)/ldns/higher.h $(srcdir)/ldns/host2wire.h ldns/net.h $(srcdir)/ldns/str2host.h $(srcdir)/ldns/update.h \ $(srcdir)/ldns/wire2host.h $(srcdir)/ldns/rr_functions.h $(srcdir)/ldns/parse.h $(srcdir)/ldns/radix.h \ $(srcdir)/ldns/sha1.h $(srcdir)/ldns/sha2.h examples/ldns-dpa.lo examples/ldns-dpa.o: $(srcdir)/examples/ldns-dpa.c ldns/config.h $(srcdir)/ldns/ldns.h ldns/util.h \ ldns/common.h $(srcdir)/ldns/buffer.h $(srcdir)/ldns/error.h $(srcdir)/ldns/dane.h $(srcdir)/ldns/rdata.h \ $(srcdir)/ldns/rr.h $(srcdir)/ldns/dname.h $(srcdir)/ldns/dnssec.h $(srcdir)/ldns/packet.h $(srcdir)/ldns/keys.h \ $(srcdir)/ldns/zone.h $(srcdir)/ldns/resolver.h $(srcdir)/ldns/tsig.h $(srcdir)/ldns/dnssec_zone.h $(srcdir)/ldns/rbtree.h \ $(srcdir)/ldns/host2str.h $(srcdir)/ldns/dnssec_verify.h $(srcdir)/ldns/dnssec_sign.h $(srcdir)/ldns/duration.h \ $(srcdir)/ldns/higher.h $(srcdir)/ldns/host2wire.h ldns/net.h $(srcdir)/ldns/str2host.h $(srcdir)/ldns/update.h \ $(srcdir)/ldns/wire2host.h $(srcdir)/ldns/rr_functions.h $(srcdir)/ldns/parse.h $(srcdir)/ldns/radix.h \ $(srcdir)/ldns/sha1.h $(srcdir)/ldns/sha2.h $(srcdir)/examples/ldns-dpa.h examples/ldns-gen-zone.lo examples/ldns-gen-zone.o: $(srcdir)/examples/ldns-gen-zone.c ldns/config.h $(srcdir)/ldns/ldns.h \ ldns/util.h ldns/common.h $(srcdir)/ldns/buffer.h $(srcdir)/ldns/error.h $(srcdir)/ldns/dane.h \ $(srcdir)/ldns/rdata.h $(srcdir)/ldns/rr.h $(srcdir)/ldns/dname.h $(srcdir)/ldns/dnssec.h $(srcdir)/ldns/packet.h \ $(srcdir)/ldns/keys.h $(srcdir)/ldns/zone.h $(srcdir)/ldns/resolver.h $(srcdir)/ldns/tsig.h $(srcdir)/ldns/dnssec_zone.h \ $(srcdir)/ldns/rbtree.h $(srcdir)/ldns/host2str.h $(srcdir)/ldns/dnssec_verify.h $(srcdir)/ldns/dnssec_sign.h \ $(srcdir)/ldns/duration.h $(srcdir)/ldns/higher.h $(srcdir)/ldns/host2wire.h ldns/net.h \ $(srcdir)/ldns/str2host.h $(srcdir)/ldns/update.h $(srcdir)/ldns/wire2host.h $(srcdir)/ldns/rr_functions.h \ $(srcdir)/ldns/parse.h $(srcdir)/ldns/radix.h $(srcdir)/ldns/sha1.h $(srcdir)/ldns/sha2.h examples/ldns-key2ds.lo examples/ldns-key2ds.o: $(srcdir)/examples/ldns-key2ds.c ldns/config.h $(srcdir)/ldns/ldns.h ldns/util.h \ ldns/common.h $(srcdir)/ldns/buffer.h $(srcdir)/ldns/error.h $(srcdir)/ldns/dane.h $(srcdir)/ldns/rdata.h \ $(srcdir)/ldns/rr.h $(srcdir)/ldns/dname.h $(srcdir)/ldns/dnssec.h $(srcdir)/ldns/packet.h $(srcdir)/ldns/keys.h \ $(srcdir)/ldns/zone.h $(srcdir)/ldns/resolver.h $(srcdir)/ldns/tsig.h $(srcdir)/ldns/dnssec_zone.h $(srcdir)/ldns/rbtree.h \ $(srcdir)/ldns/host2str.h $(srcdir)/ldns/dnssec_verify.h $(srcdir)/ldns/dnssec_sign.h $(srcdir)/ldns/duration.h \ $(srcdir)/ldns/higher.h $(srcdir)/ldns/host2wire.h ldns/net.h $(srcdir)/ldns/str2host.h $(srcdir)/ldns/update.h \ $(srcdir)/ldns/wire2host.h $(srcdir)/ldns/rr_functions.h $(srcdir)/ldns/parse.h $(srcdir)/ldns/radix.h \ $(srcdir)/ldns/sha1.h $(srcdir)/ldns/sha2.h examples/ldns-keyfetcher.lo examples/ldns-keyfetcher.o: $(srcdir)/examples/ldns-keyfetcher.c ldns/config.h $(srcdir)/ldns/ldns.h \ ldns/util.h ldns/common.h $(srcdir)/ldns/buffer.h $(srcdir)/ldns/error.h $(srcdir)/ldns/dane.h \ $(srcdir)/ldns/rdata.h $(srcdir)/ldns/rr.h $(srcdir)/ldns/dname.h $(srcdir)/ldns/dnssec.h $(srcdir)/ldns/packet.h \ $(srcdir)/ldns/keys.h $(srcdir)/ldns/zone.h $(srcdir)/ldns/resolver.h $(srcdir)/ldns/tsig.h $(srcdir)/ldns/dnssec_zone.h \ $(srcdir)/ldns/rbtree.h $(srcdir)/ldns/host2str.h $(srcdir)/ldns/dnssec_verify.h $(srcdir)/ldns/dnssec_sign.h \ $(srcdir)/ldns/duration.h $(srcdir)/ldns/higher.h $(srcdir)/ldns/host2wire.h ldns/net.h \ $(srcdir)/ldns/str2host.h $(srcdir)/ldns/update.h $(srcdir)/ldns/wire2host.h $(srcdir)/ldns/rr_functions.h \ $(srcdir)/ldns/parse.h $(srcdir)/ldns/radix.h $(srcdir)/ldns/sha1.h $(srcdir)/ldns/sha2.h examples/ldns-keygen.lo examples/ldns-keygen.o: $(srcdir)/examples/ldns-keygen.c ldns/config.h $(srcdir)/ldns/ldns.h ldns/util.h \ ldns/common.h $(srcdir)/ldns/buffer.h $(srcdir)/ldns/error.h $(srcdir)/ldns/dane.h $(srcdir)/ldns/rdata.h \ $(srcdir)/ldns/rr.h $(srcdir)/ldns/dname.h $(srcdir)/ldns/dnssec.h $(srcdir)/ldns/packet.h $(srcdir)/ldns/keys.h \ $(srcdir)/ldns/zone.h $(srcdir)/ldns/resolver.h $(srcdir)/ldns/tsig.h $(srcdir)/ldns/dnssec_zone.h $(srcdir)/ldns/rbtree.h \ $(srcdir)/ldns/host2str.h $(srcdir)/ldns/dnssec_verify.h $(srcdir)/ldns/dnssec_sign.h $(srcdir)/ldns/duration.h \ $(srcdir)/ldns/higher.h $(srcdir)/ldns/host2wire.h ldns/net.h $(srcdir)/ldns/str2host.h $(srcdir)/ldns/update.h \ $(srcdir)/ldns/wire2host.h $(srcdir)/ldns/rr_functions.h $(srcdir)/ldns/parse.h $(srcdir)/ldns/radix.h \ $(srcdir)/ldns/sha1.h $(srcdir)/ldns/sha2.h examples/ldns-mx.lo examples/ldns-mx.o: $(srcdir)/examples/ldns-mx.c ldns/config.h $(srcdir)/ldns/ldns.h ldns/util.h \ ldns/common.h $(srcdir)/ldns/buffer.h $(srcdir)/ldns/error.h $(srcdir)/ldns/dane.h $(srcdir)/ldns/rdata.h \ $(srcdir)/ldns/rr.h $(srcdir)/ldns/dname.h $(srcdir)/ldns/dnssec.h $(srcdir)/ldns/packet.h $(srcdir)/ldns/keys.h \ $(srcdir)/ldns/zone.h $(srcdir)/ldns/resolver.h $(srcdir)/ldns/tsig.h $(srcdir)/ldns/dnssec_zone.h $(srcdir)/ldns/rbtree.h \ $(srcdir)/ldns/host2str.h $(srcdir)/ldns/dnssec_verify.h $(srcdir)/ldns/dnssec_sign.h $(srcdir)/ldns/duration.h \ $(srcdir)/ldns/higher.h $(srcdir)/ldns/host2wire.h ldns/net.h $(srcdir)/ldns/str2host.h $(srcdir)/ldns/update.h \ $(srcdir)/ldns/wire2host.h $(srcdir)/ldns/rr_functions.h $(srcdir)/ldns/parse.h $(srcdir)/ldns/radix.h \ $(srcdir)/ldns/sha1.h $(srcdir)/ldns/sha2.h examples/ldns-notify.lo examples/ldns-notify.o: $(srcdir)/examples/ldns-notify.c ldns/config.h $(srcdir)/ldns/ldns.h ldns/util.h \ ldns/common.h $(srcdir)/ldns/buffer.h $(srcdir)/ldns/error.h $(srcdir)/ldns/dane.h $(srcdir)/ldns/rdata.h \ $(srcdir)/ldns/rr.h $(srcdir)/ldns/dname.h $(srcdir)/ldns/dnssec.h $(srcdir)/ldns/packet.h $(srcdir)/ldns/keys.h \ $(srcdir)/ldns/zone.h $(srcdir)/ldns/resolver.h $(srcdir)/ldns/tsig.h $(srcdir)/ldns/dnssec_zone.h $(srcdir)/ldns/rbtree.h \ $(srcdir)/ldns/host2str.h $(srcdir)/ldns/dnssec_verify.h $(srcdir)/ldns/dnssec_sign.h $(srcdir)/ldns/duration.h \ $(srcdir)/ldns/higher.h $(srcdir)/ldns/host2wire.h ldns/net.h $(srcdir)/ldns/str2host.h $(srcdir)/ldns/update.h \ $(srcdir)/ldns/wire2host.h $(srcdir)/ldns/rr_functions.h $(srcdir)/ldns/parse.h $(srcdir)/ldns/radix.h \ $(srcdir)/ldns/sha1.h $(srcdir)/ldns/sha2.h examples/ldns-nsec3-hash.lo examples/ldns-nsec3-hash.o: $(srcdir)/examples/ldns-nsec3-hash.c ldns/config.h $(srcdir)/ldns/ldns.h \ ldns/util.h ldns/common.h $(srcdir)/ldns/buffer.h $(srcdir)/ldns/error.h $(srcdir)/ldns/dane.h \ $(srcdir)/ldns/rdata.h $(srcdir)/ldns/rr.h $(srcdir)/ldns/dname.h $(srcdir)/ldns/dnssec.h $(srcdir)/ldns/packet.h \ $(srcdir)/ldns/keys.h $(srcdir)/ldns/zone.h $(srcdir)/ldns/resolver.h $(srcdir)/ldns/tsig.h $(srcdir)/ldns/dnssec_zone.h \ $(srcdir)/ldns/rbtree.h $(srcdir)/ldns/host2str.h $(srcdir)/ldns/dnssec_verify.h $(srcdir)/ldns/dnssec_sign.h \ $(srcdir)/ldns/duration.h $(srcdir)/ldns/higher.h $(srcdir)/ldns/host2wire.h ldns/net.h \ $(srcdir)/ldns/str2host.h $(srcdir)/ldns/update.h $(srcdir)/ldns/wire2host.h $(srcdir)/ldns/rr_functions.h \ $(srcdir)/ldns/parse.h $(srcdir)/ldns/radix.h $(srcdir)/ldns/sha1.h $(srcdir)/ldns/sha2.h examples/ldns-read-zone.lo examples/ldns-read-zone.o: $(srcdir)/examples/ldns-read-zone.c ldns/config.h $(srcdir)/ldns/ldns.h \ ldns/util.h ldns/common.h $(srcdir)/ldns/buffer.h $(srcdir)/ldns/error.h $(srcdir)/ldns/dane.h \ $(srcdir)/ldns/rdata.h $(srcdir)/ldns/rr.h $(srcdir)/ldns/dname.h $(srcdir)/ldns/dnssec.h $(srcdir)/ldns/packet.h \ $(srcdir)/ldns/keys.h $(srcdir)/ldns/zone.h $(srcdir)/ldns/resolver.h $(srcdir)/ldns/tsig.h $(srcdir)/ldns/dnssec_zone.h \ $(srcdir)/ldns/rbtree.h $(srcdir)/ldns/host2str.h $(srcdir)/ldns/dnssec_verify.h $(srcdir)/ldns/dnssec_sign.h \ $(srcdir)/ldns/duration.h $(srcdir)/ldns/higher.h $(srcdir)/ldns/host2wire.h ldns/net.h \ $(srcdir)/ldns/str2host.h $(srcdir)/ldns/update.h $(srcdir)/ldns/wire2host.h $(srcdir)/ldns/rr_functions.h \ $(srcdir)/ldns/parse.h $(srcdir)/ldns/radix.h $(srcdir)/ldns/sha1.h $(srcdir)/ldns/sha2.h examples/ldns-resolver.lo examples/ldns-resolver.o: $(srcdir)/examples/ldns-resolver.c ldns/config.h $(srcdir)/ldns/ldns.h \ ldns/util.h ldns/common.h $(srcdir)/ldns/buffer.h $(srcdir)/ldns/error.h $(srcdir)/ldns/dane.h \ $(srcdir)/ldns/rdata.h $(srcdir)/ldns/rr.h $(srcdir)/ldns/dname.h $(srcdir)/ldns/dnssec.h $(srcdir)/ldns/packet.h \ $(srcdir)/ldns/keys.h $(srcdir)/ldns/zone.h $(srcdir)/ldns/resolver.h $(srcdir)/ldns/tsig.h $(srcdir)/ldns/dnssec_zone.h \ $(srcdir)/ldns/rbtree.h $(srcdir)/ldns/host2str.h $(srcdir)/ldns/dnssec_verify.h $(srcdir)/ldns/dnssec_sign.h \ $(srcdir)/ldns/duration.h $(srcdir)/ldns/higher.h $(srcdir)/ldns/host2wire.h ldns/net.h \ $(srcdir)/ldns/str2host.h $(srcdir)/ldns/update.h $(srcdir)/ldns/wire2host.h $(srcdir)/ldns/rr_functions.h \ $(srcdir)/ldns/parse.h $(srcdir)/ldns/radix.h $(srcdir)/ldns/sha1.h $(srcdir)/ldns/sha2.h examples/ldns-revoke.lo examples/ldns-revoke.o: $(srcdir)/examples/ldns-revoke.c ldns/config.h $(srcdir)/ldns/ldns.h ldns/util.h \ ldns/common.h $(srcdir)/ldns/buffer.h $(srcdir)/ldns/error.h $(srcdir)/ldns/dane.h $(srcdir)/ldns/rdata.h \ $(srcdir)/ldns/rr.h $(srcdir)/ldns/dname.h $(srcdir)/ldns/dnssec.h $(srcdir)/ldns/packet.h $(srcdir)/ldns/keys.h \ $(srcdir)/ldns/zone.h $(srcdir)/ldns/resolver.h $(srcdir)/ldns/tsig.h $(srcdir)/ldns/dnssec_zone.h $(srcdir)/ldns/rbtree.h \ $(srcdir)/ldns/host2str.h $(srcdir)/ldns/dnssec_verify.h $(srcdir)/ldns/dnssec_sign.h $(srcdir)/ldns/duration.h \ $(srcdir)/ldns/higher.h $(srcdir)/ldns/host2wire.h ldns/net.h $(srcdir)/ldns/str2host.h $(srcdir)/ldns/update.h \ $(srcdir)/ldns/wire2host.h $(srcdir)/ldns/rr_functions.h $(srcdir)/ldns/parse.h $(srcdir)/ldns/radix.h \ $(srcdir)/ldns/sha1.h $(srcdir)/ldns/sha2.h examples/ldns-rrsig.lo examples/ldns-rrsig.o: $(srcdir)/examples/ldns-rrsig.c ldns/config.h $(srcdir)/ldns/ldns.h ldns/util.h \ ldns/common.h $(srcdir)/ldns/buffer.h $(srcdir)/ldns/error.h $(srcdir)/ldns/dane.h $(srcdir)/ldns/rdata.h \ $(srcdir)/ldns/rr.h $(srcdir)/ldns/dname.h $(srcdir)/ldns/dnssec.h $(srcdir)/ldns/packet.h $(srcdir)/ldns/keys.h \ $(srcdir)/ldns/zone.h $(srcdir)/ldns/resolver.h $(srcdir)/ldns/tsig.h $(srcdir)/ldns/dnssec_zone.h $(srcdir)/ldns/rbtree.h \ $(srcdir)/ldns/host2str.h $(srcdir)/ldns/dnssec_verify.h $(srcdir)/ldns/dnssec_sign.h $(srcdir)/ldns/duration.h \ $(srcdir)/ldns/higher.h $(srcdir)/ldns/host2wire.h ldns/net.h $(srcdir)/ldns/str2host.h $(srcdir)/ldns/update.h \ $(srcdir)/ldns/wire2host.h $(srcdir)/ldns/rr_functions.h $(srcdir)/ldns/parse.h $(srcdir)/ldns/radix.h \ $(srcdir)/ldns/sha1.h $(srcdir)/ldns/sha2.h examples/ldns-signzone.lo examples/ldns-signzone.o: $(srcdir)/examples/ldns-signzone.c ldns/config.h $(srcdir)/ldns/ldns.h \ ldns/util.h ldns/common.h $(srcdir)/ldns/buffer.h $(srcdir)/ldns/error.h $(srcdir)/ldns/dane.h \ $(srcdir)/ldns/rdata.h $(srcdir)/ldns/rr.h $(srcdir)/ldns/dname.h $(srcdir)/ldns/dnssec.h $(srcdir)/ldns/packet.h \ $(srcdir)/ldns/keys.h $(srcdir)/ldns/zone.h $(srcdir)/ldns/resolver.h $(srcdir)/ldns/tsig.h $(srcdir)/ldns/dnssec_zone.h \ $(srcdir)/ldns/rbtree.h $(srcdir)/ldns/host2str.h $(srcdir)/ldns/dnssec_verify.h $(srcdir)/ldns/dnssec_sign.h \ $(srcdir)/ldns/duration.h $(srcdir)/ldns/higher.h $(srcdir)/ldns/host2wire.h ldns/net.h \ $(srcdir)/ldns/str2host.h $(srcdir)/ldns/update.h $(srcdir)/ldns/wire2host.h $(srcdir)/ldns/rr_functions.h \ $(srcdir)/ldns/parse.h $(srcdir)/ldns/radix.h $(srcdir)/ldns/sha1.h $(srcdir)/ldns/sha2.h examples/ldns-test-edns.lo examples/ldns-test-edns.o: $(srcdir)/examples/ldns-test-edns.c ldns/config.h $(srcdir)/ldns/ldns.h \ ldns/util.h ldns/common.h $(srcdir)/ldns/buffer.h $(srcdir)/ldns/error.h $(srcdir)/ldns/dane.h \ $(srcdir)/ldns/rdata.h $(srcdir)/ldns/rr.h $(srcdir)/ldns/dname.h $(srcdir)/ldns/dnssec.h $(srcdir)/ldns/packet.h \ $(srcdir)/ldns/keys.h $(srcdir)/ldns/zone.h $(srcdir)/ldns/resolver.h $(srcdir)/ldns/tsig.h $(srcdir)/ldns/dnssec_zone.h \ $(srcdir)/ldns/rbtree.h $(srcdir)/ldns/host2str.h $(srcdir)/ldns/dnssec_verify.h $(srcdir)/ldns/dnssec_sign.h \ $(srcdir)/ldns/duration.h $(srcdir)/ldns/higher.h $(srcdir)/ldns/host2wire.h ldns/net.h \ $(srcdir)/ldns/str2host.h $(srcdir)/ldns/update.h $(srcdir)/ldns/wire2host.h $(srcdir)/ldns/rr_functions.h \ $(srcdir)/ldns/parse.h $(srcdir)/ldns/radix.h $(srcdir)/ldns/sha1.h $(srcdir)/ldns/sha2.h examples/ldns-testns.lo examples/ldns-testns.o: $(srcdir)/examples/ldns-testns.c ldns/config.h $(srcdir)/ldns/ldns.h ldns/util.h \ ldns/common.h $(srcdir)/ldns/buffer.h $(srcdir)/ldns/error.h $(srcdir)/ldns/dane.h $(srcdir)/ldns/rdata.h \ $(srcdir)/ldns/rr.h $(srcdir)/ldns/dname.h $(srcdir)/ldns/dnssec.h $(srcdir)/ldns/packet.h $(srcdir)/ldns/keys.h \ $(srcdir)/ldns/zone.h $(srcdir)/ldns/resolver.h $(srcdir)/ldns/tsig.h $(srcdir)/ldns/dnssec_zone.h $(srcdir)/ldns/rbtree.h \ $(srcdir)/ldns/host2str.h $(srcdir)/ldns/dnssec_verify.h $(srcdir)/ldns/dnssec_sign.h $(srcdir)/ldns/duration.h \ $(srcdir)/ldns/higher.h $(srcdir)/ldns/host2wire.h ldns/net.h $(srcdir)/ldns/str2host.h $(srcdir)/ldns/update.h \ $(srcdir)/ldns/wire2host.h $(srcdir)/ldns/rr_functions.h $(srcdir)/ldns/parse.h $(srcdir)/ldns/radix.h \ $(srcdir)/ldns/sha1.h $(srcdir)/ldns/sha2.h $(srcdir)/examples/ldns-testpkts.h examples/ldns-testpkts.lo examples/ldns-testpkts.o: $(srcdir)/examples/ldns-testpkts.c ldns/config.h $(srcdir)/ldns/ldns.h \ ldns/util.h ldns/common.h $(srcdir)/ldns/buffer.h $(srcdir)/ldns/error.h $(srcdir)/ldns/dane.h \ $(srcdir)/ldns/rdata.h $(srcdir)/ldns/rr.h $(srcdir)/ldns/dname.h $(srcdir)/ldns/dnssec.h $(srcdir)/ldns/packet.h \ $(srcdir)/ldns/keys.h $(srcdir)/ldns/zone.h $(srcdir)/ldns/resolver.h $(srcdir)/ldns/tsig.h $(srcdir)/ldns/dnssec_zone.h \ $(srcdir)/ldns/rbtree.h $(srcdir)/ldns/host2str.h $(srcdir)/ldns/dnssec_verify.h $(srcdir)/ldns/dnssec_sign.h \ $(srcdir)/ldns/duration.h $(srcdir)/ldns/higher.h $(srcdir)/ldns/host2wire.h ldns/net.h \ $(srcdir)/ldns/str2host.h $(srcdir)/ldns/update.h $(srcdir)/ldns/wire2host.h $(srcdir)/ldns/rr_functions.h \ $(srcdir)/ldns/parse.h $(srcdir)/ldns/radix.h $(srcdir)/ldns/sha1.h $(srcdir)/ldns/sha2.h \ $(srcdir)/examples/ldns-testpkts.h examples/ldns-update.lo examples/ldns-update.o: $(srcdir)/examples/ldns-update.c ldns/config.h $(srcdir)/ldns/ldns.h ldns/util.h \ ldns/common.h $(srcdir)/ldns/buffer.h $(srcdir)/ldns/error.h $(srcdir)/ldns/dane.h $(srcdir)/ldns/rdata.h \ $(srcdir)/ldns/rr.h $(srcdir)/ldns/dname.h $(srcdir)/ldns/dnssec.h $(srcdir)/ldns/packet.h $(srcdir)/ldns/keys.h \ $(srcdir)/ldns/zone.h $(srcdir)/ldns/resolver.h $(srcdir)/ldns/tsig.h $(srcdir)/ldns/dnssec_zone.h $(srcdir)/ldns/rbtree.h \ $(srcdir)/ldns/host2str.h $(srcdir)/ldns/dnssec_verify.h $(srcdir)/ldns/dnssec_sign.h $(srcdir)/ldns/duration.h \ $(srcdir)/ldns/higher.h $(srcdir)/ldns/host2wire.h ldns/net.h $(srcdir)/ldns/str2host.h $(srcdir)/ldns/update.h \ $(srcdir)/ldns/wire2host.h $(srcdir)/ldns/rr_functions.h $(srcdir)/ldns/parse.h $(srcdir)/ldns/radix.h \ $(srcdir)/ldns/sha1.h $(srcdir)/ldns/sha2.h examples/ldns-verify-zone.lo examples/ldns-verify-zone.o: $(srcdir)/examples/ldns-verify-zone.c ldns/config.h $(srcdir)/ldns/ldns.h \ ldns/util.h ldns/common.h $(srcdir)/ldns/buffer.h $(srcdir)/ldns/error.h $(srcdir)/ldns/dane.h \ $(srcdir)/ldns/rdata.h $(srcdir)/ldns/rr.h $(srcdir)/ldns/dname.h $(srcdir)/ldns/dnssec.h $(srcdir)/ldns/packet.h \ $(srcdir)/ldns/keys.h $(srcdir)/ldns/zone.h $(srcdir)/ldns/resolver.h $(srcdir)/ldns/tsig.h $(srcdir)/ldns/dnssec_zone.h \ $(srcdir)/ldns/rbtree.h $(srcdir)/ldns/host2str.h $(srcdir)/ldns/dnssec_verify.h $(srcdir)/ldns/dnssec_sign.h \ $(srcdir)/ldns/duration.h $(srcdir)/ldns/higher.h $(srcdir)/ldns/host2wire.h ldns/net.h \ $(srcdir)/ldns/str2host.h $(srcdir)/ldns/update.h $(srcdir)/ldns/wire2host.h $(srcdir)/ldns/rr_functions.h \ $(srcdir)/ldns/parse.h $(srcdir)/ldns/radix.h $(srcdir)/ldns/sha1.h $(srcdir)/ldns/sha2.h examples/ldns-version.lo examples/ldns-version.o: $(srcdir)/examples/ldns-version.c ldns/config.h $(srcdir)/ldns/ldns.h ldns/util.h \ ldns/common.h $(srcdir)/ldns/buffer.h $(srcdir)/ldns/error.h $(srcdir)/ldns/dane.h $(srcdir)/ldns/rdata.h \ $(srcdir)/ldns/rr.h $(srcdir)/ldns/dname.h $(srcdir)/ldns/dnssec.h $(srcdir)/ldns/packet.h $(srcdir)/ldns/keys.h \ $(srcdir)/ldns/zone.h $(srcdir)/ldns/resolver.h $(srcdir)/ldns/tsig.h $(srcdir)/ldns/dnssec_zone.h $(srcdir)/ldns/rbtree.h \ $(srcdir)/ldns/host2str.h $(srcdir)/ldns/dnssec_verify.h $(srcdir)/ldns/dnssec_sign.h $(srcdir)/ldns/duration.h \ $(srcdir)/ldns/higher.h $(srcdir)/ldns/host2wire.h ldns/net.h $(srcdir)/ldns/str2host.h $(srcdir)/ldns/update.h \ $(srcdir)/ldns/wire2host.h $(srcdir)/ldns/rr_functions.h $(srcdir)/ldns/parse.h $(srcdir)/ldns/radix.h \ $(srcdir)/ldns/sha1.h $(srcdir)/ldns/sha2.h examples/ldns-walk.lo examples/ldns-walk.o: $(srcdir)/examples/ldns-walk.c ldns/config.h $(srcdir)/ldns/ldns.h ldns/util.h \ ldns/common.h $(srcdir)/ldns/buffer.h $(srcdir)/ldns/error.h $(srcdir)/ldns/dane.h $(srcdir)/ldns/rdata.h \ $(srcdir)/ldns/rr.h $(srcdir)/ldns/dname.h $(srcdir)/ldns/dnssec.h $(srcdir)/ldns/packet.h $(srcdir)/ldns/keys.h \ $(srcdir)/ldns/zone.h $(srcdir)/ldns/resolver.h $(srcdir)/ldns/tsig.h $(srcdir)/ldns/dnssec_zone.h $(srcdir)/ldns/rbtree.h \ $(srcdir)/ldns/host2str.h $(srcdir)/ldns/dnssec_verify.h $(srcdir)/ldns/dnssec_sign.h $(srcdir)/ldns/duration.h \ $(srcdir)/ldns/higher.h $(srcdir)/ldns/host2wire.h ldns/net.h $(srcdir)/ldns/str2host.h $(srcdir)/ldns/update.h \ $(srcdir)/ldns/wire2host.h $(srcdir)/ldns/rr_functions.h $(srcdir)/ldns/parse.h $(srcdir)/ldns/radix.h \ $(srcdir)/ldns/sha1.h $(srcdir)/ldns/sha2.h examples/ldns-zcat.lo examples/ldns-zcat.o: $(srcdir)/examples/ldns-zcat.c ldns/config.h $(srcdir)/ldns/ldns.h ldns/util.h \ ldns/common.h $(srcdir)/ldns/buffer.h $(srcdir)/ldns/error.h $(srcdir)/ldns/dane.h $(srcdir)/ldns/rdata.h \ $(srcdir)/ldns/rr.h $(srcdir)/ldns/dname.h $(srcdir)/ldns/dnssec.h $(srcdir)/ldns/packet.h $(srcdir)/ldns/keys.h \ $(srcdir)/ldns/zone.h $(srcdir)/ldns/resolver.h $(srcdir)/ldns/tsig.h $(srcdir)/ldns/dnssec_zone.h $(srcdir)/ldns/rbtree.h \ $(srcdir)/ldns/host2str.h $(srcdir)/ldns/dnssec_verify.h $(srcdir)/ldns/dnssec_sign.h $(srcdir)/ldns/duration.h \ $(srcdir)/ldns/higher.h $(srcdir)/ldns/host2wire.h ldns/net.h $(srcdir)/ldns/str2host.h $(srcdir)/ldns/update.h \ $(srcdir)/ldns/wire2host.h $(srcdir)/ldns/rr_functions.h $(srcdir)/ldns/parse.h $(srcdir)/ldns/radix.h \ $(srcdir)/ldns/sha1.h $(srcdir)/ldns/sha2.h examples/ldns-zsplit.lo examples/ldns-zsplit.o: $(srcdir)/examples/ldns-zsplit.c ldns/config.h $(srcdir)/ldns/ldns.h ldns/util.h \ ldns/common.h $(srcdir)/ldns/buffer.h $(srcdir)/ldns/error.h $(srcdir)/ldns/dane.h $(srcdir)/ldns/rdata.h \ $(srcdir)/ldns/rr.h $(srcdir)/ldns/dname.h $(srcdir)/ldns/dnssec.h $(srcdir)/ldns/packet.h $(srcdir)/ldns/keys.h \ $(srcdir)/ldns/zone.h $(srcdir)/ldns/resolver.h $(srcdir)/ldns/tsig.h $(srcdir)/ldns/dnssec_zone.h $(srcdir)/ldns/rbtree.h \ $(srcdir)/ldns/host2str.h $(srcdir)/ldns/dnssec_verify.h $(srcdir)/ldns/dnssec_sign.h $(srcdir)/ldns/duration.h \ $(srcdir)/ldns/higher.h $(srcdir)/ldns/host2wire.h ldns/net.h $(srcdir)/ldns/str2host.h $(srcdir)/ldns/update.h \ $(srcdir)/ldns/wire2host.h $(srcdir)/ldns/rr_functions.h $(srcdir)/ldns/parse.h $(srcdir)/ldns/radix.h \ $(srcdir)/ldns/sha1.h $(srcdir)/ldns/sha2.h drill/chasetrace.lo drill/chasetrace.o: $(srcdir)/drill/chasetrace.c $(srcdir)/drill/drill.h ldns/config.h \ $(srcdir)/drill/drill_util.h $(srcdir)/ldns/ldns.h ldns/util.h ldns/common.h $(srcdir)/ldns/buffer.h \ $(srcdir)/ldns/error.h $(srcdir)/ldns/dane.h $(srcdir)/ldns/rdata.h $(srcdir)/ldns/rr.h $(srcdir)/ldns/dname.h \ $(srcdir)/ldns/dnssec.h $(srcdir)/ldns/packet.h $(srcdir)/ldns/keys.h $(srcdir)/ldns/zone.h $(srcdir)/ldns/resolver.h \ $(srcdir)/ldns/tsig.h $(srcdir)/ldns/dnssec_zone.h $(srcdir)/ldns/rbtree.h $(srcdir)/ldns/host2str.h \ $(srcdir)/ldns/dnssec_verify.h $(srcdir)/ldns/dnssec_sign.h $(srcdir)/ldns/duration.h $(srcdir)/ldns/higher.h \ $(srcdir)/ldns/host2wire.h ldns/net.h $(srcdir)/ldns/str2host.h $(srcdir)/ldns/update.h \ $(srcdir)/ldns/wire2host.h $(srcdir)/ldns/rr_functions.h $(srcdir)/ldns/parse.h $(srcdir)/ldns/radix.h \ $(srcdir)/ldns/sha1.h $(srcdir)/ldns/sha2.h drill/dnssec.lo drill/dnssec.o: $(srcdir)/drill/dnssec.c $(srcdir)/drill/drill.h ldns/config.h $(srcdir)/drill/drill_util.h \ $(srcdir)/ldns/ldns.h ldns/util.h ldns/common.h $(srcdir)/ldns/buffer.h $(srcdir)/ldns/error.h \ $(srcdir)/ldns/dane.h $(srcdir)/ldns/rdata.h $(srcdir)/ldns/rr.h $(srcdir)/ldns/dname.h $(srcdir)/ldns/dnssec.h \ $(srcdir)/ldns/packet.h $(srcdir)/ldns/keys.h $(srcdir)/ldns/zone.h $(srcdir)/ldns/resolver.h $(srcdir)/ldns/tsig.h \ $(srcdir)/ldns/dnssec_zone.h $(srcdir)/ldns/rbtree.h $(srcdir)/ldns/host2str.h $(srcdir)/ldns/dnssec_verify.h \ $(srcdir)/ldns/dnssec_sign.h $(srcdir)/ldns/duration.h $(srcdir)/ldns/higher.h $(srcdir)/ldns/host2wire.h \ ldns/net.h $(srcdir)/ldns/str2host.h $(srcdir)/ldns/update.h $(srcdir)/ldns/wire2host.h \ $(srcdir)/ldns/rr_functions.h $(srcdir)/ldns/parse.h $(srcdir)/ldns/radix.h $(srcdir)/ldns/sha1.h $(srcdir)/ldns/sha2.h drill/drill.lo drill/drill.o: $(srcdir)/drill/drill.c $(srcdir)/drill/drill.h ldns/config.h $(srcdir)/drill/drill_util.h \ $(srcdir)/ldns/ldns.h ldns/util.h ldns/common.h $(srcdir)/ldns/buffer.h $(srcdir)/ldns/error.h \ $(srcdir)/ldns/dane.h $(srcdir)/ldns/rdata.h $(srcdir)/ldns/rr.h $(srcdir)/ldns/dname.h $(srcdir)/ldns/dnssec.h \ $(srcdir)/ldns/packet.h $(srcdir)/ldns/keys.h $(srcdir)/ldns/zone.h $(srcdir)/ldns/resolver.h $(srcdir)/ldns/tsig.h \ $(srcdir)/ldns/dnssec_zone.h $(srcdir)/ldns/rbtree.h $(srcdir)/ldns/host2str.h $(srcdir)/ldns/dnssec_verify.h \ $(srcdir)/ldns/dnssec_sign.h $(srcdir)/ldns/duration.h $(srcdir)/ldns/higher.h $(srcdir)/ldns/host2wire.h \ ldns/net.h $(srcdir)/ldns/str2host.h $(srcdir)/ldns/update.h $(srcdir)/ldns/wire2host.h \ $(srcdir)/ldns/rr_functions.h $(srcdir)/ldns/parse.h $(srcdir)/ldns/radix.h $(srcdir)/ldns/sha1.h $(srcdir)/ldns/sha2.h drill/drill_util.lo drill/drill_util.o: $(srcdir)/drill/drill_util.c $(srcdir)/drill/drill.h ldns/config.h \ $(srcdir)/drill/drill_util.h $(srcdir)/ldns/ldns.h ldns/util.h ldns/common.h $(srcdir)/ldns/buffer.h \ $(srcdir)/ldns/error.h $(srcdir)/ldns/dane.h $(srcdir)/ldns/rdata.h $(srcdir)/ldns/rr.h $(srcdir)/ldns/dname.h \ $(srcdir)/ldns/dnssec.h $(srcdir)/ldns/packet.h $(srcdir)/ldns/keys.h $(srcdir)/ldns/zone.h $(srcdir)/ldns/resolver.h \ $(srcdir)/ldns/tsig.h $(srcdir)/ldns/dnssec_zone.h $(srcdir)/ldns/rbtree.h $(srcdir)/ldns/host2str.h \ $(srcdir)/ldns/dnssec_verify.h $(srcdir)/ldns/dnssec_sign.h $(srcdir)/ldns/duration.h $(srcdir)/ldns/higher.h \ $(srcdir)/ldns/host2wire.h ldns/net.h $(srcdir)/ldns/str2host.h $(srcdir)/ldns/update.h \ $(srcdir)/ldns/wire2host.h $(srcdir)/ldns/rr_functions.h $(srcdir)/ldns/parse.h $(srcdir)/ldns/radix.h \ $(srcdir)/ldns/sha1.h $(srcdir)/ldns/sha2.h drill/error.lo drill/error.o: $(srcdir)/drill/error.c $(srcdir)/drill/drill.h ldns/config.h $(srcdir)/drill/drill_util.h \ $(srcdir)/ldns/ldns.h ldns/util.h ldns/common.h $(srcdir)/ldns/buffer.h $(srcdir)/ldns/error.h \ $(srcdir)/ldns/dane.h $(srcdir)/ldns/rdata.h $(srcdir)/ldns/rr.h $(srcdir)/ldns/dname.h $(srcdir)/ldns/dnssec.h \ $(srcdir)/ldns/packet.h $(srcdir)/ldns/keys.h $(srcdir)/ldns/zone.h $(srcdir)/ldns/resolver.h $(srcdir)/ldns/tsig.h \ $(srcdir)/ldns/dnssec_zone.h $(srcdir)/ldns/rbtree.h $(srcdir)/ldns/host2str.h $(srcdir)/ldns/dnssec_verify.h \ $(srcdir)/ldns/dnssec_sign.h $(srcdir)/ldns/duration.h $(srcdir)/ldns/higher.h $(srcdir)/ldns/host2wire.h \ ldns/net.h $(srcdir)/ldns/str2host.h $(srcdir)/ldns/update.h $(srcdir)/ldns/wire2host.h \ $(srcdir)/ldns/rr_functions.h $(srcdir)/ldns/parse.h $(srcdir)/ldns/radix.h $(srcdir)/ldns/sha1.h $(srcdir)/ldns/sha2.h drill/root.lo drill/root.o: $(srcdir)/drill/root.c $(srcdir)/drill/drill.h ldns/config.h $(srcdir)/drill/drill_util.h \ $(srcdir)/ldns/ldns.h ldns/util.h ldns/common.h $(srcdir)/ldns/buffer.h $(srcdir)/ldns/error.h \ $(srcdir)/ldns/dane.h $(srcdir)/ldns/rdata.h $(srcdir)/ldns/rr.h $(srcdir)/ldns/dname.h $(srcdir)/ldns/dnssec.h \ $(srcdir)/ldns/packet.h $(srcdir)/ldns/keys.h $(srcdir)/ldns/zone.h $(srcdir)/ldns/resolver.h $(srcdir)/ldns/tsig.h \ $(srcdir)/ldns/dnssec_zone.h $(srcdir)/ldns/rbtree.h $(srcdir)/ldns/host2str.h $(srcdir)/ldns/dnssec_verify.h \ $(srcdir)/ldns/dnssec_sign.h $(srcdir)/ldns/duration.h $(srcdir)/ldns/higher.h $(srcdir)/ldns/host2wire.h \ ldns/net.h $(srcdir)/ldns/str2host.h $(srcdir)/ldns/update.h $(srcdir)/ldns/wire2host.h \ $(srcdir)/ldns/rr_functions.h $(srcdir)/ldns/parse.h $(srcdir)/ldns/radix.h $(srcdir)/ldns/sha1.h $(srcdir)/ldns/sha2.h drill/securetrace.lo drill/securetrace.o: $(srcdir)/drill/securetrace.c $(srcdir)/drill/drill.h ldns/config.h \ $(srcdir)/drill/drill_util.h $(srcdir)/ldns/ldns.h ldns/util.h ldns/common.h $(srcdir)/ldns/buffer.h \ $(srcdir)/ldns/error.h $(srcdir)/ldns/dane.h $(srcdir)/ldns/rdata.h $(srcdir)/ldns/rr.h $(srcdir)/ldns/dname.h \ $(srcdir)/ldns/dnssec.h $(srcdir)/ldns/packet.h $(srcdir)/ldns/keys.h $(srcdir)/ldns/zone.h $(srcdir)/ldns/resolver.h \ $(srcdir)/ldns/tsig.h $(srcdir)/ldns/dnssec_zone.h $(srcdir)/ldns/rbtree.h $(srcdir)/ldns/host2str.h \ $(srcdir)/ldns/dnssec_verify.h $(srcdir)/ldns/dnssec_sign.h $(srcdir)/ldns/duration.h $(srcdir)/ldns/higher.h \ $(srcdir)/ldns/host2wire.h ldns/net.h $(srcdir)/ldns/str2host.h $(srcdir)/ldns/update.h \ $(srcdir)/ldns/wire2host.h $(srcdir)/ldns/rr_functions.h $(srcdir)/ldns/parse.h $(srcdir)/ldns/radix.h \ $(srcdir)/ldns/sha1.h $(srcdir)/ldns/sha2.h drill/work.lo drill/work.o: $(srcdir)/drill/work.c $(srcdir)/drill/drill.h ldns/config.h $(srcdir)/drill/drill_util.h \ $(srcdir)/ldns/ldns.h ldns/util.h ldns/common.h $(srcdir)/ldns/buffer.h $(srcdir)/ldns/error.h \ $(srcdir)/ldns/dane.h $(srcdir)/ldns/rdata.h $(srcdir)/ldns/rr.h $(srcdir)/ldns/dname.h $(srcdir)/ldns/dnssec.h \ $(srcdir)/ldns/packet.h $(srcdir)/ldns/keys.h $(srcdir)/ldns/zone.h $(srcdir)/ldns/resolver.h $(srcdir)/ldns/tsig.h \ $(srcdir)/ldns/dnssec_zone.h $(srcdir)/ldns/rbtree.h $(srcdir)/ldns/host2str.h $(srcdir)/ldns/dnssec_verify.h \ $(srcdir)/ldns/dnssec_sign.h $(srcdir)/ldns/duration.h $(srcdir)/ldns/higher.h $(srcdir)/ldns/host2wire.h \ ldns/net.h $(srcdir)/ldns/str2host.h $(srcdir)/ldns/update.h $(srcdir)/ldns/wire2host.h \ $(srcdir)/ldns/rr_functions.h $(srcdir)/ldns/parse.h $(srcdir)/ldns/radix.h $(srcdir)/ldns/sha1.h $(srcdir)/ldns/sha2.h examples/ldns-chaos: examples/ldns-chaos.lo examples/ldns-chaos.o $(LIB) examples/ldns-compare-zones: examples/ldns-compare-zones.lo examples/ldns-compare-zones.o $(LIB) examples/ldnsd: examples/ldnsd.lo examples/ldnsd.o $(LIB) examples/ldns-gen-zone: examples/ldns-gen-zone.lo examples/ldns-gen-zone.o $(LIB) examples/ldns-key2ds: examples/ldns-key2ds.lo examples/ldns-key2ds.o $(LIB) examples/ldns-keyfetcher: examples/ldns-keyfetcher.lo examples/ldns-keyfetcher.o $(LIB) examples/ldns-keygen: examples/ldns-keygen.lo examples/ldns-keygen.o $(LIB) examples/ldns-mx: examples/ldns-mx.lo examples/ldns-mx.o $(LIB) examples/ldns-notify: examples/ldns-notify.lo examples/ldns-notify.o $(LIB) examples/ldns-read-zone: examples/ldns-read-zone.lo examples/ldns-read-zone.o $(LIB) examples/ldns-resolver: examples/ldns-resolver.lo examples/ldns-resolver.o $(LIB) examples/ldns-rrsig: examples/ldns-rrsig.lo examples/ldns-rrsig.o $(LIB) examples/ldns-test-edns: examples/ldns-test-edns.lo examples/ldns-test-edns.o $(LIB) examples/ldns-update: examples/ldns-update.lo examples/ldns-update.o $(LIB) examples/ldns-version: examples/ldns-version.lo examples/ldns-version.o $(LIB) examples/ldns-walk: examples/ldns-walk.lo examples/ldns-walk.o $(LIB) examples/ldns-zcat: examples/ldns-zcat.lo examples/ldns-zcat.o $(LIB) examples/ldns-zsplit: examples/ldns-zsplit.lo examples/ldns-zsplit.o $(LIB) examples/ldns-dpa: examples/ldns-dpa.lo examples/ldns-dpa.o $(LIB) examples/ldns-dane: examples/ldns-dane.lo examples/ldns-dane.o $(LIB) examples/ldns-nsec3-hash: examples/ldns-nsec3-hash.lo examples/ldns-nsec3-hash.o $(LIB) examples/ldns-revoke: examples/ldns-revoke.lo examples/ldns-revoke.o $(LIB) examples/ldns-signzone: examples/ldns-signzone.lo examples/ldns-signzone.o $(LIB) examples/ldns-verify-zone: examples/ldns-verify-zone.lo examples/ldns-verify-zone.o $(LIB) examples/ldns-testns: examples/ldns-testns.lo examples/ldns-testns.o examples/ldns-testpkts.lo examples/ldns-testpkts.o $(LIB) ldns-1.6.17/str2host.c0000664000175100017510000011057612264060151014061 0ustar willemwillem/* * str2host.c * * conversion routines from the presentation format * to the host format * * a Net::DNS like library for C * * (c) NLnet Labs, 2004-2006 * * See the file LICENSE for the license */ #include #include #ifdef HAVE_SYS_SOCKET_H #include #endif #ifdef HAVE_ARPA_INET_H #include #endif #include #include #ifdef HAVE_NETDB_H #include #endif #include #ifdef HAVE_SYS_PARAM_H #include #endif ldns_status ldns_str2rdf_int16(ldns_rdf **rd, const char *shortstr) { char *end = NULL; uint16_t *r; r = LDNS_MALLOC(uint16_t); if(!r) return LDNS_STATUS_MEM_ERR; *r = htons((uint16_t)strtol((char *)shortstr, &end, 10)); if(*end != 0) { LDNS_FREE(r); return LDNS_STATUS_INVALID_INT; } else { *rd = ldns_rdf_new_frm_data( LDNS_RDF_TYPE_INT16, sizeof(uint16_t), r); LDNS_FREE(r); return *rd?LDNS_STATUS_OK:LDNS_STATUS_MEM_ERR; } } ldns_status ldns_str2rdf_time(ldns_rdf **rd, const char *time) { /* convert a time YYYYDDMMHHMMSS to wireformat */ uint16_t *r = NULL; struct tm tm; uint32_t l; char *end; /* Try to scan the time... */ r = (uint16_t*)LDNS_MALLOC(uint32_t); if(!r) return LDNS_STATUS_MEM_ERR; memset(&tm, 0, sizeof(tm)); if (strlen(time) == 14 && sscanf(time, "%4d%2d%2d%2d%2d%2d", &tm.tm_year, &tm.tm_mon, &tm.tm_mday, &tm.tm_hour, &tm.tm_min, &tm.tm_sec) == 6 ) { tm.tm_year -= 1900; tm.tm_mon--; /* Check values */ if (tm.tm_year < 70) { goto bad_format; } if (tm.tm_mon < 0 || tm.tm_mon > 11) { goto bad_format; } if (tm.tm_mday < 1 || tm.tm_mday > 31) { goto bad_format; } if (tm.tm_hour < 0 || tm.tm_hour > 23) { goto bad_format; } if (tm.tm_min < 0 || tm.tm_min > 59) { goto bad_format; } if (tm.tm_sec < 0 || tm.tm_sec > 59) { goto bad_format; } l = htonl(ldns_mktime_from_utc(&tm)); memcpy(r, &l, sizeof(uint32_t)); *rd = ldns_rdf_new_frm_data( LDNS_RDF_TYPE_TIME, sizeof(uint32_t), r); LDNS_FREE(r); return *rd?LDNS_STATUS_OK:LDNS_STATUS_MEM_ERR; } else { /* handle it as 32 bits timestamp */ l = htonl((uint32_t)strtol((char*)time, &end, 10)); if(*end != 0) { LDNS_FREE(r); return LDNS_STATUS_ERR; } else { memcpy(r, &l, sizeof(uint32_t)); *rd = ldns_rdf_new_frm_data( LDNS_RDF_TYPE_INT32, sizeof(uint32_t), r); LDNS_FREE(r); return *rd?LDNS_STATUS_OK:LDNS_STATUS_MEM_ERR; } } bad_format: LDNS_FREE(r); return LDNS_STATUS_INVALID_TIME; } ldns_status ldns_str2rdf_nsec3_salt(ldns_rdf **rd, const char *salt_str) { uint8_t salt_length; int c; int salt_length_str; uint8_t *salt; uint8_t *data; if(rd == NULL) { return LDNS_STATUS_NULL; } salt_length_str = (int)strlen(salt_str); if (salt_length_str == 1 && salt_str[0] == '-') { salt_length_str = 0; } else if (salt_length_str % 2 != 0) { return LDNS_STATUS_INVALID_HEX; } if (salt_length_str > 512) { return LDNS_STATUS_INVALID_HEX; } salt = LDNS_XMALLOC(uint8_t, salt_length_str / 2); if(!salt) { return LDNS_STATUS_MEM_ERR; } for (c = 0; c < salt_length_str; c += 2) { if (isxdigit((int) salt_str[c]) && isxdigit((int) salt_str[c+1])) { salt[c/2] = (uint8_t) ldns_hexdigit_to_int(salt_str[c]) * 16 + ldns_hexdigit_to_int(salt_str[c+1]); } else { LDNS_FREE(salt); return LDNS_STATUS_INVALID_HEX; } } salt_length = (uint8_t) (salt_length_str / 2); data = LDNS_XMALLOC(uint8_t, 1 + salt_length); if(!data) { LDNS_FREE(salt); return LDNS_STATUS_MEM_ERR; } data[0] = salt_length; memcpy(&data[1], salt, salt_length); *rd = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_NSEC3_SALT, 1 + salt_length, data); LDNS_FREE(data); LDNS_FREE(salt); return *rd?LDNS_STATUS_OK:LDNS_STATUS_MEM_ERR; } ldns_status ldns_str2rdf_period(ldns_rdf **rd,const char *period) { uint32_t p; const char *end; /* Allocate required space... */ p = ldns_str2period(period, &end); if (*end != 0) { return LDNS_STATUS_ERR; } else { p = (uint32_t) htonl(p); *rd = ldns_rdf_new_frm_data( LDNS_RDF_TYPE_PERIOD, sizeof(uint32_t), &p); } return *rd?LDNS_STATUS_OK:LDNS_STATUS_MEM_ERR; } ldns_status ldns_str2rdf_int32(ldns_rdf **rd, const char *longstr) { char *end; uint16_t *r = NULL; uint32_t l; r = (uint16_t*)LDNS_MALLOC(uint32_t); if(!r) return LDNS_STATUS_MEM_ERR; errno = 0; /* must set to zero before call, note race condition on errno */ if(*longstr == '-') l = htonl((uint32_t)strtol((char*)longstr, &end, 10)); else l = htonl((uint32_t)strtoul((char*)longstr, &end, 10)); if(*end != 0) { LDNS_FREE(r); return LDNS_STATUS_ERR; } else { if (errno == ERANGE) { LDNS_FREE(r); return LDNS_STATUS_SYNTAX_INTEGER_OVERFLOW; } memcpy(r, &l, sizeof(uint32_t)); *rd = ldns_rdf_new_frm_data( LDNS_RDF_TYPE_INT32, sizeof(uint32_t), r); LDNS_FREE(r); return *rd?LDNS_STATUS_OK:LDNS_STATUS_MEM_ERR; } } ldns_status ldns_str2rdf_int8(ldns_rdf **rd, const char *bytestr) { char *end; uint8_t *r = NULL; r = LDNS_MALLOC(uint8_t); if(!r) return LDNS_STATUS_MEM_ERR; *r = (uint8_t)strtol((char*)bytestr, &end, 10); if(*end != 0) { LDNS_FREE(r); return LDNS_STATUS_ERR; } else { *rd = ldns_rdf_new_frm_data( LDNS_RDF_TYPE_INT8, sizeof(uint8_t), r); LDNS_FREE(r); return *rd?LDNS_STATUS_OK:LDNS_STATUS_MEM_ERR; } } /* * Checks whether the escaped value at **s is an octal value or * a 'normally' escaped character (and not eos) * * The string pointer at *s is increased by either 0 (on error), 1 (on * normal escapes), or 3 (on octals) * * Returns the number of bytes read from the escaped string, or * 0 on error */ INLINE bool parse_escape(uint8_t *ch_p, const char** str_p) { uint16_t val; if ((*str_p)[0] && isdigit((*str_p)[0]) && (*str_p)[1] && isdigit((*str_p)[1]) && (*str_p)[2] && isdigit((*str_p)[2])) { val = (uint16_t)(((*str_p)[0] - '0') * 100 + ((*str_p)[1] - '0') * 10 + ((*str_p)[2] - '0')); if (val > 255) { goto error; } *ch_p = (uint8_t)val; *str_p += 3; return true; } else if ((*str_p)[0] && !isdigit((*str_p)[0])) { *ch_p = (uint8_t)*(*str_p)++; return true; } error: *str_p = NULL; return false; /* LDNS_STATUS_SYNTAX_BAD_ESCAPE */ } INLINE bool parse_char(uint8_t *ch_p, const char** str_p) { switch (**str_p) { case '\0': return false; case '\\': *str_p += 1; return parse_escape(ch_p, str_p); default: *ch_p = (uint8_t)*(*str_p)++; return true; } } /* * No special care is taken, all dots are translated into * label seperators. * Could be made more efficient....we do 3 memcpy's in total... */ ldns_status ldns_str2rdf_dname(ldns_rdf **d, const char *str) { size_t len; const char *s; uint8_t *q, *pq, label_len; uint8_t buf[LDNS_MAX_DOMAINLEN + 1]; *d = NULL; len = strlen((char*)str); /* octet representation can make strings a lot longer than actual length */ if (len > LDNS_MAX_DOMAINLEN * 4) { return LDNS_STATUS_DOMAINNAME_OVERFLOW; } if (0 == len) { return LDNS_STATUS_DOMAINNAME_UNDERFLOW; } /* root label */ if (1 == len && *str == '.') { *d = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_DNAME, 1, "\0"); return LDNS_STATUS_OK; } /* get on with the rest */ /* s is on the current character in the string * pq points to where the labellength is going to go * label_len keeps track of the current label's length * q builds the dname inside the buf array */ len = 0; q = buf+1; pq = buf; label_len = 0; for (s = str; *s; s++, q++) { if (q > buf + LDNS_MAX_DOMAINLEN) { return LDNS_STATUS_DOMAINNAME_OVERFLOW; } *q = 0; switch (*s) { case '.': if (label_len > LDNS_MAX_LABELLEN) { return LDNS_STATUS_LABEL_OVERFLOW; } if (label_len == 0) { return LDNS_STATUS_EMPTY_LABEL; } len += label_len + 1; *pq = label_len; label_len = 0; pq = q; break; case '\\': /* octet value or literal char */ s += 1; if (! parse_escape(q, &s)) { return LDNS_STATUS_SYNTAX_BAD_ESCAPE; } s -= 1; label_len++; break; default: *q = (uint8_t)*s; label_len++; } } /* add root label if last char was not '.' */ if (!ldns_dname_str_absolute(str)) { if (q > buf + LDNS_MAX_DOMAINLEN) { return LDNS_STATUS_DOMAINNAME_OVERFLOW; } if (label_len > LDNS_MAX_LABELLEN) { return LDNS_STATUS_LABEL_OVERFLOW; } if (label_len == 0) { /* label_len 0 but not . at end? */ return LDNS_STATUS_EMPTY_LABEL; } len += label_len + 1; *pq = label_len; *q = 0; } len++; *d = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_DNAME, len, buf); return LDNS_STATUS_OK; } ldns_status ldns_str2rdf_a(ldns_rdf **rd, const char *str) { in_addr_t address; if (inet_pton(AF_INET, (char*)str, &address) != 1) { return LDNS_STATUS_INVALID_IP4; } else { *rd = ldns_rdf_new_frm_data( LDNS_RDF_TYPE_A, sizeof(address), &address); } return *rd?LDNS_STATUS_OK:LDNS_STATUS_MEM_ERR; } ldns_status ldns_str2rdf_aaaa(ldns_rdf **rd, const char *str) { uint8_t address[LDNS_IP6ADDRLEN + 1]; if (inet_pton(AF_INET6, (char*)str, address) != 1) { return LDNS_STATUS_INVALID_IP6; } else { *rd = ldns_rdf_new_frm_data( LDNS_RDF_TYPE_AAAA, sizeof(address) - 1, &address); } return *rd?LDNS_STATUS_OK:LDNS_STATUS_MEM_ERR; } ldns_status ldns_str2rdf_str(ldns_rdf **rd, const char *str) { uint8_t *data, *dp, ch = 0; size_t length; /* Worst case space requirement. We'll realloc to actual size later. */ dp = data = LDNS_XMALLOC(uint8_t, strlen(str) > 255 ? 256 : (strlen(str) + 1)); if (! data) { return LDNS_STATUS_MEM_ERR; } /* Fill data (up to 255 characters) */ while (parse_char(&ch, &str)) { if (dp - data >= 255) { LDNS_FREE(data); return LDNS_STATUS_INVALID_STR; } *++dp = ch; } if (! str) { return LDNS_STATUS_SYNTAX_BAD_ESCAPE; } length = (size_t)(dp - data); /* Fix last length byte */ data[0] = (uint8_t)length; /* Lose the overmeasure */ data = LDNS_XREALLOC(dp = data, uint8_t, length + 1); if (! data) { LDNS_FREE(dp); return LDNS_STATUS_MEM_ERR; } /* Create rdf */ *rd = ldns_rdf_new(LDNS_RDF_TYPE_STR, length + 1, data); if (! *rd) { LDNS_FREE(data); return LDNS_STATUS_MEM_ERR; } return LDNS_STATUS_OK; } ldns_status ldns_str2rdf_apl(ldns_rdf **rd, const char *str) { const char *my_str = str; char *my_ip_str; size_t ip_str_len; uint16_t family; bool negation; uint8_t afdlength = 0; uint8_t *afdpart; uint8_t prefix; uint8_t *data; size_t i = 0; /* [!]afi:address/prefix */ if (strlen(my_str) < 2 || strchr(my_str, ':') == NULL || strchr(my_str, '/') == NULL || strchr(my_str, ':') > strchr(my_str, '/')) { return LDNS_STATUS_INVALID_STR; } if (my_str[0] == '!') { negation = true; my_str += 1; } else { negation = false; } family = (uint16_t) atoi(my_str); my_str = strchr(my_str, ':') + 1; /* need ip addr and only ip addr for inet_pton */ ip_str_len = (size_t) (strchr(my_str, '/') - my_str); my_ip_str = LDNS_XMALLOC(char, ip_str_len + 1); if(!my_ip_str) return LDNS_STATUS_MEM_ERR; strncpy(my_ip_str, my_str, ip_str_len + 1); my_ip_str[ip_str_len] = '\0'; if (family == 1) { /* ipv4 */ afdpart = LDNS_XMALLOC(uint8_t, 4); if(!afdpart) { LDNS_FREE(my_ip_str); return LDNS_STATUS_MEM_ERR; } if (inet_pton(AF_INET, my_ip_str, afdpart) == 0) { LDNS_FREE(my_ip_str); LDNS_FREE(afdpart); return LDNS_STATUS_INVALID_STR; } for (i = 0; i < 4; i++) { if (afdpart[i] != 0) { afdlength = i + 1; } } } else if (family == 2) { /* ipv6 */ afdpart = LDNS_XMALLOC(uint8_t, 16); if(!afdpart) { LDNS_FREE(my_ip_str); return LDNS_STATUS_MEM_ERR; } if (inet_pton(AF_INET6, my_ip_str, afdpart) == 0) { LDNS_FREE(my_ip_str); LDNS_FREE(afdpart); return LDNS_STATUS_INVALID_STR; } for (i = 0; i < 16; i++) { if (afdpart[i] != 0) { afdlength = i + 1; } } } else { /* unknown family */ LDNS_FREE(my_ip_str); return LDNS_STATUS_INVALID_STR; } my_str = strchr(my_str, '/') + 1; prefix = (uint8_t) atoi(my_str); data = LDNS_XMALLOC(uint8_t, 4 + afdlength); if(!data) { LDNS_FREE(afdpart); LDNS_FREE(my_ip_str); return LDNS_STATUS_INVALID_STR; } ldns_write_uint16(data, family); data[2] = prefix; data[3] = afdlength; if (negation) { /* set bit 1 of byte 3 */ data[3] = data[3] | 0x80; } memcpy(data + 4, afdpart, afdlength); *rd = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_APL, afdlength + 4, data); LDNS_FREE(afdpart); LDNS_FREE(data); LDNS_FREE(my_ip_str); return *rd?LDNS_STATUS_OK:LDNS_STATUS_MEM_ERR; } ldns_status ldns_str2rdf_b64(ldns_rdf **rd, const char *str) { uint8_t *buffer; int16_t i; buffer = LDNS_XMALLOC(uint8_t, ldns_b64_ntop_calculate_size(strlen(str))); if(!buffer) { return LDNS_STATUS_MEM_ERR; } i = (uint16_t)ldns_b64_pton((const char*)str, buffer, ldns_b64_ntop_calculate_size(strlen(str))); if (-1 == i) { LDNS_FREE(buffer); return LDNS_STATUS_INVALID_B64; } else { *rd = ldns_rdf_new_frm_data( LDNS_RDF_TYPE_B64, (uint16_t) i, buffer); } LDNS_FREE(buffer); return *rd?LDNS_STATUS_OK:LDNS_STATUS_MEM_ERR; } ldns_status ldns_str2rdf_b32_ext(ldns_rdf **rd, const char *str) { uint8_t *buffer; int i; /* first byte contains length of actual b32 data */ uint8_t len = ldns_b32_pton_calculate_size(strlen(str)); buffer = LDNS_XMALLOC(uint8_t, len + 1); if(!buffer) { return LDNS_STATUS_MEM_ERR; } buffer[0] = len; i = ldns_b32_pton_extended_hex((const char*)str, strlen(str), buffer + 1, ldns_b32_ntop_calculate_size(strlen(str))); if (i < 0) { LDNS_FREE(buffer); return LDNS_STATUS_INVALID_B32_EXT; } else { *rd = ldns_rdf_new_frm_data( LDNS_RDF_TYPE_B32_EXT, (uint16_t) i + 1, buffer); } LDNS_FREE(buffer); return *rd?LDNS_STATUS_OK:LDNS_STATUS_MEM_ERR; } ldns_status ldns_str2rdf_hex(ldns_rdf **rd, const char *str) { uint8_t *t, *t_orig; int i; size_t len; len = strlen(str); if (len > LDNS_MAX_RDFLEN * 2) { return LDNS_STATUS_LABEL_OVERFLOW; } else { t = LDNS_XMALLOC(uint8_t, (len / 2) + 1); if(!t) { return LDNS_STATUS_MEM_ERR; } t_orig = t; /* Now process octet by octet... */ while (*str) { *t = 0; if (isspace((int) *str)) { str++; } else { for (i = 16; i >= 1; i -= 15) { while (*str && isspace((int) *str)) { str++; } if (*str) { if (isxdigit((int) *str)) { *t += ldns_hexdigit_to_int(*str) * i; } else { LDNS_FREE(t_orig); return LDNS_STATUS_ERR; } ++str; } } ++t; } } *rd = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_HEX, (size_t) (t - t_orig), t_orig); LDNS_FREE(t_orig); } return *rd?LDNS_STATUS_OK:LDNS_STATUS_MEM_ERR; } ldns_status ldns_str2rdf_nsec(ldns_rdf **rd, const char *str) { const char *delimiters = "\n\t "; char *token = LDNS_XMALLOC(char, LDNS_MAX_RDFLEN); ldns_buffer *str_buf; ssize_t c; uint16_t cur_type; size_t type_count = 0; ldns_rr_type type_list[65536]; if(!token) return LDNS_STATUS_MEM_ERR; if(rd == NULL) { LDNS_FREE(token); return LDNS_STATUS_NULL; } str_buf = LDNS_MALLOC(ldns_buffer); if(!str_buf) { LDNS_FREE(token); return LDNS_STATUS_MEM_ERR; } ldns_buffer_new_frm_data(str_buf, (char *)str, strlen(str)); if(ldns_buffer_status(str_buf) != LDNS_STATUS_OK) { LDNS_FREE(str_buf); LDNS_FREE(token); return LDNS_STATUS_MEM_ERR; } while ((c = ldns_bget_token(str_buf, token, delimiters, LDNS_MAX_RDFLEN)) != -1 && c != 0) { if(type_count >= sizeof(type_list)) { LDNS_FREE(str_buf); LDNS_FREE(token); return LDNS_STATUS_ERR; } cur_type = ldns_get_rr_type_by_name(token); type_list[type_count] = cur_type; type_count++; } *rd = ldns_dnssec_create_nsec_bitmap(type_list, type_count, LDNS_RR_TYPE_NSEC); LDNS_FREE(token); ldns_buffer_free(str_buf); return *rd?LDNS_STATUS_OK:LDNS_STATUS_MEM_ERR; } ldns_status ldns_str2rdf_type(ldns_rdf **rd, const char *str) { uint16_t type; type = htons(ldns_get_rr_type_by_name(str)); /* ldns_rr_type is a 16 bit value */ *rd = ldns_rdf_new_frm_data( LDNS_RDF_TYPE_TYPE, sizeof(uint16_t), &type); return *rd?LDNS_STATUS_OK:LDNS_STATUS_MEM_ERR; } ldns_status ldns_str2rdf_class(ldns_rdf **rd, const char *str) { uint16_t klass; klass = htons(ldns_get_rr_class_by_name(str)); /* class is 16 bit */ *rd = ldns_rdf_new_frm_data( LDNS_RDF_TYPE_CLASS, sizeof(uint16_t), &klass); return *rd?LDNS_STATUS_OK:LDNS_STATUS_MEM_ERR; } /* An certificate alg field can either be specified as a 8 bits number * or by its symbolic name. Handle both */ ldns_status ldns_str2rdf_cert_alg(ldns_rdf **rd, const char *str) { ldns_lookup_table *lt; ldns_status st; uint8_t idd[2]; lt = ldns_lookup_by_name(ldns_cert_algorithms, str); st = LDNS_STATUS_OK; if (lt) { ldns_write_uint16(idd, (uint16_t) lt->id); *rd = ldns_rdf_new_frm_data( LDNS_RDF_TYPE_INT16, sizeof(uint16_t), idd); if (!*rd) { st = LDNS_STATUS_ERR; } } else { /* try as-is (a number) */ st = ldns_str2rdf_int16(rd, str); if (st == LDNS_STATUS_OK && ldns_rdf2native_int16(*rd) == 0) { st = LDNS_STATUS_CERT_BAD_ALGORITHM; } } return st; } /* An alg field can either be specified as a 8 bits number * or by its symbolic name. Handle both */ ldns_status ldns_str2rdf_alg(ldns_rdf **rd, const char *str) { ldns_lookup_table *lt; ldns_status st; lt = ldns_lookup_by_name(ldns_algorithms, str); st = LDNS_STATUS_OK; if (lt) { /* it was given as a integer */ *rd = ldns_native2rdf_int8(LDNS_RDF_TYPE_INT8, (uint8_t) lt->id); if (!*rd) { st = LDNS_STATUS_ERR; } } else { /* try as-is (a number) */ st = ldns_str2rdf_int8(rd, str); } return st; } ldns_status ldns_str2rdf_unknown( ATTR_UNUSED(ldns_rdf **rd) , ATTR_UNUSED(const char *str) ) { /* this should be caught in an earlier time (general str2host for rr's */ return LDNS_STATUS_NOT_IMPL; } ldns_status ldns_str2rdf_service( ATTR_UNUSED(ldns_rdf **rd) , ATTR_UNUSED(const char *str) ) { /* is this used? is this actually WKS? or SRV? */ return LDNS_STATUS_NOT_IMPL; } static int loc_parse_cm(char* my_str, char** endstr, uint8_t* m, uint8_t* e) { /* read [.][mM] */ /* into mantissa exponent format for LOC type */ uint32_t meters = 0, cm = 0, val; while (isblank(*my_str)) { my_str++; } meters = (uint32_t)strtol(my_str, &my_str, 10); if (*my_str == '.') { my_str++; cm = (uint32_t)strtol(my_str, &my_str, 10); } if (meters >= 1) { *e = 2; val = meters; } else { *e = 0; val = cm; } while(val >= 10) { (*e)++; val /= 10; } *m = (uint8_t)val; if (*e > 9) return 0; if (*my_str == 'm' || *my_str == 'M') { my_str++; } *endstr = my_str; return 1; } ldns_status ldns_str2rdf_loc(ldns_rdf **rd, const char *str) { uint32_t latitude = 0; uint32_t longitude = 0; uint32_t altitude = 0; uint8_t *data; uint32_t equator = (uint32_t) ldns_power(2, 31); uint32_t h = 0; uint32_t m = 0; uint8_t size_b = 1, size_e = 2; uint8_t horiz_pre_b = 1, horiz_pre_e = 6; uint8_t vert_pre_b = 1, vert_pre_e = 3; double s = 0.0; bool northerness; bool easterness; char *my_str = (char *) str; /* only support version 0 */ if (isdigit((int) *my_str)) { h = (uint32_t) strtol(my_str, &my_str, 10); } else { return LDNS_STATUS_INVALID_STR; } while (isblank((int) *my_str)) { my_str++; } if (isdigit((int) *my_str)) { m = (uint32_t) strtol(my_str, &my_str, 10); } else if (*my_str == 'N' || *my_str == 'S') { goto north; } else { return LDNS_STATUS_INVALID_STR; } while (isblank((int) *my_str)) { my_str++; } if (isdigit((int) *my_str)) { s = strtod(my_str, &my_str); } north: while (isblank((int) *my_str)) { my_str++; } if (*my_str == 'N') { northerness = true; } else if (*my_str == 'S') { northerness = false; } else { return LDNS_STATUS_INVALID_STR; } my_str++; /* store number */ s = 1000.0 * s; /* add a little to make floor in conversion a round */ s += 0.0005; latitude = (uint32_t) s; latitude += 1000 * 60 * m; latitude += 1000 * 60 * 60 * h; if (northerness) { latitude = equator + latitude; } else { latitude = equator - latitude; } while (isblank(*my_str)) { my_str++; } if (isdigit((int) *my_str)) { h = (uint32_t) strtol(my_str, &my_str, 10); } else { return LDNS_STATUS_INVALID_STR; } while (isblank((int) *my_str)) { my_str++; } if (isdigit((int) *my_str)) { m = (uint32_t) strtol(my_str, &my_str, 10); } else if (*my_str == 'E' || *my_str == 'W') { goto east; } else { return LDNS_STATUS_INVALID_STR; } while (isblank(*my_str)) { my_str++; } if (isdigit((int) *my_str)) { s = strtod(my_str, &my_str); } east: while (isblank(*my_str)) { my_str++; } if (*my_str == 'E') { easterness = true; } else if (*my_str == 'W') { easterness = false; } else { return LDNS_STATUS_INVALID_STR; } my_str++; /* store number */ s *= 1000.0; /* add a little to make floor in conversion a round */ s += 0.0005; longitude = (uint32_t) s; longitude += 1000 * 60 * m; longitude += 1000 * 60 * 60 * h; if (easterness) { longitude += equator; } else { longitude = equator - longitude; } altitude = (uint32_t)(strtod(my_str, &my_str)*100.0 + 10000000.0 + 0.5); if (*my_str == 'm' || *my_str == 'M') { my_str++; } if (strlen(my_str) > 0) { if(!loc_parse_cm(my_str, &my_str, &size_b, &size_e)) return LDNS_STATUS_INVALID_STR; } if (strlen(my_str) > 0) { if(!loc_parse_cm(my_str, &my_str, &horiz_pre_b, &horiz_pre_e)) return LDNS_STATUS_INVALID_STR; } if (strlen(my_str) > 0) { if(!loc_parse_cm(my_str, &my_str, &vert_pre_b, &vert_pre_e)) return LDNS_STATUS_INVALID_STR; } data = LDNS_XMALLOC(uint8_t, 16); if(!data) { return LDNS_STATUS_MEM_ERR; } data[0] = 0; data[1] = 0; data[1] = ((size_b << 4) & 0xf0) | (size_e & 0x0f); data[2] = ((horiz_pre_b << 4) & 0xf0) | (horiz_pre_e & 0x0f); data[3] = ((vert_pre_b << 4) & 0xf0) | (vert_pre_e & 0x0f); ldns_write_uint32(data + 4, latitude); ldns_write_uint32(data + 8, longitude); ldns_write_uint32(data + 12, altitude); *rd = ldns_rdf_new_frm_data( LDNS_RDF_TYPE_LOC, 16, data); LDNS_FREE(data); return *rd?LDNS_STATUS_OK:LDNS_STATUS_MEM_ERR; } ldns_status ldns_str2rdf_wks(ldns_rdf **rd, const char *str) { uint8_t *bitmap = NULL; uint8_t *data; int bm_len = 0; struct protoent *proto = NULL; struct servent *serv = NULL; int serv_port; ldns_buffer *str_buf; char *proto_str = NULL; char *token; if(strlen(str) == 0) token = LDNS_XMALLOC(char, 50); else token = LDNS_XMALLOC(char, strlen(str)+2); if(!token) return LDNS_STATUS_MEM_ERR; str_buf = LDNS_MALLOC(ldns_buffer); if(!str_buf) {LDNS_FREE(token); return LDNS_STATUS_MEM_ERR;} ldns_buffer_new_frm_data(str_buf, (char *)str, strlen(str)); if(ldns_buffer_status(str_buf) != LDNS_STATUS_OK) { LDNS_FREE(str_buf); LDNS_FREE(token); return LDNS_STATUS_MEM_ERR; } while(ldns_bget_token(str_buf, token, "\t\n ", strlen(str)) > 0) { if (!proto_str) { proto_str = strdup(token); if (!proto_str) { LDNS_FREE(bitmap); LDNS_FREE(token); ldns_buffer_free(str_buf); return LDNS_STATUS_INVALID_STR; } } else { serv = getservbyname(token, proto_str); if (serv) { serv_port = (int) ntohs((uint16_t) serv->s_port); } else { serv_port = atoi(token); } if (serv_port / 8 >= bm_len) { uint8_t *b2 = LDNS_XREALLOC(bitmap, uint8_t, (serv_port / 8) + 1); if(!b2) { LDNS_FREE(bitmap); LDNS_FREE(token); ldns_buffer_free(str_buf); free(proto_str); return LDNS_STATUS_INVALID_STR; } bitmap = b2; /* set to zero to be sure */ for (; bm_len <= serv_port / 8; bm_len++) { bitmap[bm_len] = 0; } } ldns_set_bit(bitmap + (serv_port / 8), 7 - (serv_port % 8), true); } } if (!proto_str || !bitmap) { LDNS_FREE(bitmap); LDNS_FREE(token); ldns_buffer_free(str_buf); free(proto_str); return LDNS_STATUS_INVALID_STR; } data = LDNS_XMALLOC(uint8_t, bm_len + 1); if(!data) { LDNS_FREE(token); ldns_buffer_free(str_buf); LDNS_FREE(bitmap); free(proto_str); return LDNS_STATUS_INVALID_STR; } if (proto_str) proto = getprotobyname(proto_str); if (proto) { data[0] = (uint8_t) proto->p_proto; } else if (proto_str) { data[0] = (uint8_t) atoi(proto_str); } memcpy(data + 1, bitmap, (size_t) bm_len); *rd = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_WKS, (uint16_t) (bm_len + 1), data); LDNS_FREE(data); LDNS_FREE(token); ldns_buffer_free(str_buf); LDNS_FREE(bitmap); free(proto_str); #ifdef HAVE_ENDSERVENT endservent(); #endif #ifdef HAVE_ENDPROTOENT endprotoent(); #endif if(!*rd) return LDNS_STATUS_MEM_ERR; return LDNS_STATUS_OK; } ldns_status ldns_str2rdf_nsap(ldns_rdf **rd, const char *str) { size_t len, i; char* nsap_str = (char*) str; /* just a hex string with optional dots? */ if (str[0] != '0' || str[1] != 'x') { return LDNS_STATUS_INVALID_STR; } else { len = strlen(str); for (i=0; i < len; i++) { if (nsap_str[i] == '.') nsap_str[i] = ' '; } return ldns_str2rdf_hex(rd, str+2); } } ldns_status ldns_str2rdf_atma(ldns_rdf **rd, const char *str) { size_t len, i; char* atma_str = (char*) str; ldns_status status; /* just a hex string with optional dots? */ len = strlen(str); for (i=0; i < len; i++) { if (atma_str[i] == '.') atma_str[i] = ' '; } status = ldns_str2rdf_hex(rd, str); if (status != LDNS_STATUS_OK) { ; /* probably in e.164 format than */ } return status; } ldns_status ldns_str2rdf_ipseckey(ldns_rdf **rd, const char *str) { uint8_t precedence = 0; uint8_t gateway_type = 0; uint8_t algorithm = 0; char* gateway = NULL; char* publickey = NULL; uint8_t *data; ldns_buffer *str_buf; char *token; int token_count = 0; int ipseckey_len = 0; ldns_rdf* gateway_rdf = NULL; ldns_rdf* publickey_rdf = NULL; ldns_status status = LDNS_STATUS_OK; if(strlen(str) == 0) token = LDNS_XMALLOC(char, 256); else token = LDNS_XMALLOC(char, strlen(str)+2); if(!token) return LDNS_STATUS_MEM_ERR; str_buf = LDNS_MALLOC(ldns_buffer); if(!str_buf) {LDNS_FREE(token); return LDNS_STATUS_MEM_ERR;} ldns_buffer_new_frm_data(str_buf, (char *)str, strlen(str)); if(ldns_buffer_status(str_buf) != LDNS_STATUS_OK) { LDNS_FREE(str_buf); LDNS_FREE(token); return LDNS_STATUS_MEM_ERR; } while(ldns_bget_token(str_buf, token, "\t\n ", strlen(str)) > 0) { switch (token_count) { case 0: precedence = (uint8_t)atoi(token); break; case 1: gateway_type = (uint8_t)atoi(token); break; case 2: algorithm = (uint8_t)atoi(token); break; case 3: gateway = strdup(token); if (!gateway || (gateway_type == 0 && (token[0] != '.' || token[1] != '\0'))) { LDNS_FREE(gateway); LDNS_FREE(token); ldns_buffer_free(str_buf); return LDNS_STATUS_INVALID_STR; } break; case 4: publickey = strdup(token); break; default: LDNS_FREE(token); ldns_buffer_free(str_buf); return LDNS_STATUS_INVALID_STR; break; } token_count++; } if (!gateway || !publickey) { if (gateway) LDNS_FREE(gateway); if (publickey) LDNS_FREE(publickey); LDNS_FREE(token); ldns_buffer_free(str_buf); return LDNS_STATUS_INVALID_STR; } if (gateway_type == 1) { status = ldns_str2rdf_a(&gateway_rdf, gateway); } else if (gateway_type == 2) { status = ldns_str2rdf_aaaa(&gateway_rdf, gateway); } else if (gateway_type == 3) { status = ldns_str2rdf_dname(&gateway_rdf, gateway); } if (status != LDNS_STATUS_OK) { if (gateway) LDNS_FREE(gateway); if (publickey) LDNS_FREE(publickey); LDNS_FREE(token); ldns_buffer_free(str_buf); return LDNS_STATUS_INVALID_STR; } status = ldns_str2rdf_b64(&publickey_rdf, publickey); if (status != LDNS_STATUS_OK) { if (gateway) LDNS_FREE(gateway); if (publickey) LDNS_FREE(publickey); LDNS_FREE(token); ldns_buffer_free(str_buf); if (gateway_rdf) ldns_rdf_free(gateway_rdf); return LDNS_STATUS_INVALID_STR; } /* now copy all into one ipseckey rdf */ if (gateway_type) ipseckey_len = 3 + (int)ldns_rdf_size(gateway_rdf) + (int)ldns_rdf_size(publickey_rdf); else ipseckey_len = 3 + (int)ldns_rdf_size(publickey_rdf); data = LDNS_XMALLOC(uint8_t, ipseckey_len); if(!data) { if (gateway) LDNS_FREE(gateway); if (publickey) LDNS_FREE(publickey); LDNS_FREE(token); ldns_buffer_free(str_buf); if (gateway_rdf) ldns_rdf_free(gateway_rdf); if (publickey_rdf) ldns_rdf_free(publickey_rdf); return LDNS_STATUS_MEM_ERR; } data[0] = precedence; data[1] = gateway_type; data[2] = algorithm; if (gateway_type) { memcpy(data + 3, ldns_rdf_data(gateway_rdf), ldns_rdf_size(gateway_rdf)); memcpy(data + 3 + ldns_rdf_size(gateway_rdf), ldns_rdf_data(publickey_rdf), ldns_rdf_size(publickey_rdf)); } else { memcpy(data + 3, ldns_rdf_data(publickey_rdf), ldns_rdf_size(publickey_rdf)); } *rd = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_IPSECKEY, (uint16_t) ipseckey_len, data); if (gateway) LDNS_FREE(gateway); if (publickey) LDNS_FREE(publickey); LDNS_FREE(token); ldns_buffer_free(str_buf); ldns_rdf_free(gateway_rdf); ldns_rdf_free(publickey_rdf); LDNS_FREE(data); if(!*rd) return LDNS_STATUS_MEM_ERR; return LDNS_STATUS_OK; } ldns_status ldns_str2rdf_ilnp64(ldns_rdf **rd, const char *str) { unsigned int a, b, c, d; uint16_t shorts[4]; int l; if (sscanf(str, "%4x:%4x:%4x:%4x%n", &a, &b, &c, &d, &l) != 4 || l != (int)strlen(str) || /* more data to read */ strpbrk(str, "+-") /* signed hexes */ ) { return LDNS_STATUS_INVALID_ILNP64; } else { shorts[0] = htons(a); shorts[1] = htons(b); shorts[2] = htons(c); shorts[3] = htons(d); *rd = ldns_rdf_new_frm_data( LDNS_RDF_TYPE_ILNP64, 4 * sizeof(uint16_t), &shorts); } return *rd ? LDNS_STATUS_OK : LDNS_STATUS_MEM_ERR; } ldns_status ldns_str2rdf_eui48(ldns_rdf **rd, const char *str) { unsigned int a, b, c, d, e, f; uint8_t bytes[6]; int l; if (sscanf(str, "%2x-%2x-%2x-%2x-%2x-%2x%n", &a, &b, &c, &d, &e, &f, &l) != 6 || l != (int)strlen(str) || /* more data to read */ strpbrk(str, "+-") /* signed hexes */ ) { return LDNS_STATUS_INVALID_EUI48; } else { bytes[0] = a; bytes[1] = b; bytes[2] = c; bytes[3] = d; bytes[4] = e; bytes[5] = f; *rd = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_EUI48, 6, &bytes); } return *rd ? LDNS_STATUS_OK : LDNS_STATUS_MEM_ERR; } ldns_status ldns_str2rdf_eui64(ldns_rdf **rd, const char *str) { unsigned int a, b, c, d, e, f, g, h; uint8_t bytes[8]; int l; if (sscanf(str, "%2x-%2x-%2x-%2x-%2x-%2x-%2x-%2x%n", &a, &b, &c, &d, &e, &f, &g, &h, &l) != 8 || l != (int)strlen(str) || /* more data to read */ strpbrk(str, "+-") /* signed hexes */ ) { return LDNS_STATUS_INVALID_EUI64; } else { bytes[0] = a; bytes[1] = b; bytes[2] = c; bytes[3] = d; bytes[4] = e; bytes[5] = f; bytes[6] = g; bytes[7] = h; *rd = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_EUI64, 8, &bytes); } return *rd ? LDNS_STATUS_OK : LDNS_STATUS_MEM_ERR; } ldns_status ldns_str2rdf_tag(ldns_rdf **rd, const char *str) { uint8_t *data; const char* ptr; if (strlen(str) > 255) { return LDNS_STATUS_INVALID_TAG; } for (ptr = str; *ptr; ptr++) { if (! isalnum(*ptr)) { return LDNS_STATUS_INVALID_TAG; } } data = LDNS_XMALLOC(uint8_t, strlen(str) + 1); if (!data) { return LDNS_STATUS_MEM_ERR; } data[0] = strlen(str); memcpy(data + 1, str, strlen(str)); *rd = ldns_rdf_new(LDNS_RDF_TYPE_TAG, strlen(str) + 1, data); if (!*rd) { LDNS_FREE(data); return LDNS_STATUS_MEM_ERR; } return LDNS_STATUS_OK; } ldns_status ldns_str2rdf_long_str(ldns_rdf **rd, const char *str) { uint8_t *data, *dp, ch = 0; size_t length; /* Worst case space requirement. We'll realloc to actual size later. */ dp = data = LDNS_XMALLOC(uint8_t, strlen(str)); if (! data) { return LDNS_STATUS_MEM_ERR; } /* Fill data with parsed bytes */ while (parse_char(&ch, &str)) { *dp++ = ch; if (dp - data > LDNS_MAX_RDFLEN) { LDNS_FREE(data); return LDNS_STATUS_INVALID_STR; } } if (! str) { return LDNS_STATUS_SYNTAX_BAD_ESCAPE; } length = (size_t)(dp - data); /* Lose the overmeasure */ data = LDNS_XREALLOC(dp = data, uint8_t, length); if (! data) { LDNS_FREE(dp); return LDNS_STATUS_MEM_ERR; } /* Create rdf */ *rd = ldns_rdf_new(LDNS_RDF_TYPE_LONG_STR, length, data); if (! *rd) { LDNS_FREE(data); return LDNS_STATUS_MEM_ERR; } return LDNS_STATUS_OK; } ldns_status ldns_str2rdf_hip(ldns_rdf **rd, const char *str) { const char *hit = strchr(str, ' ') + 1; const char *pk = hit == NULL ? NULL : strchr(hit, ' ') + 1; size_t hit_size = hit == NULL ? 0 : pk == NULL ? strlen(hit) : (size_t) (pk - hit) - 1; size_t pk_size = pk == NULL ? 0 : strlen(pk); size_t hit_wire_size = (hit_size + 1) / 2; size_t pk_wire_size = ldns_b64_pton_calculate_size(pk_size); size_t rdf_size = 4 + hit_wire_size + pk_wire_size; char *endptr; /* utility var for strtol usage */ int algorithm = strtol(str, &endptr, 10); uint8_t *data, *dp; int hi, lo, written; if (hit_size == 0 || pk_size == 0 || (hit_size + 1) / 2 > 255 || rdf_size > LDNS_MAX_RDFLEN || algorithm < 0 || algorithm > 255 || (errno != 0 && algorithm == 0) /* out of range */ || endptr == str /* no digits */) { return LDNS_STATUS_SYNTAX_ERR; } if ((data = LDNS_XMALLOC(uint8_t, rdf_size)) == NULL) { return LDNS_STATUS_MEM_ERR; } /* From RFC 5205 section 5. HIP RR Storage Format: ************************************************* 0 1 2 3 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ | HIT length | PK algorithm | PK length | +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ | | ~ HIT ~ | | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ | | | +-+-+-+-+-+-+-+-+-+-+-+ + | Public Key | ~ ~ | | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ | | | +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | | ~ Rendezvous Servers ~ | | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ | | +-+-+-+-+-+-+-+ */ data[0] = (uint8_t) hit_wire_size; data[1] = (uint8_t) algorithm; for (dp = data + 4; *hit && *hit != ' '; dp++) { if ((hi = ldns_hexdigit_to_int(*hit++)) == -1 || (lo = ldns_hexdigit_to_int(*hit++)) == -1) { LDNS_FREE(data); return LDNS_STATUS_INVALID_HEX; } *dp = (uint8_t) hi << 4 | lo; } if ((written = ldns_b64_pton(pk, dp, pk_wire_size)) <= 0) { LDNS_FREE(data); return LDNS_STATUS_INVALID_B64; } /* Because ldns_b64_pton_calculate_size isn't always correct: * (we have to fix it at some point) */ pk_wire_size = (uint16_t) written; ldns_write_uint16(data + 2, pk_wire_size); rdf_size = 4 + hit_wire_size + pk_wire_size; /* Create rdf */ if (! (*rd = ldns_rdf_new(LDNS_RDF_TYPE_HIP, rdf_size, data))) { LDNS_FREE(data); return LDNS_STATUS_MEM_ERR; } return LDNS_STATUS_OK; } ldns-1.6.17/duration.c0000664000175100017510000002115212264060151014105 0ustar willemwillem/* * $Id: duration.c 4518 2011-02-24 15:39:09Z matthijs $ * * Copyright (c) 2009 NLNet Labs. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * */ /** * * This file is copied from the OpenDNSSEC source repository * and only slightly adapted to make it fit. */ /** * * Durations. */ #include #include #include #include #include #include /** * Create a new 'instant' duration. * */ ldns_duration_type* ldns_duration_create(void) { ldns_duration_type* duration; duration = malloc(sizeof(ldns_duration_type)); if (!duration) { return NULL; } duration->years = 0; duration->months = 0; duration->weeks = 0; duration->days = 0; duration->hours = 0; duration->minutes = 0; duration->seconds = 0; return duration; } /** * Compare durations. * */ int ldns_duration_compare(ldns_duration_type* d1, ldns_duration_type* d2) { if (!d1 && !d2) { return 0; } if (!d1 || !d2) { return d1?-1:1; } if (d1->years != d2->years) { return (int) (d1->years - d2->years); } if (d1->months != d2->months) { return (int) (d1->months - d2->months); } if (d1->weeks != d2->weeks) { return (int) (d1->weeks - d2->weeks); } if (d1->days != d2->days) { return (int) (d1->days - d2->days); } if (d1->hours != d2->hours) { return (int) (d1->hours - d2->hours); } if (d1->minutes != d2->minutes) { return (int) (d1->minutes - d2->minutes); } if (d1->seconds != d2->seconds) { return (int) (d1->seconds - d2->seconds); } return 0; } /** * Create a duration from string. * */ ldns_duration_type* ldns_duration_create_from_string(const char* str) { ldns_duration_type* duration = ldns_duration_create(); char* P, *X, *T, *W; int not_weeks = 0; if (!duration) { return NULL; } if (!str) { return duration; } P = strchr(str, 'P'); if (!P) { ldns_duration_cleanup(duration); return NULL; } T = strchr(str, 'T'); X = strchr(str, 'Y'); if (X) { duration->years = (time_t) atoi(str+1); str = X; not_weeks = 1; } X = strchr(str, 'M'); if (X && (!T || (size_t) (X-P) < (size_t) (T-P))) { duration->months = (time_t) atoi(str+1); str = X; not_weeks = 1; } X = strchr(str, 'D'); if (X) { duration->days = (time_t) atoi(str+1); str = X; not_weeks = 1; } if (T) { str = T; not_weeks = 1; } X = strchr(str, 'H'); if (X && T) { duration->hours = (time_t) atoi(str+1); str = X; not_weeks = 1; } X = strrchr(str, 'M'); if (X && T && (size_t) (X-P) > (size_t) (T-P)) { duration->minutes = (time_t) atoi(str+1); str = X; not_weeks = 1; } X = strchr(str, 'S'); if (X && T) { duration->seconds = (time_t) atoi(str+1); str = X; not_weeks = 1; } W = strchr(str, 'W'); if (W) { if (not_weeks) { ldns_duration_cleanup(duration); return NULL; } else { duration->weeks = (time_t) atoi(str+1); str = W; } } return duration; } /** * Get the number of digits in a number. * */ static size_t digits_in_number(time_t duration) { uint32_t period = (uint32_t) duration; size_t count = 0; while (period > 0) { count++; period /= 10; } return count; } /** * Convert a duration to a string. * */ char* ldns_duration2string(ldns_duration_type* duration) { char* str = NULL, *num = NULL; size_t count = 2; int T = 0; if (!duration) { return NULL; } if (duration->years > 0) { count = count + 1 + digits_in_number(duration->years); } if (duration->months > 0) { count = count + 1 + digits_in_number(duration->months); } if (duration->weeks > 0) { count = count + 1 + digits_in_number(duration->weeks); } if (duration->days > 0) { count = count + 1 + digits_in_number(duration->days); } if (duration->hours > 0) { count = count + 1 + digits_in_number(duration->hours); T = 1; } if (duration->minutes > 0) { count = count + 1 + digits_in_number(duration->minutes); T = 1; } if (duration->seconds > 0) { count = count + 1 + digits_in_number(duration->seconds); T = 1; } if (T) { count++; } str = (char*) calloc(count, sizeof(char)); str[0] = 'P'; str[1] = '\0'; if (duration->years > 0) { count = digits_in_number(duration->years); num = (char*) calloc(count+2, sizeof(char)); snprintf(num, count+2, "%uY", (unsigned int) duration->years); str = strncat(str, num, count+2); free((void*) num); } if (duration->months > 0) { count = digits_in_number(duration->months); num = (char*) calloc(count+2, sizeof(char)); snprintf(num, count+2, "%uM", (unsigned int) duration->months); str = strncat(str, num, count+2); free((void*) num); } if (duration->weeks > 0) { count = digits_in_number(duration->weeks); num = (char*) calloc(count+2, sizeof(char)); snprintf(num, count+2, "%uW", (unsigned int) duration->weeks); str = strncat(str, num, count+2); free((void*) num); } if (duration->days > 0) { count = digits_in_number(duration->days); num = (char*) calloc(count+2, sizeof(char)); snprintf(num, count+2, "%uD", (unsigned int) duration->days); str = strncat(str, num, count+2); free((void*) num); } if (T) { str = strncat(str, "T", 1); } if (duration->hours > 0) { count = digits_in_number(duration->hours); num = (char*) calloc(count+2, sizeof(char)); snprintf(num, count+2, "%uH", (unsigned int) duration->hours); str = strncat(str, num, count+2); free((void*) num); } if (duration->minutes > 0) { count = digits_in_number(duration->minutes); num = (char*) calloc(count+2, sizeof(char)); snprintf(num, count+2, "%uM", (unsigned int) duration->minutes); str = strncat(str, num, count+2); free((void*) num); } if (duration->seconds > 0) { count = digits_in_number(duration->seconds); num = (char*) calloc(count+2, sizeof(char)); snprintf(num, count+2, "%uS", (unsigned int) duration->seconds); str = strncat(str, num, count+2); free((void*) num); } return str; } /** * Convert a duration to a time. * */ time_t ldns_duration2time(ldns_duration_type* duration) { time_t period = 0; if (duration) { period += (duration->seconds); period += (duration->minutes)*60; period += (duration->hours)*3600; period += (duration->days)*86400; period += (duration->weeks)*86400*7; period += (duration->months)*86400*31; period += (duration->years)*86400*365; /* [TODO] calculate correct number of days in this month/year */ /* if (duration->months || duration->years) { } */ } return period; } /** * Clean up duration. * */ void ldns_duration_cleanup(ldns_duration_type* duration) { if (!duration) { return; } free(duration); return; } ldns-1.6.17/update.c0000664000175100017510000001647412264060151013555 0ustar willemwillem/* update.c * * Functions for RFC 2136 Dynamic Update * * Copyright (c) 2005-2008, NLnet Labs. All rights reserved. * * See LICENSE for the license. */ #include #include #include #include #include /* * RFC 2136 sections mapped to RFC 1035: * zone/ZO -- QD/question * prerequisites/PR -- AN/answers * updates/UP -- NS/authority records * additional data/AD -- AR/additional records */ ldns_pkt * ldns_update_pkt_new(ldns_rdf *zone_rdf, ldns_rr_class c, ldns_rr_list *pr_rrlist, ldns_rr_list *up_rrlist, ldns_rr_list *ad_rrlist) { ldns_pkt *p; if (!zone_rdf || !up_rrlist) { return NULL; } if (c == 0) { c = LDNS_RR_CLASS_IN; } /* Create packet, fill in Zone Section. */ p = ldns_pkt_query_new(zone_rdf, LDNS_RR_TYPE_SOA, c, LDNS_RD); if (!p) { return NULL; } zone_rdf = NULL; /* No longer safe to use. */ ldns_pkt_set_opcode(p, LDNS_PACKET_UPDATE); ldns_rr_list_deep_free(p->_authority); ldns_pkt_set_authority(p, ldns_rr_list_clone(up_rrlist)); ldns_update_set_upcount(p, ldns_rr_list_rr_count(up_rrlist)); if (pr_rrlist) { ldns_rr_list_deep_free(p->_answer); /*XXX access function */ ldns_pkt_set_answer(p, ldns_rr_list_clone(pr_rrlist)); ldns_update_set_prcount(p, ldns_rr_list_rr_count(pr_rrlist)); } if (ad_rrlist) { ldns_rr_list_deep_free(p->_additional); ldns_pkt_set_additional(p, ldns_rr_list_clone(ad_rrlist)); ldns_update_set_adcount(p, ldns_rr_list_rr_count(ad_rrlist)); } return p; } ldns_status ldns_update_pkt_tsig_add(ldns_pkt *p, ldns_resolver *r) { #ifdef HAVE_SSL uint16_t fudge = 300; /* Recommended fudge. [RFC2845 6.4] */ if (ldns_resolver_tsig_keyname(r) && ldns_resolver_tsig_keydata(r)) return ldns_pkt_tsig_sign(p, ldns_resolver_tsig_keyname(r), ldns_resolver_tsig_keydata(r), fudge, ldns_resolver_tsig_algorithm(r), NULL); #else /* do nothing */ (void)p; (void)r; #endif /* HAVE_SSL */ /* No TSIG to do. */ return LDNS_STATUS_OK; } /* Move to higher.c or similar? */ /* XXX doc */ ldns_status ldns_update_soa_mname(ldns_rdf *zone, ldns_resolver *r, ldns_rr_class c, ldns_rdf **mname) { ldns_rr *soa_rr; ldns_pkt *query, *resp; /* Nondestructive, so clone 'zone' here */ query = ldns_pkt_query_new(ldns_rdf_clone(zone), LDNS_RR_TYPE_SOA, c, LDNS_RD); if (!query) { return LDNS_STATUS_ERR; } ldns_pkt_set_random_id(query); if (ldns_resolver_send_pkt(&resp, r, query) != LDNS_STATUS_OK) { ldns_pkt_free(query); return LDNS_STATUS_ERR; } ldns_pkt_free(query); if (!resp) { return LDNS_STATUS_ERR; } /* Expect a SOA answer. */ *mname = NULL; while ((soa_rr = ldns_rr_list_pop_rr(ldns_pkt_answer(resp)))) { if (ldns_rr_get_type(soa_rr) != LDNS_RR_TYPE_SOA || ldns_rr_rdf(soa_rr, 0) == NULL) continue; /* [RFC1035 3.3.13] */ *mname = ldns_rdf_clone(ldns_rr_rdf(soa_rr, 0)); break; } ldns_pkt_free(resp); return *mname ? LDNS_STATUS_OK : LDNS_STATUS_ERR; } /* Try to get zone and MNAME from SOA queries. */ ldns_status ldns_update_soa_zone_mname(const char *fqdn, ldns_resolver *r, ldns_rr_class c, ldns_rdf **zone_rdf, ldns_rdf **mname_rdf) { ldns_rr *soa_rr, *rr; ldns_rdf *soa_zone = NULL, *soa_mname = NULL; ldns_rdf *ipaddr, *fqdn_rdf, *tmp; ldns_rdf **nslist; ldns_pkt *query, *resp; size_t i; /* * XXX Ok, this cannot be the best way to find this...? * XXX (I run into weird cache-related stuff here) */ /* Step 1 - first find a nameserver that should know *something* */ fqdn_rdf = ldns_dname_new_frm_str(fqdn); query = ldns_pkt_query_new(fqdn_rdf, LDNS_RR_TYPE_SOA, c, LDNS_RD); if (!query) { return LDNS_STATUS_ERR; } fqdn_rdf = NULL; ldns_pkt_set_random_id(query); if (ldns_resolver_send_pkt(&resp, r, query) != LDNS_STATUS_OK) { ldns_pkt_free(query); return LDNS_STATUS_ERR; } ldns_pkt_free(query); if (!resp) { return LDNS_STATUS_ERR; } /* XXX Is it safe to only look in authority section here? */ while ((soa_rr = ldns_rr_list_pop_rr(ldns_pkt_authority(resp)))) { if (ldns_rr_get_type(soa_rr) != LDNS_RR_TYPE_SOA || ldns_rr_rdf(soa_rr, 0) == NULL) continue; /* [RFC1035 3.3.13] */ soa_mname = ldns_rdf_clone(ldns_rr_rdf(soa_rr, 0)); break; } ldns_pkt_free(resp); if (!soa_rr) { return LDNS_STATUS_ERR; } /* Step 2 - find SOA MNAME IP address, add to resolver */ query = ldns_pkt_query_new(soa_mname, LDNS_RR_TYPE_A, c, LDNS_RD); if (!query) { return LDNS_STATUS_ERR; } soa_mname = NULL; ldns_pkt_set_random_id(query); if (ldns_resolver_send_pkt(&resp, r, query) != LDNS_STATUS_OK) { ldns_pkt_free(query); return LDNS_STATUS_ERR; } ldns_pkt_free(query); if (!resp) { return LDNS_STATUS_ERR; } if (ldns_pkt_ancount(resp) == 0) { ldns_pkt_free(resp); return LDNS_STATUS_ERR; } /* XXX There may be more than one answer RR here. */ rr = ldns_rr_list_pop_rr(ldns_pkt_answer(resp)); ipaddr = ldns_rr_rdf(rr, 0); /* Put the SOA mname IP first in the nameserver list. */ nslist = ldns_resolver_nameservers(r); for (i = 0; i < ldns_resolver_nameserver_count(r); i++) { if (ldns_rdf_compare(ipaddr, nslist[i]) == 0) { if (i) { tmp = nslist[0]; nslist[0] = nslist[i]; nslist[i] = tmp; } break; } } if (i >= ldns_resolver_nameserver_count(r)) { /* SOA mname was not part of the resolver so add it first. */ (void) ldns_resolver_push_nameserver(r, ipaddr); nslist = ldns_resolver_nameservers(r); i = ldns_resolver_nameserver_count(r) - 1; tmp = nslist[0]; nslist[0] = nslist[i]; nslist[i] = tmp; } ldns_pkt_free(resp); /* Make sure to ask the first in the list, i.e SOA mname */ ldns_resolver_set_random(r, false); /* Step 3 - Redo SOA query, sending to SOA MNAME directly. */ fqdn_rdf = ldns_dname_new_frm_str(fqdn); query = ldns_pkt_query_new(fqdn_rdf, LDNS_RR_TYPE_SOA, c, LDNS_RD); if (!query) { return LDNS_STATUS_ERR; } fqdn_rdf = NULL; ldns_pkt_set_random_id(query); if (ldns_resolver_send_pkt(&resp, r, query) != LDNS_STATUS_OK) { ldns_pkt_free(query); return LDNS_STATUS_ERR; } ldns_pkt_free(query); if (!resp) { return LDNS_STATUS_ERR; } /* XXX Is it safe to only look in authority section here, too? */ while ((soa_rr = ldns_rr_list_pop_rr(ldns_pkt_authority(resp)))) { if (ldns_rr_get_type(soa_rr) != LDNS_RR_TYPE_SOA || ldns_rr_rdf(soa_rr, 0) == NULL) continue; /* [RFC1035 3.3.13] */ soa_mname = ldns_rdf_clone(ldns_rr_rdf(soa_rr, 0)); soa_zone = ldns_rdf_clone(ldns_rr_owner(soa_rr)); break; } ldns_pkt_free(resp); if (!soa_rr) { return LDNS_STATUS_ERR; } /* That seems to have worked, pass results to caller. */ *zone_rdf = soa_zone; *mname_rdf = soa_mname; return LDNS_STATUS_OK; } /* * ldns_update_{get,set}_{zo,pr,up,ad}count */ uint16_t ldns_update_zocount(const ldns_pkt *p) { return ldns_pkt_qdcount(p); } uint16_t ldns_update_prcount(const ldns_pkt *p) { return ldns_pkt_ancount(p); } uint16_t ldns_update_upcount(const ldns_pkt *p) { return ldns_pkt_nscount(p); } uint16_t ldns_update_ad(const ldns_pkt *p) { return ldns_pkt_arcount(p); } void ldns_update_set_zo(ldns_pkt *p, uint16_t v) { ldns_pkt_set_qdcount(p, v); } void ldns_update_set_prcount(ldns_pkt *p, uint16_t v) { ldns_pkt_set_ancount(p, v); } void ldns_update_set_upcount(ldns_pkt *p, uint16_t v) { ldns_pkt_set_nscount(p, v); } void ldns_update_set_adcount(ldns_pkt *p, uint16_t v) { ldns_pkt_set_arcount(p, v); } ldns-1.6.17/rdata.c0000664000175100017510000003733612264060151013366 0ustar willemwillem/* * rdata.c * * rdata implementation * * a Net::DNS like library for C * * (c) NLnet Labs, 2004-2006 * * See the file LICENSE for the license */ #include #include /* * Access functions * do this as functions to get type checking */ /* read */ size_t ldns_rdf_size(const ldns_rdf *rd) { assert(rd != NULL); return rd->_size; } ldns_rdf_type ldns_rdf_get_type(const ldns_rdf *rd) { assert(rd != NULL); return rd->_type; } uint8_t * ldns_rdf_data(const ldns_rdf *rd) { assert(rd != NULL); return rd->_data; } /* write */ void ldns_rdf_set_size(ldns_rdf *rd, size_t size) { assert(rd != NULL); rd->_size = size; } void ldns_rdf_set_type(ldns_rdf *rd, ldns_rdf_type type) { assert(rd != NULL); rd->_type = type; } void ldns_rdf_set_data(ldns_rdf *rd, void *data) { /* only copy the pointer */ assert(rd != NULL); rd->_data = data; } /* for types that allow it, return * the native/host order type */ uint8_t ldns_rdf2native_int8(const ldns_rdf *rd) { uint8_t data; /* only allow 8 bit rdfs */ if (ldns_rdf_size(rd) != LDNS_RDF_SIZE_BYTE) { return 0; } memcpy(&data, ldns_rdf_data(rd), sizeof(data)); return data; } uint16_t ldns_rdf2native_int16(const ldns_rdf *rd) { uint16_t data; /* only allow 16 bit rdfs */ if (ldns_rdf_size(rd) != LDNS_RDF_SIZE_WORD) { return 0; } memcpy(&data, ldns_rdf_data(rd), sizeof(data)); return ntohs(data); } uint32_t ldns_rdf2native_int32(const ldns_rdf *rd) { uint32_t data; /* only allow 32 bit rdfs */ if (ldns_rdf_size(rd) != LDNS_RDF_SIZE_DOUBLEWORD) { return 0; } memcpy(&data, ldns_rdf_data(rd), sizeof(data)); return ntohl(data); } time_t ldns_rdf2native_time_t(const ldns_rdf *rd) { uint32_t data; /* only allow 32 bit rdfs */ if (ldns_rdf_size(rd) != LDNS_RDF_SIZE_DOUBLEWORD || ldns_rdf_get_type(rd) != LDNS_RDF_TYPE_TIME) { return 0; } memcpy(&data, ldns_rdf_data(rd), sizeof(data)); return (time_t)ntohl(data); } ldns_rdf * ldns_native2rdf_int8(ldns_rdf_type type, uint8_t value) { return ldns_rdf_new_frm_data(type, LDNS_RDF_SIZE_BYTE, &value); } ldns_rdf * ldns_native2rdf_int16(ldns_rdf_type type, uint16_t value) { uint16_t *rdf_data = LDNS_XMALLOC(uint16_t, 1); ldns_rdf* rdf; if (!rdf_data) { return NULL; } ldns_write_uint16(rdf_data, value); rdf = ldns_rdf_new(type, LDNS_RDF_SIZE_WORD, rdf_data); if(!rdf) LDNS_FREE(rdf_data); return rdf; } ldns_rdf * ldns_native2rdf_int32(ldns_rdf_type type, uint32_t value) { uint32_t *rdf_data = LDNS_XMALLOC(uint32_t, 1); ldns_rdf* rdf; if (!rdf_data) { return NULL; } ldns_write_uint32(rdf_data, value); rdf = ldns_rdf_new(type, LDNS_RDF_SIZE_DOUBLEWORD, rdf_data); if(!rdf) LDNS_FREE(rdf_data); return rdf; } ldns_rdf * ldns_native2rdf_int16_data(size_t size, uint8_t *data) { uint8_t *rdf_data = LDNS_XMALLOC(uint8_t, size + 2); ldns_rdf* rdf; if (!rdf_data) { return NULL; } ldns_write_uint16(rdf_data, size); memcpy(rdf_data + 2, data, size); rdf = ldns_rdf_new(LDNS_RDF_TYPE_INT16_DATA, size + 2, rdf_data); if(!rdf) LDNS_FREE(rdf_data); return rdf; } /* note: data must be allocated memory */ ldns_rdf * ldns_rdf_new(ldns_rdf_type type, size_t size, void *data) { ldns_rdf *rd; rd = LDNS_MALLOC(ldns_rdf); if (!rd) { return NULL; } ldns_rdf_set_size(rd, size); ldns_rdf_set_type(rd, type); ldns_rdf_set_data(rd, data); return rd; } ldns_rdf * ldns_rdf_new_frm_data(ldns_rdf_type type, size_t size, const void *data) { ldns_rdf *rdf; /* if the size is too big, fail */ if (size > LDNS_MAX_RDFLEN) { return NULL; } /* allocate space */ rdf = LDNS_MALLOC(ldns_rdf); if (!rdf) { return NULL; } rdf->_data = LDNS_XMALLOC(uint8_t, size); if (!rdf->_data) { LDNS_FREE(rdf); return NULL; } /* set the values */ ldns_rdf_set_type(rdf, type); ldns_rdf_set_size(rdf, size); memcpy(rdf->_data, data, size); return rdf; } ldns_rdf * ldns_rdf_clone(const ldns_rdf *rd) { assert(rd != NULL); return (ldns_rdf_new_frm_data( ldns_rdf_get_type(rd), ldns_rdf_size(rd), ldns_rdf_data(rd))); } void ldns_rdf_deep_free(ldns_rdf *rd) { if (rd) { if (rd->_data) { LDNS_FREE(rd->_data); } LDNS_FREE(rd); } } void ldns_rdf_free(ldns_rdf *rd) { if (rd) { LDNS_FREE(rd); } } ldns_rdf * ldns_rdf_new_frm_str(ldns_rdf_type type, const char *str) { ldns_rdf *rdf = NULL; ldns_status status; switch (type) { case LDNS_RDF_TYPE_DNAME: status = ldns_str2rdf_dname(&rdf, str); break; case LDNS_RDF_TYPE_INT8: status = ldns_str2rdf_int8(&rdf, str); break; case LDNS_RDF_TYPE_INT16: status = ldns_str2rdf_int16(&rdf, str); break; case LDNS_RDF_TYPE_INT32: status = ldns_str2rdf_int32(&rdf, str); break; case LDNS_RDF_TYPE_A: status = ldns_str2rdf_a(&rdf, str); break; case LDNS_RDF_TYPE_AAAA: status = ldns_str2rdf_aaaa(&rdf, str); break; case LDNS_RDF_TYPE_STR: status = ldns_str2rdf_str(&rdf, str); break; case LDNS_RDF_TYPE_APL: status = ldns_str2rdf_apl(&rdf, str); break; case LDNS_RDF_TYPE_B64: status = ldns_str2rdf_b64(&rdf, str); break; case LDNS_RDF_TYPE_B32_EXT: status = ldns_str2rdf_b32_ext(&rdf, str); break; case LDNS_RDF_TYPE_HEX: status = ldns_str2rdf_hex(&rdf, str); break; case LDNS_RDF_TYPE_NSEC: status = ldns_str2rdf_nsec(&rdf, str); break; case LDNS_RDF_TYPE_TYPE: status = ldns_str2rdf_type(&rdf, str); break; case LDNS_RDF_TYPE_CLASS: status = ldns_str2rdf_class(&rdf, str); break; case LDNS_RDF_TYPE_CERT_ALG: status = ldns_str2rdf_cert_alg(&rdf, str); break; case LDNS_RDF_TYPE_ALG: status = ldns_str2rdf_alg(&rdf, str); break; case LDNS_RDF_TYPE_UNKNOWN: status = ldns_str2rdf_unknown(&rdf, str); break; case LDNS_RDF_TYPE_TIME: status = ldns_str2rdf_time(&rdf, str); break; case LDNS_RDF_TYPE_PERIOD: status = ldns_str2rdf_period(&rdf, str); break; case LDNS_RDF_TYPE_HIP: status = ldns_str2rdf_hip(&rdf, str); break; case LDNS_RDF_TYPE_SERVICE: status = ldns_str2rdf_service(&rdf, str); break; case LDNS_RDF_TYPE_LOC: status = ldns_str2rdf_loc(&rdf, str); break; case LDNS_RDF_TYPE_WKS: status = ldns_str2rdf_wks(&rdf, str); break; case LDNS_RDF_TYPE_NSAP: status = ldns_str2rdf_nsap(&rdf, str); break; case LDNS_RDF_TYPE_ATMA: status = ldns_str2rdf_atma(&rdf, str); break; case LDNS_RDF_TYPE_IPSECKEY: status = ldns_str2rdf_ipseckey(&rdf, str); break; case LDNS_RDF_TYPE_NSEC3_SALT: status = ldns_str2rdf_nsec3_salt(&rdf, str); break; case LDNS_RDF_TYPE_NSEC3_NEXT_OWNER: status = ldns_str2rdf_b32_ext(&rdf, str); break; case LDNS_RDF_TYPE_ILNP64: status = ldns_str2rdf_ilnp64(&rdf, str); break; case LDNS_RDF_TYPE_EUI48: status = ldns_str2rdf_eui48(&rdf, str); break; case LDNS_RDF_TYPE_EUI64: status = ldns_str2rdf_eui64(&rdf, str); break; case LDNS_RDF_TYPE_TAG: status = ldns_str2rdf_tag(&rdf, str); break; case LDNS_RDF_TYPE_LONG_STR: status = ldns_str2rdf_long_str(&rdf, str); break; case LDNS_RDF_TYPE_NONE: default: /* default default ??? */ status = LDNS_STATUS_ERR; break; } if (LDNS_STATUS_OK == status) { ldns_rdf_set_type(rdf, type); return rdf; } if (rdf) { LDNS_FREE(rdf); } return NULL; } ldns_status ldns_rdf_new_frm_fp(ldns_rdf **rdf, ldns_rdf_type type, FILE *fp) { return ldns_rdf_new_frm_fp_l(rdf, type, fp, NULL); } ldns_status ldns_rdf_new_frm_fp_l(ldns_rdf **rdf, ldns_rdf_type type, FILE *fp, int *line_nr) { char *line; ldns_rdf *r; ssize_t t; line = LDNS_XMALLOC(char, LDNS_MAX_LINELEN + 1); if (!line) { return LDNS_STATUS_MEM_ERR; } /* read an entire line in from the file */ if ((t = ldns_fget_token_l(fp, line, LDNS_PARSE_SKIP_SPACE, 0, line_nr)) == -1 || t == 0) { LDNS_FREE(line); return LDNS_STATUS_SYNTAX_RDATA_ERR; } r = ldns_rdf_new_frm_str(type, (const char*) line); LDNS_FREE(line); if (rdf) { *rdf = r; return LDNS_STATUS_OK; } else { return LDNS_STATUS_NULL; } } ldns_rdf * ldns_rdf_address_reverse(ldns_rdf *rd) { uint8_t buf_4[LDNS_IP4ADDRLEN]; uint8_t buf_6[LDNS_IP6ADDRLEN * 2]; ldns_rdf *rev; ldns_rdf *in_addr; ldns_rdf *ret_dname; uint8_t octet; uint8_t nnibble; uint8_t nibble; uint8_t i, j; char *char_dname; int nbit; if (ldns_rdf_get_type(rd) != LDNS_RDF_TYPE_A && ldns_rdf_get_type(rd) != LDNS_RDF_TYPE_AAAA) { return NULL; } in_addr = NULL; ret_dname = NULL; switch(ldns_rdf_get_type(rd)) { case LDNS_RDF_TYPE_A: /* the length of the buffer is 4 */ buf_4[3] = ldns_rdf_data(rd)[0]; buf_4[2] = ldns_rdf_data(rd)[1]; buf_4[1] = ldns_rdf_data(rd)[2]; buf_4[0] = ldns_rdf_data(rd)[3]; in_addr = ldns_dname_new_frm_str("in-addr.arpa."); if (!in_addr) { return NULL; } /* make a new rdf and convert that back */ rev = ldns_rdf_new_frm_data( LDNS_RDF_TYPE_A, LDNS_IP4ADDRLEN, (void*)&buf_4); if (!rev) { LDNS_FREE(in_addr); return NULL; } /* convert rev to a string */ char_dname = ldns_rdf2str(rev); if (!char_dname) { LDNS_FREE(in_addr); ldns_rdf_deep_free(rev); return NULL; } /* transform back to rdf with type dname */ ret_dname = ldns_dname_new_frm_str(char_dname); if (!ret_dname) { LDNS_FREE(in_addr); ldns_rdf_deep_free(rev); LDNS_FREE(char_dname); return NULL; } /* not needed anymore */ ldns_rdf_deep_free(rev); LDNS_FREE(char_dname); break; case LDNS_RDF_TYPE_AAAA: /* some foo magic to reverse the nibbles ... */ for (nbit = 127; nbit >= 0; nbit = nbit - 4) { /* calculate octett (8 bit) */ octet = ( ((unsigned int) nbit) & 0x78) >> 3; /* calculate nibble */ nnibble = ( ((unsigned int) nbit) & 0x04) >> 2; /* extract nibble */ nibble = (ldns_rdf_data(rd)[octet] & ( 0xf << (4 * (1 - nnibble)) ) ) >> ( 4 * (1 - nnibble)); buf_6[(LDNS_IP6ADDRLEN * 2 - 1) - (octet * 2 + nnibble)] = (uint8_t)ldns_int_to_hexdigit((int)nibble); } char_dname = LDNS_XMALLOC(char, (LDNS_IP6ADDRLEN * 4)); if (!char_dname) { return NULL; } char_dname[LDNS_IP6ADDRLEN * 4 - 1] = '\0'; /* closure */ /* walk the string and add . 's */ for (i = 0, j = 0; i < LDNS_IP6ADDRLEN * 2; i++, j = j + 2) { char_dname[j] = (char)buf_6[i]; if (i != LDNS_IP6ADDRLEN * 2 - 1) { char_dname[j + 1] = '.'; } } in_addr = ldns_dname_new_frm_str("ip6.arpa."); if (!in_addr) { LDNS_FREE(char_dname); return NULL; } /* convert rev to a string */ ret_dname = ldns_dname_new_frm_str(char_dname); LDNS_FREE(char_dname); if (!ret_dname) { ldns_rdf_deep_free(in_addr); return NULL; } break; default: break; } /* add the suffix */ rev = ldns_dname_cat_clone(ret_dname, in_addr); ldns_rdf_deep_free(ret_dname); ldns_rdf_deep_free(in_addr); return rev; } ldns_status ldns_rdf_hip_get_alg_hit_pk(ldns_rdf *rdf, uint8_t* alg, uint8_t *hit_size, uint8_t** hit, uint16_t *pk_size, uint8_t** pk) { uint8_t *data; size_t rdf_size; if (! rdf || ! alg || ! hit || ! hit_size || ! pk || ! pk_size) { return LDNS_STATUS_INVALID_POINTER; } else if (ldns_rdf_get_type(rdf) != LDNS_RDF_TYPE_HIP) { return LDNS_STATUS_INVALID_RDF_TYPE; } else if ((rdf_size = ldns_rdf_size(rdf)) < 6) { return LDNS_STATUS_WIRE_RDATA_ERR; } data = ldns_rdf_data(rdf); *hit_size = data[0]; *alg = data[1]; *pk_size = ldns_read_uint16(data + 2); *hit = data + 4; *pk = data + 4 + *hit_size; if (*hit_size == 0 || *pk_size == 0 || rdf_size < (size_t) *hit_size + *pk_size + 4) { return LDNS_STATUS_WIRE_RDATA_ERR; } return LDNS_STATUS_OK; } ldns_status ldns_rdf_hip_new_frm_alg_hit_pk(ldns_rdf** rdf, uint8_t alg, uint8_t hit_size, uint8_t *hit, uint16_t pk_size, uint8_t *pk) { uint8_t *data; if (! rdf) { return LDNS_STATUS_INVALID_POINTER; } if (4 + hit_size + pk_size > LDNS_MAX_RDFLEN) { return LDNS_STATUS_RDATA_OVERFLOW; } data = LDNS_XMALLOC(uint8_t, 4 + hit_size + pk_size); if (data == NULL) { return LDNS_STATUS_MEM_ERR; } data[0] = hit_size; data[1] = alg; ldns_write_uint16(data + 2, pk_size); memcpy(data + 4, hit, hit_size); memcpy(data + 4 + hit_size, pk, pk_size); *rdf = ldns_rdf_new(LDNS_RDF_TYPE_HIP, 4 + hit_size + pk_size, data); if (! *rdf) { LDNS_FREE(data); return LDNS_STATUS_MEM_ERR; } return LDNS_STATUS_OK; } ldns_status ldns_octet(char *word, size_t *length) { char *s; char *p; *length = 0; for (s = p = word; *s != '\0'; s++,p++) { switch (*s) { case '.': if (s[1] == '.') { return LDNS_STATUS_EMPTY_LABEL; } *p = *s; (*length)++; break; case '\\': if ('0' <= s[1] && s[1] <= '9' && '0' <= s[2] && s[2] <= '9' && '0' <= s[3] && s[3] <= '9') { /* \DDD seen */ int val = ((s[1] - '0') * 100 + (s[2] - '0') * 10 + (s[3] - '0')); if (0 <= val && val <= 255) { /* this also handles \0 */ s += 3; *p = val; (*length)++; } else { return LDNS_STATUS_DDD_OVERFLOW; } } else { /* an espaced character, like \ ? * remove the '\' keep the rest */ *p = *++s; (*length)++; } break; case '\"': /* non quoted " Is either first or the last character in * the string */ *p = *++s; /* skip it */ (*length)++; /* I'm not sure if this is needed in libdns... MG */ if ( *s == '\0' ) { /* ok, it was the last one */ *p = '\0'; return LDNS_STATUS_OK; } break; default: *p = *s; (*length)++; break; } } *p = '\0'; return LDNS_STATUS_OK; } int ldns_rdf_compare(const ldns_rdf *rd1, const ldns_rdf *rd2) { uint16_t i1, i2, i; uint8_t *d1, *d2; /* only when both are not NULL we can say anything about them */ if (!rd1 && !rd2) { return 0; } if (!rd1 || !rd2) { return -1; } i1 = ldns_rdf_size(rd1); i2 = ldns_rdf_size(rd2); if (i1 < i2) { return -1; } else if (i1 > i2) { return +1; } else { d1 = (uint8_t*)ldns_rdf_data(rd1); d2 = (uint8_t*)ldns_rdf_data(rd2); for(i = 0; i < i1; i++) { if (d1[i] < d2[i]) { return -1; } else if (d1[i] > d2[i]) { return +1; } } } return 0; } uint32_t ldns_str2period(const char *nptr, const char **endptr) { int sign = 0; uint32_t i = 0; uint32_t seconds = 0; for(*endptr = nptr; **endptr; (*endptr)++) { switch (**endptr) { case ' ': case '\t': break; case '-': if(sign == 0) { sign = -1; } else { return seconds; } break; case '+': if(sign == 0) { sign = 1; } else { return seconds; } break; case 's': case 'S': seconds += i; i = 0; break; case 'm': case 'M': seconds += i * 60; i = 0; break; case 'h': case 'H': seconds += i * 60 * 60; i = 0; break; case 'd': case 'D': seconds += i * 60 * 60 * 24; i = 0; break; case 'w': case 'W': seconds += i * 60 * 60 * 24 * 7; i = 0; break; case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': i *= 10; i += (**endptr - '0'); break; default: seconds += i; /* disregard signedness */ return seconds; } } seconds += i; /* disregard signedness */ return seconds; } ldns-1.6.17/install-sh0000775000175100017510000003325512264060151014127 0ustar willemwillem#!/bin/sh # install - install a program, script, or datafile scriptversion=2011-11-20.07; # UTC # This originates from X11R5 (mit/util/scripts/install.sh), which was # later released in X11R6 (xc/config/util/install.sh) with the # following copyright and license. # # Copyright (C) 1994 X Consortium # # Permission is hereby granted, free of charge, to any person obtaining a copy # of this software and associated documentation files (the "Software"), to # deal in the Software without restriction, including without limitation the # rights to use, copy, modify, merge, publish, distribute, sublicense, and/or # sell copies of the Software, and to permit persons to whom the Software is # furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included in # all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN # AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNEC- # TION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. # # Except as contained in this notice, the name of the X Consortium shall not # be used in advertising or otherwise to promote the sale, use or other deal- # ings in this Software without prior written authorization from the X Consor- # tium. # # # FSF changes to this file are in the public domain. # # Calling this script install-sh is preferred over install.sh, to prevent # 'make' implicit rules from creating a file called install from it # when there is no Makefile. # # This script is compatible with the BSD install script, but was written # from scratch. nl=' ' IFS=" "" $nl" # set DOITPROG to echo to test this script # Don't use :- since 4.3BSD and earlier shells don't like it. doit=${DOITPROG-} if test -z "$doit"; then doit_exec=exec else doit_exec=$doit fi # Put in absolute file names if you don't have them in your path; # or use environment vars. chgrpprog=${CHGRPPROG-chgrp} chmodprog=${CHMODPROG-chmod} chownprog=${CHOWNPROG-chown} cmpprog=${CMPPROG-cmp} cpprog=${CPPROG-cp} mkdirprog=${MKDIRPROG-mkdir} mvprog=${MVPROG-mv} rmprog=${RMPROG-rm} stripprog=${STRIPPROG-strip} posix_glob='?' initialize_posix_glob=' test "$posix_glob" != "?" || { if (set -f) 2>/dev/null; then posix_glob= else posix_glob=: fi } ' posix_mkdir= # Desired mode of installed file. mode=0755 chgrpcmd= chmodcmd=$chmodprog chowncmd= mvcmd=$mvprog rmcmd="$rmprog -f" stripcmd= src= dst= dir_arg= dst_arg= copy_on_change=false no_target_directory= usage="\ Usage: $0 [OPTION]... [-T] SRCFILE DSTFILE or: $0 [OPTION]... SRCFILES... DIRECTORY or: $0 [OPTION]... -t DIRECTORY SRCFILES... or: $0 [OPTION]... -d DIRECTORIES... In the 1st form, copy SRCFILE to DSTFILE. In the 2nd and 3rd, copy all SRCFILES to DIRECTORY. In the 4th, create DIRECTORIES. Options: --help display this help and exit. --version display version info and exit. -c (ignored) -C install only if different (preserve the last data modification time) -d create directories instead of installing files. -g GROUP $chgrpprog installed files to GROUP. -m MODE $chmodprog installed files to MODE. -o USER $chownprog installed files to USER. -s $stripprog installed files. -t DIRECTORY install into DIRECTORY. -T report an error if DSTFILE is a directory. Environment variables override the default commands: CHGRPPROG CHMODPROG CHOWNPROG CMPPROG CPPROG MKDIRPROG MVPROG RMPROG STRIPPROG " while test $# -ne 0; do case $1 in -c) ;; -C) copy_on_change=true;; -d) dir_arg=true;; -g) chgrpcmd="$chgrpprog $2" shift;; --help) echo "$usage"; exit $?;; -m) mode=$2 case $mode in *' '* | *' '* | *' '* | *'*'* | *'?'* | *'['*) echo "$0: invalid mode: $mode" >&2 exit 1;; esac shift;; -o) chowncmd="$chownprog $2" shift;; -s) stripcmd=$stripprog;; -t) dst_arg=$2 # Protect names problematic for 'test' and other utilities. case $dst_arg in -* | [=\(\)!]) dst_arg=./$dst_arg;; esac shift;; -T) no_target_directory=true;; --version) echo "$0 $scriptversion"; exit $?;; --) shift break;; -*) echo "$0: invalid option: $1" >&2 exit 1;; *) break;; esac shift done if test $# -ne 0 && test -z "$dir_arg$dst_arg"; then # When -d is used, all remaining arguments are directories to create. # When -t is used, the destination is already specified. # Otherwise, the last argument is the destination. Remove it from $@. for arg do if test -n "$dst_arg"; then # $@ is not empty: it contains at least $arg. set fnord "$@" "$dst_arg" shift # fnord fi shift # arg dst_arg=$arg # Protect names problematic for 'test' and other utilities. case $dst_arg in -* | [=\(\)!]) dst_arg=./$dst_arg;; esac done fi if test $# -eq 0; then if test -z "$dir_arg"; then echo "$0: no input file specified." >&2 exit 1 fi # It's OK to call 'install-sh -d' without argument. # This can happen when creating conditional directories. exit 0 fi if test -z "$dir_arg"; then do_exit='(exit $ret); exit $ret' trap "ret=129; $do_exit" 1 trap "ret=130; $do_exit" 2 trap "ret=141; $do_exit" 13 trap "ret=143; $do_exit" 15 # Set umask so as not to create temps with too-generous modes. # However, 'strip' requires both read and write access to temps. case $mode in # Optimize common cases. *644) cp_umask=133;; *755) cp_umask=22;; *[0-7]) if test -z "$stripcmd"; then u_plus_rw= else u_plus_rw='% 200' fi cp_umask=`expr '(' 777 - $mode % 1000 ')' $u_plus_rw`;; *) if test -z "$stripcmd"; then u_plus_rw= else u_plus_rw=,u+rw fi cp_umask=$mode$u_plus_rw;; esac fi for src do # Protect names problematic for 'test' and other utilities. case $src in -* | [=\(\)!]) src=./$src;; esac if test -n "$dir_arg"; then dst=$src dstdir=$dst test -d "$dstdir" dstdir_status=$? else # Waiting for this to be detected by the "$cpprog $src $dsttmp" command # might cause directories to be created, which would be especially bad # if $src (and thus $dsttmp) contains '*'. if test ! -f "$src" && test ! -d "$src"; then echo "$0: $src does not exist." >&2 exit 1 fi if test -z "$dst_arg"; then echo "$0: no destination specified." >&2 exit 1 fi dst=$dst_arg # If destination is a directory, append the input filename; won't work # if double slashes aren't ignored. if test -d "$dst"; then if test -n "$no_target_directory"; then echo "$0: $dst_arg: Is a directory" >&2 exit 1 fi dstdir=$dst dst=$dstdir/`basename "$src"` dstdir_status=0 else # Prefer dirname, but fall back on a substitute if dirname fails. dstdir=` (dirname "$dst") 2>/dev/null || expr X"$dst" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$dst" : 'X\(//\)[^/]' \| \ X"$dst" : 'X\(//\)$' \| \ X"$dst" : 'X\(/\)' \| . 2>/dev/null || echo X"$dst" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q } /^X\(\/\/\)[^/].*/{ s//\1/ q } /^X\(\/\/\)$/{ s//\1/ q } /^X\(\/\).*/{ s//\1/ q } s/.*/./; q' ` test -d "$dstdir" dstdir_status=$? fi fi obsolete_mkdir_used=false if test $dstdir_status != 0; then case $posix_mkdir in '') # Create intermediate dirs using mode 755 as modified by the umask. # This is like FreeBSD 'install' as of 1997-10-28. umask=`umask` case $stripcmd.$umask in # Optimize common cases. *[2367][2367]) mkdir_umask=$umask;; .*0[02][02] | .[02][02] | .[02]) mkdir_umask=22;; *[0-7]) mkdir_umask=`expr $umask + 22 \ - $umask % 100 % 40 + $umask % 20 \ - $umask % 10 % 4 + $umask % 2 `;; *) mkdir_umask=$umask,go-w;; esac # With -d, create the new directory with the user-specified mode. # Otherwise, rely on $mkdir_umask. if test -n "$dir_arg"; then mkdir_mode=-m$mode else mkdir_mode= fi posix_mkdir=false case $umask in *[123567][0-7][0-7]) # POSIX mkdir -p sets u+wx bits regardless of umask, which # is incompatible with FreeBSD 'install' when (umask & 300) != 0. ;; *) tmpdir=${TMPDIR-/tmp}/ins$RANDOM-$$ trap 'ret=$?; rmdir "$tmpdir/d" "$tmpdir" 2>/dev/null; exit $ret' 0 if (umask $mkdir_umask && exec $mkdirprog $mkdir_mode -p -- "$tmpdir/d") >/dev/null 2>&1 then if test -z "$dir_arg" || { # Check for POSIX incompatibilities with -m. # HP-UX 11.23 and IRIX 6.5 mkdir -m -p sets group- or # other-writable bit of parent directory when it shouldn't. # FreeBSD 6.1 mkdir -m -p sets mode of existing directory. ls_ld_tmpdir=`ls -ld "$tmpdir"` case $ls_ld_tmpdir in d????-?r-*) different_mode=700;; d????-?--*) different_mode=755;; *) false;; esac && $mkdirprog -m$different_mode -p -- "$tmpdir" && { ls_ld_tmpdir_1=`ls -ld "$tmpdir"` test "$ls_ld_tmpdir" = "$ls_ld_tmpdir_1" } } then posix_mkdir=: fi rmdir "$tmpdir/d" "$tmpdir" else # Remove any dirs left behind by ancient mkdir implementations. rmdir ./$mkdir_mode ./-p ./-- 2>/dev/null fi trap '' 0;; esac;; esac if $posix_mkdir && ( umask $mkdir_umask && $doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir" ) then : else # The umask is ridiculous, or mkdir does not conform to POSIX, # or it failed possibly due to a race condition. Create the # directory the slow way, step by step, checking for races as we go. case $dstdir in /*) prefix='/';; [-=\(\)!]*) prefix='./';; *) prefix='';; esac eval "$initialize_posix_glob" oIFS=$IFS IFS=/ $posix_glob set -f set fnord $dstdir shift $posix_glob set +f IFS=$oIFS prefixes= for d do test X"$d" = X && continue prefix=$prefix$d if test -d "$prefix"; then prefixes= else if $posix_mkdir; then (umask=$mkdir_umask && $doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir") && break # Don't fail if two instances are running concurrently. test -d "$prefix" || exit 1 else case $prefix in *\'*) qprefix=`echo "$prefix" | sed "s/'/'\\\\\\\\''/g"`;; *) qprefix=$prefix;; esac prefixes="$prefixes '$qprefix'" fi fi prefix=$prefix/ done if test -n "$prefixes"; then # Don't fail if two instances are running concurrently. (umask $mkdir_umask && eval "\$doit_exec \$mkdirprog $prefixes") || test -d "$dstdir" || exit 1 obsolete_mkdir_used=true fi fi fi if test -n "$dir_arg"; then { test -z "$chowncmd" || $doit $chowncmd "$dst"; } && { test -z "$chgrpcmd" || $doit $chgrpcmd "$dst"; } && { test "$obsolete_mkdir_used$chowncmd$chgrpcmd" = false || test -z "$chmodcmd" || $doit $chmodcmd $mode "$dst"; } || exit 1 else # Make a couple of temp file names in the proper directory. dsttmp=$dstdir/_inst.$$_ rmtmp=$dstdir/_rm.$$_ # Trap to clean up those temp files at exit. trap 'ret=$?; rm -f "$dsttmp" "$rmtmp" && exit $ret' 0 # Copy the file name to the temp name. (umask $cp_umask && $doit_exec $cpprog "$src" "$dsttmp") && # and set any options; do chmod last to preserve setuid bits. # # If any of these fail, we abort the whole thing. If we want to # ignore errors from any of these, just make sure not to ignore # errors from the above "$doit $cpprog $src $dsttmp" command. # { test -z "$chowncmd" || $doit $chowncmd "$dsttmp"; } && { test -z "$chgrpcmd" || $doit $chgrpcmd "$dsttmp"; } && { test -z "$stripcmd" || $doit $stripcmd "$dsttmp"; } && { test -z "$chmodcmd" || $doit $chmodcmd $mode "$dsttmp"; } && # If -C, don't bother to copy if it wouldn't change the file. if $copy_on_change && old=`LC_ALL=C ls -dlL "$dst" 2>/dev/null` && new=`LC_ALL=C ls -dlL "$dsttmp" 2>/dev/null` && eval "$initialize_posix_glob" && $posix_glob set -f && set X $old && old=:$2:$4:$5:$6 && set X $new && new=:$2:$4:$5:$6 && $posix_glob set +f && test "$old" = "$new" && $cmpprog "$dst" "$dsttmp" >/dev/null 2>&1 then rm -f "$dsttmp" else # Rename the file to the real destination. $doit $mvcmd -f "$dsttmp" "$dst" 2>/dev/null || # The rename failed, perhaps because mv can't rename something else # to itself, or perhaps because mv is so ancient that it does not # support -f. { # Now remove or move aside any old file at destination location. # We try this two ways since rm can't unlink itself on some # systems and the destination file might be busy for other # reasons. In this case, the final cleanup might fail but the new # file should still install successfully. { test ! -f "$dst" || $doit $rmcmd -f "$dst" 2>/dev/null || { $doit $mvcmd -f "$dst" "$rmtmp" 2>/dev/null && { $doit $rmcmd -f "$rmtmp" 2>/dev/null; :; } } || { echo "$0: cannot unlink or rename $dst" >&2 (exit 1); exit 1 } } && # Now rename the file to the real destination. $doit $mvcmd "$dsttmp" "$dst" } fi || exit 1 trap '' 0 fi done # Local variables: # eval: (add-hook 'write-file-hooks 'time-stamp) # time-stamp-start: "scriptversion=" # time-stamp-format: "%:y-%02m-%02d.%02H" # time-stamp-time-zone: "UTC" # time-stamp-end: "; # UTC" # End: ldns-1.6.17/drill/0000775000175100017510000000000012264060171013223 5ustar willemwillemldns-1.6.17/drill/chasetrace.c0000664000175100017510000002325112264060151015472 0ustar willemwillem/* * chasetrace.c * Where all the hard work concerning chasing * and tracing is done * (c) 2005, 2006 NLnet Labs * * See the file LICENSE for the license * */ #include "drill.h" #include /** * trace down from the root to name */ /* same naive method as in drill0.9 * We resolver _ALL_ the names, which is ofcourse not needed * We _do_ use the local resolver to do that, so it still is * fast, but it can be made to run much faster */ ldns_pkt * do_trace(ldns_resolver *local_res, ldns_rdf *name, ldns_rr_type t, ldns_rr_class c) { ldns_resolver *res; ldns_pkt *p; ldns_rr_list *new_nss_a; ldns_rr_list *new_nss_aaaa; ldns_rr_list *final_answer; ldns_rr_list *new_nss; ldns_rr_list *ns_addr; uint16_t loop_count; ldns_rdf *pop; ldns_status status; size_t i; loop_count = 0; new_nss_a = NULL; new_nss_aaaa = NULL; new_nss = NULL; ns_addr = NULL; final_answer = NULL; p = ldns_pkt_new(); res = ldns_resolver_new(); if (!p) { if (res) { ldns_resolver_free(res); } error("Memory allocation failed"); return NULL; } if (!res) { ldns_pkt_free(p); error("Memory allocation failed"); return NULL; } /* transfer some properties of local_res to res, * because they were given on the commandline */ ldns_resolver_set_ip6(res, ldns_resolver_ip6(local_res)); ldns_resolver_set_port(res, ldns_resolver_port(local_res)); ldns_resolver_set_debug(res, ldns_resolver_debug(local_res)); ldns_resolver_set_dnssec(res, ldns_resolver_dnssec(local_res)); ldns_resolver_set_fail(res, ldns_resolver_fail(local_res)); ldns_resolver_set_usevc(res, ldns_resolver_usevc(local_res)); ldns_resolver_set_random(res, ldns_resolver_random(local_res)); ldns_resolver_set_source(res, ldns_resolver_source(local_res)); ldns_resolver_set_recursive(res, false); /* setup the root nameserver in the new resolver */ status = ldns_resolver_push_nameserver_rr_list(res, global_dns_root); if (status != LDNS_STATUS_OK) { fprintf(stderr, "Error adding root servers to resolver: %s\n", ldns_get_errorstr_by_id(status)); ldns_rr_list_print(stdout, global_dns_root); ldns_resolver_free(res); ldns_pkt_free(p); return NULL; } /* this must be a real query to local_res */ status = ldns_resolver_send(&p, res, ldns_dname_new_frm_str("."), LDNS_RR_TYPE_NS, c, 0); /* p can still be NULL */ if (ldns_pkt_empty(p)) { warning("No root server information received"); } if (status == LDNS_STATUS_OK) { if (!ldns_pkt_empty(p)) { drill_pkt_print(stdout, local_res, p); } } else { error("cannot use local resolver"); return NULL; } status = ldns_resolver_send(&p, res, name, t, c, 0); while(status == LDNS_STATUS_OK && ldns_pkt_reply_type(p) == LDNS_PACKET_REFERRAL) { if (!p) { /* some error occurred, bail out */ return NULL; } new_nss_a = ldns_pkt_rr_list_by_type(p, LDNS_RR_TYPE_A, LDNS_SECTION_ADDITIONAL); new_nss_aaaa = ldns_pkt_rr_list_by_type(p, LDNS_RR_TYPE_AAAA, LDNS_SECTION_ADDITIONAL); new_nss = ldns_pkt_rr_list_by_type(p, LDNS_RR_TYPE_NS, LDNS_SECTION_AUTHORITY); if (verbosity != -1) { ldns_rr_list_print(stdout, new_nss); } /* checks itself for verbosity */ drill_pkt_print_footer(stdout, local_res, p); /* remove the old nameserver from the resolver */ while(ldns_resolver_pop_nameserver(res)) { /* do it */ } /* also check for new_nss emptyness */ if (!new_nss_aaaa && !new_nss_a) { /* * no nameserver found!!! * try to resolve the names we do got */ for(i = 0; i < ldns_rr_list_rr_count(new_nss); i++) { /* get the name of the nameserver */ pop = ldns_rr_rdf(ldns_rr_list_rr(new_nss, i), 0); if (!pop) { break; } ldns_rr_list_print(stdout, new_nss); ldns_rdf_print(stdout, pop); /* retrieve it's addresses */ ns_addr = ldns_rr_list_cat_clone(ns_addr, ldns_get_rr_list_addr_by_name(local_res, pop, c, 0)); } if (ns_addr) { if (ldns_resolver_push_nameserver_rr_list(res, ns_addr) != LDNS_STATUS_OK) { error("Error adding new nameservers"); ldns_pkt_free(p); return NULL; } ldns_rr_list_free(ns_addr); } else { ldns_rr_list_print(stdout, ns_addr); error("Could not find the nameserver ip addr; abort"); ldns_pkt_free(p); return NULL; } } /* add the new ones */ if (new_nss_aaaa) { if (ldns_resolver_push_nameserver_rr_list(res, new_nss_aaaa) != LDNS_STATUS_OK) { error("adding new nameservers"); ldns_pkt_free(p); return NULL; } } if (new_nss_a) { if (ldns_resolver_push_nameserver_rr_list(res, new_nss_a) != LDNS_STATUS_OK) { error("adding new nameservers"); ldns_pkt_free(p); return NULL; } } if (loop_count++ > 20) { /* unlikely that we are doing something usefull */ error("Looks like we are looping"); ldns_pkt_free(p); return NULL; } status = ldns_resolver_send(&p, res, name, t, c, 0); new_nss_aaaa = NULL; new_nss_a = NULL; ns_addr = NULL; } status = ldns_resolver_send(&p, res, name, t, c, 0); if (!p) { return NULL; } new_nss = ldns_pkt_authority(p); final_answer = ldns_pkt_answer(p); if (verbosity != -1) { ldns_rr_list_print(stdout, final_answer); ldns_rr_list_print(stdout, new_nss); } drill_pkt_print_footer(stdout, local_res, p); ldns_pkt_free(p); return NULL; } /** * Chase the given rr to a known and trusted key * * Based on drill 0.9 * * the last argument prev_key_list, if not null, and type == DS, then the ds * rr list we have must all be a ds for the keys in this list */ #ifdef HAVE_SSL ldns_status do_chase(ldns_resolver *res, ldns_rdf *name, ldns_rr_type type, ldns_rr_class c, ldns_rr_list *trusted_keys, ldns_pkt *pkt_o, uint16_t qflags, ldns_rr_list * ATTR_UNUSED(prev_key_list), int verbosity) { ldns_rr_list *rrset = NULL; ldns_status result; ldns_rr *orig_rr = NULL; /* ldns_rr_list *sigs; ldns_rr *cur_sig; uint16_t sig_i; ldns_rr_list *keys; */ ldns_pkt *pkt; ldns_status tree_result; ldns_dnssec_data_chain *chain; ldns_dnssec_trust_tree *tree; const ldns_rr_descriptor *descriptor; descriptor = ldns_rr_descript(type); ldns_dname2canonical(name); pkt = ldns_pkt_clone(pkt_o); if (!name) { mesg("No name to chase"); ldns_pkt_free(pkt); return LDNS_STATUS_EMPTY_LABEL; } if (verbosity != -1) { printf(";; Chasing: "); ldns_rdf_print(stdout, name); if (descriptor && descriptor->_name) { printf(" %s\n", descriptor->_name); } else { printf(" type %d\n", type); } } if (!trusted_keys || ldns_rr_list_rr_count(trusted_keys) < 1) { warning("No trusted keys specified"); } if (pkt) { rrset = ldns_pkt_rr_list_by_name_and_type(pkt, name, type, LDNS_SECTION_ANSWER ); if (!rrset) { /* nothing in answer, try authority */ rrset = ldns_pkt_rr_list_by_name_and_type(pkt, name, type, LDNS_SECTION_AUTHORITY ); } /* answer might be a cname, chase that first, then chase cname target? (TODO) */ if (!rrset) { rrset = ldns_pkt_rr_list_by_name_and_type(pkt, name, LDNS_RR_TYPE_CNAME, LDNS_SECTION_ANSWER ); if (!rrset) { /* nothing in answer, try authority */ rrset = ldns_pkt_rr_list_by_name_and_type(pkt, name, LDNS_RR_TYPE_CNAME, LDNS_SECTION_AUTHORITY ); } } } else { /* no packet? */ if (verbosity >= 0) { fprintf(stderr, "%s", ldns_get_errorstr_by_id(LDNS_STATUS_MEM_ERR)); fprintf(stderr, "\n"); } return LDNS_STATUS_MEM_ERR; } if (!rrset) { /* not found in original packet, try again */ ldns_pkt_free(pkt); pkt = NULL; pkt = ldns_resolver_query(res, name, type, c, qflags); if (!pkt) { if (verbosity >= 0) { fprintf(stderr, "%s", ldns_get_errorstr_by_id(LDNS_STATUS_NETWORK_ERR)); fprintf(stderr, "\n"); } return LDNS_STATUS_NETWORK_ERR; } if (verbosity >= 5) { ldns_pkt_print(stdout, pkt); } rrset = ldns_pkt_rr_list_by_name_and_type(pkt, name, type, LDNS_SECTION_ANSWER ); } orig_rr = ldns_rr_new(); /* if the answer had no answer section, we need to construct our own rr (for instance if * the rr qe asked for doesn't exist. This rr will be destroyed when the chain is freed */ if (ldns_pkt_ancount(pkt) < 1) { ldns_rr_set_type(orig_rr, type); ldns_rr_set_owner(orig_rr, ldns_rdf_clone(name)); chain = ldns_dnssec_build_data_chain(res, qflags, rrset, pkt, ldns_rr_clone(orig_rr)); } else { /* chase the first answer */ chain = ldns_dnssec_build_data_chain(res, qflags, rrset, pkt, NULL); } if (verbosity >= 4) { printf("\n\nDNSSEC Data Chain:\n"); ldns_dnssec_data_chain_print(stdout, chain); } result = LDNS_STATUS_OK; tree = ldns_dnssec_derive_trust_tree(chain, NULL); if (verbosity >= 2) { printf("\n\nDNSSEC Trust tree:\n"); ldns_dnssec_trust_tree_print(stdout, tree, 0, true); } if (ldns_rr_list_rr_count(trusted_keys) > 0) { tree_result = ldns_dnssec_trust_tree_contains_keys(tree, trusted_keys); if (tree_result == LDNS_STATUS_DNSSEC_EXISTENCE_DENIED) { if (verbosity >= 1) { printf("Existence denied or verifiably insecure\n"); } result = LDNS_STATUS_OK; } else if (tree_result != LDNS_STATUS_OK) { if (verbosity >= 1) { printf("No trusted keys found in tree: first error was: %s\n", ldns_get_errorstr_by_id(tree_result)); } result = tree_result; } } else { if (verbosity >= 0) { printf("You have not provided any trusted keys.\n"); } } ldns_rr_free(orig_rr); ldns_dnssec_trust_tree_free(tree); ldns_dnssec_data_chain_deep_free(chain); ldns_rr_list_deep_free(rrset); ldns_pkt_free(pkt); /* ldns_rr_free(orig_rr);*/ return result; } #endif /* HAVE_SSL */ ldns-1.6.17/drill/dnssec.c0000664000175100017510000003207512264060151014653 0ustar willemwillem/* * dnssec.c * Some DNSSEC helper function are defined here * and tracing is done * (c) 2005 NLnet Labs * * See the file LICENSE for the license * */ #include "drill.h" #include /* get rr_type from a server from a server */ ldns_rr_list * get_rr(ldns_resolver *res, ldns_rdf *zname, ldns_rr_type t, ldns_rr_class c) { /* query, retrieve, extract and return */ ldns_pkt *p; ldns_rr_list *found; p = ldns_pkt_new(); found = NULL; if (ldns_resolver_send(&p, res, zname, t, c, 0) == LDNS_STATUS_OK) { found = ldns_pkt_rr_list_by_type(p, t, LDNS_SECTION_ANY_NOQUESTION); } ldns_pkt_free(p); return found; } void drill_pkt_print(FILE *fd, ldns_resolver *r, ldns_pkt *p) { ldns_rr_list *new_nss; ldns_rr_list *hostnames; char *answerfrom_str; if (verbosity < 5) { return; } hostnames = ldns_get_rr_list_name_by_addr(r, ldns_pkt_answerfrom(p), 0, 0); new_nss = ldns_pkt_rr_list_by_type(p, LDNS_RR_TYPE_NS, LDNS_SECTION_ANSWER); ldns_rr_list_print(fd, new_nss); ldns_rr_list_deep_free(new_nss); fprintf(fd, ";; Received %d bytes from %s#%d(", (int) ldns_pkt_size(p), ldns_rdf2str(ldns_pkt_answerfrom(p)), (int) ldns_resolver_port(r)); /* if we can resolve this print it, other print the ip again */ if (hostnames) { ldns_rdf_print(fd, ldns_rr_rdf(ldns_rr_list_rr(hostnames, 0), 0)); ldns_rr_list_deep_free(hostnames); } else { answerfrom_str = ldns_rdf2str(ldns_pkt_answerfrom(p)); if (answerfrom_str) { fprintf(fd, "%s", answerfrom_str); LDNS_FREE(answerfrom_str); } } fprintf(fd, ") in %u ms\n\n", (unsigned int)ldns_pkt_querytime(p)); } void drill_pkt_print_footer(FILE *fd, ldns_resolver *r, ldns_pkt *p) { ldns_rr_list *hostnames; char *answerfrom_str; if (verbosity < 5) { return; } hostnames = ldns_get_rr_list_name_by_addr(r, ldns_pkt_answerfrom(p), 0, 0); fprintf(fd, ";; Received %d bytes from %s#%d(", (int) ldns_pkt_size(p), ldns_rdf2str(ldns_pkt_answerfrom(p)), (int) ldns_resolver_port(r)); /* if we can resolve this print it, other print the ip again */ if (hostnames) { ldns_rdf_print(fd, ldns_rr_rdf(ldns_rr_list_rr(hostnames, 0), 0)); ldns_rr_list_deep_free(hostnames); } else { answerfrom_str = ldns_rdf2str(ldns_pkt_answerfrom(p)); if (answerfrom_str) { fprintf(fd, "%s", answerfrom_str); LDNS_FREE(answerfrom_str); } } fprintf(fd, ") in %u ms\n\n", (unsigned int)ldns_pkt_querytime(p)); } /* * generic function to get some RRset from a nameserver * and possible some signatures too (that would be the day...) */ ldns_pkt_type get_dnssec_rr(ldns_pkt *p, ldns_rdf *name, ldns_rr_type t, ldns_rr_list **rrlist, ldns_rr_list **sig) { ldns_pkt_type pt = LDNS_PACKET_UNKNOWN; ldns_rr_list *sigs = NULL; size_t i; if (!p) { if (rrlist) { *rrlist = NULL; } return LDNS_PACKET_UNKNOWN; } pt = ldns_pkt_reply_type(p); if (name) { if (rrlist) { *rrlist = ldns_pkt_rr_list_by_name_and_type(p, name, t, LDNS_SECTION_ANSWER); if (!*rrlist) { *rrlist = ldns_pkt_rr_list_by_name_and_type( p, name, t, LDNS_SECTION_AUTHORITY); } } if (sig) { sigs = ldns_pkt_rr_list_by_name_and_type(p, name, LDNS_RR_TYPE_RRSIG, LDNS_SECTION_ANSWER); if (!sigs) { sigs = ldns_pkt_rr_list_by_name_and_type( p, name, LDNS_RR_TYPE_RRSIG, LDNS_SECTION_AUTHORITY); } } } else { /* A DS-referral - get the DS records if they are there */ if (rrlist) { *rrlist = ldns_pkt_rr_list_by_type( p, t, LDNS_SECTION_AUTHORITY); } if (sig) { sigs = ldns_pkt_rr_list_by_type(p, LDNS_RR_TYPE_RRSIG, LDNS_SECTION_AUTHORITY); } } if (sig) { *sig = ldns_rr_list_new(); for (i = 0; i < ldns_rr_list_rr_count(sigs); i++) { /* only add the sigs that cover this type */ if (t == ldns_rdf2rr_type(ldns_rr_rrsig_typecovered( ldns_rr_list_rr(sigs, i)))) { ldns_rr_list_push_rr(*sig, ldns_rr_clone( ldns_rr_list_rr( sigs, i))); } } } ldns_rr_list_deep_free(sigs); if (pt == LDNS_PACKET_NXDOMAIN || pt == LDNS_PACKET_NODATA) { return pt; } else { return LDNS_PACKET_ANSWER; } } ldns_status ldns_verify_denial(ldns_pkt *pkt, ldns_rdf *name, ldns_rr_type type, ldns_rr_list **nsec_rrs, ldns_rr_list **nsec_rr_sigs) { #ifdef HAVE_SSL uint16_t nsec_i; ldns_rr_list *nsecs; ldns_status result; if (verbosity >= 5) { printf("VERIFY DENIAL FROM:\n"); ldns_pkt_print(stdout, pkt); } result = LDNS_STATUS_CRYPTO_NO_RRSIG; /* Try to see if there are NSECS in the packet */ nsecs = ldns_pkt_rr_list_by_type(pkt, LDNS_RR_TYPE_NSEC, LDNS_SECTION_ANY_NOQUESTION); if (nsecs) { for (nsec_i = 0; nsec_i < ldns_rr_list_rr_count(nsecs); nsec_i++) { /* there are four options: * - name equals ownername and is covered by the type bitmap * - name equals ownername but is not covered by the type bitmap * - name falls within nsec coverage but is not equal to the owner name * - name falls outside of nsec coverage */ if (ldns_dname_compare(ldns_rr_owner(ldns_rr_list_rr(nsecs, nsec_i)), name) == 0) { /* printf("CHECKING NSEC:\n"); ldns_rr_print(stdout, ldns_rr_list_rr(nsecs, nsec_i)); printf("DAWASEM\n"); */ if (ldns_nsec_bitmap_covers_type( ldns_nsec_get_bitmap(ldns_rr_list_rr(nsecs, nsec_i)), type)) { /* Error, according to the nsec this rrset is signed */ result = LDNS_STATUS_CRYPTO_NO_RRSIG; } else { /* ok nsec denies existence */ if (verbosity >= 3) { printf(";; Existence of data set with this type denied by NSEC\n"); } /*printf(";; Verifiably insecure.\n");*/ if (nsec_rrs && nsec_rr_sigs) { (void) get_dnssec_rr(pkt, ldns_rr_owner(ldns_rr_list_rr(nsecs, nsec_i)), LDNS_RR_TYPE_NSEC, nsec_rrs, nsec_rr_sigs); } ldns_rr_list_deep_free(nsecs); return LDNS_STATUS_OK; } } else if (ldns_nsec_covers_name(ldns_rr_list_rr(nsecs, nsec_i), name)) { if (verbosity >= 3) { printf(";; Existence of data set with this name denied by NSEC\n"); } if (nsec_rrs && nsec_rr_sigs) { (void) get_dnssec_rr(pkt, ldns_rr_owner(ldns_rr_list_rr(nsecs, nsec_i)), LDNS_RR_TYPE_NSEC, nsec_rrs, nsec_rr_sigs); } ldns_rr_list_deep_free(nsecs); return LDNS_STATUS_OK; } else { /* nsec has nothing to do with this data */ } } ldns_rr_list_deep_free(nsecs); } else if( (nsecs = ldns_pkt_rr_list_by_type(pkt, LDNS_RR_TYPE_NSEC3, LDNS_SECTION_ANY_NOQUESTION)) ) { ldns_rr_list* sigs = ldns_pkt_rr_list_by_type(pkt, LDNS_RR_TYPE_RRSIG, LDNS_SECTION_ANY_NOQUESTION); ldns_rr* q = ldns_rr_new(); ldns_rr* match = NULL; if(!sigs) { if (q) { ldns_rr_free(q); } ldns_rr_list_deep_free(nsecs); return LDNS_STATUS_MEM_ERR; } if(!q) { ldns_rr_list_deep_free(nsecs); ldns_rr_list_deep_free(sigs); return LDNS_STATUS_MEM_ERR; } ldns_rr_set_question(q, 1); ldns_rr_set_ttl(q, 0); ldns_rr_set_owner(q, ldns_rdf_clone(name)); if(!ldns_rr_owner(q)) { ldns_rr_free(q); ldns_rr_list_deep_free(sigs); ldns_rr_list_deep_free(nsecs); return LDNS_STATUS_MEM_ERR; } ldns_rr_set_type(q, type); /* result = ldns_dnssec_verify_denial_nsec3(q, nsecs, sigs, ldns_pkt_get_rcode(pkt), type, ldns_pkt_ancount(pkt) == 0); */ result = ldns_dnssec_verify_denial_nsec3_match(q, nsecs, sigs, ldns_pkt_get_rcode(pkt), type, ldns_pkt_ancount(pkt) == 0, &match); if (result == LDNS_STATUS_OK && match && nsec_rrs && nsec_rr_sigs) { (void) get_dnssec_rr(pkt, ldns_rr_owner(match), LDNS_RR_TYPE_NSEC3, nsec_rrs, nsec_rr_sigs); } ldns_rr_free(q); ldns_rr_list_deep_free(nsecs); ldns_rr_list_deep_free(sigs); } return result; #else (void)pkt; (void)name; (void)type; (void)nsec_rrs; (void)nsec_rr_sigs; return LDNS_STATUS_ERR; #endif /* HAVE_SSL */ } /* NSEC3 draft -07 */ /*return hash name match*/ ldns_rr * ldns_nsec3_exact_match(ldns_rdf *qname, ldns_rr_type qtype, ldns_rr_list *nsec3s) { uint8_t algorithm; uint32_t iterations; uint8_t salt_length; uint8_t *salt; ldns_rdf *sname = NULL, *hashed_sname = NULL; size_t nsec_i; ldns_rr *nsec; ldns_rr *result = NULL; const ldns_rr_descriptor *descriptor; ldns_rdf *zone_name = NULL; if (verbosity >= 4) { printf(";; finding exact match for "); descriptor = ldns_rr_descript(qtype); if (descriptor && descriptor->_name) { printf("%s ", descriptor->_name); } else { printf("TYPE%d ", qtype); } ldns_rdf_print(stdout, qname); printf("\n"); } if (!qname || !nsec3s || ldns_rr_list_rr_count(nsec3s) < 1) { if (verbosity >= 4) { printf("no qname, nsec3s or list empty\n"); } return NULL; } nsec = ldns_rr_list_rr(nsec3s, 0); algorithm = ldns_nsec3_algorithm(nsec); salt_length = ldns_nsec3_salt_length(nsec); salt = ldns_nsec3_salt_data(nsec); iterations = ldns_nsec3_iterations(nsec); if (salt == NULL) { goto done; } sname = ldns_rdf_clone(qname); if (sname == NULL) { goto done; } if (verbosity >= 4) { printf(";; owner name hashes to: "); } hashed_sname = ldns_nsec3_hash_name(sname, algorithm, iterations, salt_length, salt); if (hashed_sname == NULL) { goto done; } zone_name = ldns_dname_left_chop(ldns_rr_owner(nsec)); if (zone_name == NULL) { goto done; } if (ldns_dname_cat(hashed_sname, zone_name) != LDNS_STATUS_OK) { goto done; }; if (verbosity >= 4) { ldns_rdf_print(stdout, hashed_sname); printf("\n"); } for (nsec_i = 0; nsec_i < ldns_rr_list_rr_count(nsec3s); nsec_i++) { nsec = ldns_rr_list_rr(nsec3s, nsec_i); /* check values of iterations etc! */ /* exact match? */ if (ldns_dname_compare(ldns_rr_owner(nsec), hashed_sname) == 0) { result = nsec; goto done; } } done: ldns_rdf_deep_free(zone_name); ldns_rdf_deep_free(sname); ldns_rdf_deep_free(hashed_sname); LDNS_FREE(salt); if (verbosity >= 4) { if (result) { printf(";; Found.\n"); } else { printf(";; Not foud.\n"); } } return result; } /*return the owner name of the closest encloser for name from the list of rrs */ /* this is NOT the hash, but the original name! */ ldns_rdf * ldns_nsec3_closest_encloser(ldns_rdf *qname, ldns_rr_type qtype, ldns_rr_list *nsec3s) { /* remember parameters, they must match */ uint8_t algorithm; uint32_t iterations; uint8_t salt_length; uint8_t *salt; ldns_rdf *sname = NULL, *hashed_sname = NULL, *tmp; bool flag; bool exact_match_found; bool in_range_found; ldns_rdf *zone_name = NULL; size_t nsec_i; ldns_rr *nsec; ldns_rdf *result = NULL; if (!qname || !nsec3s || ldns_rr_list_rr_count(nsec3s) < 1) { return NULL; } if (verbosity >= 4) { printf(";; finding closest encloser for type %d ", qtype); ldns_rdf_print(stdout, qname); printf("\n"); } nsec = ldns_rr_list_rr(nsec3s, 0); algorithm = ldns_nsec3_algorithm(nsec); salt_length = ldns_nsec3_salt_length(nsec); salt = ldns_nsec3_salt_data(nsec); iterations = ldns_nsec3_iterations(nsec); if (salt == NULL) { goto done; } sname = ldns_rdf_clone(qname); if (sname == NULL) { goto done; } flag = false; zone_name = ldns_dname_left_chop(ldns_rr_owner(nsec)); if (zone_name == NULL) { goto done; } /* algorithm from nsec3-07 8.3 */ while (ldns_dname_label_count(sname) > 0) { exact_match_found = false; in_range_found = false; if (verbosity >= 3) { printf(";; "); ldns_rdf_print(stdout, sname); printf(" hashes to: "); } hashed_sname = ldns_nsec3_hash_name(sname, algorithm, iterations, salt_length, salt); if (hashed_sname == NULL) { goto done; } if (ldns_dname_cat(hashed_sname, zone_name) != LDNS_STATUS_OK){ goto done; } if (verbosity >= 3) { ldns_rdf_print(stdout, hashed_sname); printf("\n"); } for (nsec_i = 0; nsec_i < ldns_rr_list_rr_count(nsec3s); nsec_i++) { nsec = ldns_rr_list_rr(nsec3s, nsec_i); /* check values of iterations etc! */ /* exact match? */ if (ldns_dname_compare(ldns_rr_owner(nsec), hashed_sname) == 0) { if (verbosity >= 4) { printf(";; exact match found\n"); } exact_match_found = true; } else if (ldns_nsec_covers_name(nsec, hashed_sname)) { if (verbosity >= 4) { printf(";; in range of an nsec\n"); } in_range_found = true; } } if (!exact_match_found && in_range_found) { flag = true; } else if (exact_match_found && flag) { result = ldns_rdf_clone(sname); } else if (exact_match_found && !flag) { // error! if (verbosity >= 4) { printf(";; the closest encloser is the same name (ie. this is an exact match, ie there is no closest encloser)\n"); } ldns_rdf_deep_free(hashed_sname); goto done; } else { flag = false; } ldns_rdf_deep_free(hashed_sname); tmp = sname; sname = ldns_dname_left_chop(sname); ldns_rdf_deep_free(tmp); if (sname == NULL) { goto done; } } done: LDNS_FREE(salt); ldns_rdf_deep_free(zone_name); ldns_rdf_deep_free(sname); if (!result) { if (verbosity >= 4) { printf(";; no closest encloser found\n"); } } /* todo checks from end of 6.2. here or in caller? */ return result; } ldns-1.6.17/drill/error.c0000664000175100017510000000341312264060151014517 0ustar willemwillem/** * error.c * * error reporting routines * basicly wrappers around printf * * (c) 2005 NLnet Labs * * See the file LICENSE for the license * */ #include "drill.h" #include static void warning_va_list(const char *fmt, va_list args) { fprintf(stderr, "Warning: "); vfprintf(stderr, fmt, args); fprintf(stderr, "\n"); } void warning(const char *fmt, ...) { va_list args; va_start(args, fmt); warning_va_list(fmt, args); va_end(args); } static void error_va_list(const char *fmt, va_list args) { fprintf(stderr, "Error: "); vfprintf(stderr, fmt, args); fprintf(stderr, "\n"); } void error(const char *fmt, ...) { va_list args; va_start(args, fmt); error_va_list(fmt, args); va_end(args); exit(EXIT_FAILURE); } static void verbose_va_list(const char *fmt, va_list args) { vfprintf(stdout, fmt, args); fprintf(stdout, "\n"); } /* print stuff */ void mesg(const char *fmt, ...) { va_list args; if (verbosity == -1) { return; } fprintf(stdout, ";; "); va_start(args, fmt); verbose_va_list(fmt, args); va_end(args); } /* print stuff when in verbose mode (1) */ void verbose(const char *fmt, ...) { va_list args; if (verbosity < 1) { return; } va_start(args, fmt); verbose_va_list(fmt, args); va_end(args); } /* print stuff when in vverbose mode (2) */ void vverbose(const char *fmt, ...) { va_list args; if (verbosity < 2) { return; } va_start(args, fmt); verbose_va_list(fmt, args); va_end(args); } static void debug_va_list(const char *fmt, va_list args) { vfprintf(stderr, fmt, args); fprintf(stderr, "\n"); } void debug(const char *fmt, ...) { va_list args; fprintf(stderr, "[DEBUG] "); va_start(args, fmt); debug_va_list(fmt, args); va_end(args); } ldns-1.6.17/drill/Makefile.in0000664000175100017510000000574112264060151015275 0ustar willemwillem# Standard installation pathnames # See the file LICENSE for the license SHELL = @SHELL@ VERSION = @PACKAGE_VERSION@ basesrcdir = $(shell basename `pwd`) srcdir = @srcdir@ prefix = @prefix@ exec_prefix = @exec_prefix@ bindir = @bindir@ mandir = @mandir@ includedir = @includedir@ datarootdir = @datarootdir@ CC = @CC@ CFLAGS = -I. @CFLAGS@ CPPFLAGS = @CPPFLAGS@ LDFLAGS = @LDFLAGS@ LIBS = @LIBS@ INSTALL = $(srcdir)/install-sh -c INSTALL_PROGRAM = $(INSTALL) LDNSDIR = @LDNSDIR@ LIBS_STC = @LIBS_STC@ COMPILE = $(CC) $(CPPFLAGS) $(CFLAGS) -I. -I$(srcdir) LINK = $(CC) $(CFLAGS) $(LDFLAGS) LINT = splint LINTFLAGS=+quiet -weak -warnposix -unrecog -Din_addr_t=uint32_t -Du_int=unsigned -Du_char=uint8_t -preproc -Drlimit=rlimit64 -D__gnuc_va_list=va_list #-Dglob64=glob -Dglobfree64=globfree # compat with openssl linux edition. LINTFLAGS+="-DBN_ULONG=unsigned long" -Dkrb5_int32=int "-Dkrb5_ui_4=unsigned int" -DPQ_64BIT=uint64_t -DRC4_INT=unsigned -fixedformalarray -D"ENGINE=unsigned" -D"RSA=unsigned" -D"DSA=unsigned" -D"EVP_PKEY=unsigned" -D"EVP_MD=unsigned" -D"SSL=unsigned" -D"SSL_CTX=unsigned" -D"X509=unsigned" -D"RC4_KEY=unsigned" -D"EVP_MD_CTX=unsigned" # compat with NetBSD ifeq "$(shell uname)" "NetBSD" LINTFLAGS+="-D__RENAME(x)=" -D_NETINET_IN_H_ endif # compat with OpenBSD LINTFLAGS+="-Dsigset_t=long" # FreeBSD8 LINTFLAGS+="-D__uint16_t=uint16_t" LINTFLAGS+=-D__signed__=signed "-D__packed=" "-D__aligned(x)=" # Ubuntu Linux 11.04 LINTFLAGS+="-D__u16=struct __u16" "-D__u32=struct __u32" "-D__u64=struct __u64" OBJ=drill.o drill_util.o error.o root.o work.o chasetrace.o dnssec.o securetrace.o SRC=$(OBJ:.o=.c) HEADER=drill.h $(srcdir)/drill_util.h .PHONY: all clean realclean docclean doc release tags install all-static all: drill all-static: drill-stc tags: ctags *.[ch] drill: $(OBJ) $(LINK) -o drill $(OBJ) $(LIBS) drill-stc: $(OBJ) $(LINK) -o drill $(OBJ) $(LIBS_STC) ## implicit rule %.o: $(srcdir)/%.c $(COMPILE) -c $< clean: rm -f ${OBJ} rm -f drill rm -f *core rm -f config.h.in~ rm -f config.log rm -f config.guess rm -f config.status docclean: rm -rf doxydoc distclean: clean docclean rm -f config.h realclean: clean docclean rm -f tags rm -f config.log rm -f config.sub rm -f ltmain.sh rm -f config.status rm -rf autom4te.cache rm -f config.h rm -f config.h.in rm -f configure rm -f Makefile rm -f drill.1 rm -f aclocal.m4 doc: doxygen drill.doxygen install: all $(INSTALL) -d $(DESTDIR)$(bindir) $(INSTALL) drill $(DESTDIR)$(bindir)/drill $(INSTALL) -m 644 drill.1 $(DESTDIR)$(mandir)/man1/drill.1 uninstall: @echo rm -f -- $(DESTDIR)$(bindir)/drill rm -f -- $(DESTDIR)$(mandir)/man1/drill.1 rmdir -p $(DESTDIR)$(bindir) rmdir -p $(DESTDIR)$(mandir)/man1 @echo lint: @for i in $(SRC) ; do \ $(LINT) $(LINTFLAGS) $(CPPFLAGS) -I$(srcdir) $(srcdir)/$$i ; \ if [ $$? -ne 0 ] ; then exit 1 ; fi ; \ done confclean: clean rm -rf config.log config.status config.h Makefile drill.1 ldns-1.6.17/drill/drill.c0000664000175100017510000006513712264060151014507 0ustar willemwillem/* * drill.c * the main file of drill * (c) 2005-2008 NLnet Labs * * See the file LICENSE for the license * */ #include "drill.h" #include #ifdef HAVE_SSL #include #endif #define IP6_ARPA_MAX_LEN 65 /* query debug, 2 hex dumps */ int verbosity; static void usage(FILE *stream, const char *progname) { fprintf(stream, " Usage: %s name [@server] [type] [class]\n", progname); fprintf(stream, "\t can be a domain name or an IP address (-x lookups)\n"); fprintf(stream, "\t defaults to A\n"); fprintf(stream, "\t defaults to IN\n"); fprintf(stream, "\n\targuments may be placed in random order\n"); fprintf(stream, "\n Options:\n"); fprintf(stream, "\t-D\t\tenable DNSSEC (DO bit)\n"); #ifdef HAVE_SSL fprintf(stream, "\t-T\t\ttrace from the root down to \n"); fprintf(stream, "\t-S\t\tchase signature(s) from to a know key [*]\n"); #endif /*HAVE_SSL*/ fprintf(stream, "\t-I
\tsource address to query from\n"); fprintf(stream, "\t-V \tverbosity (0-5)\n"); fprintf(stream, "\t-Q\t\tquiet mode (overrules -V)\n"); fprintf(stream, "\n"); fprintf(stream, "\t-f file\t\tread packet from file and send it\n"); fprintf(stream, "\t-i file\t\tread packet from file and print it\n"); fprintf(stream, "\t-w file\t\twrite answer packet to file\n"); fprintf(stream, "\t-q file\t\twrite query packet to file\n"); fprintf(stream, "\t-h\t\tshow this help\n"); fprintf(stream, "\t-v\t\tshow version\n"); fprintf(stream, "\n Query options:\n"); fprintf(stream, "\t-4\t\tstay on ip4\n"); fprintf(stream, "\t-6\t\tstay on ip6\n"); fprintf(stream, "\t-a\t\tfallback to EDNS0 and TCP if the answer is truncated\n"); fprintf(stream, "\t-b \tuse as the buffer size (defaults to 512 b)\n"); fprintf(stream, "\t-c \tuse file for rescursive nameserver configuration" "\n\t\t\t(/etc/resolv.conf)\n"); fprintf(stream, "\t-k \tspecify a file that contains a trusted DNSSEC key [**]\n"); fprintf(stream, "\t\t\tUsed to verify any signatures in the current answer.\n"); fprintf(stream, "\t\t\tWhen DNSSEC enabled tracing (-TD) or signature\n" "\t\t\tchasing (-S) and no key files are given, keys are read\n" "\t\t\tfrom: %s\n", LDNS_TRUST_ANCHOR_FILE); fprintf(stream, "\t-o \tset flags to:" "\n\t\t\t[QR|qr][AA|aa][TC|tc][RD|rd][CD|cd][RA|ra][AD|ad]\n"); fprintf(stream, "\t\t\tlowercase: unset bit, uppercase: set bit\n"); fprintf(stream, "\t-p \tuse as remote port number\n"); fprintf(stream, "\t-s\t\tshow the DS RR for each key in a packet\n"); fprintf(stream, "\t-u\t\tsend the query with udp (the default)\n"); fprintf(stream, "\t-x\t\tdo a reverse lookup\n"); fprintf(stream, "\twhen doing a secure trace:\n"); fprintf(stream, "\t-r \tuse file as root servers hint file\n"); fprintf(stream, "\t-t\t\tsend the query with tcp (connected)\n"); fprintf(stream, "\t-d \tuse domain as the start point for the trace\n"); fprintf(stream, "\t-y \tspecify named base64 tsig key, and optional an\n\t\t\talgorithm (defaults to hmac-md5.sig-alg.reg.int)\n"); fprintf(stream, "\t-z\t\tdon't randomize the nameservers before use\n"); fprintf(stream, "\n [*] = enables/implies DNSSEC\n"); fprintf(stream, " [**] = can be given more than once\n"); fprintf(stream, "\n ldns-team@nlnetlabs.nl | http://www.nlnetlabs.nl/ldns/\n"); } /** * Prints the drill version to stderr */ static void version(FILE *stream, const char *progname) { fprintf(stream, "%s version %s (ldns version %s)\n", progname, DRILL_VERSION, ldns_version()); fprintf(stream, "Written by NLnet Labs.\n"); fprintf(stream, "\nCopyright (c) 2004-2008 NLnet Labs.\n"); fprintf(stream, "Licensed under the revised BSD license.\n"); fprintf(stream, "There is NO warranty; not even for MERCHANTABILITY or FITNESS\n"); fprintf(stream, "FOR A PARTICULAR PURPOSE.\n"); } /** * Main function of drill * parse the arguments and prepare a query */ int main(int argc, char *argv[]) { ldns_resolver *res = NULL; ldns_resolver *cmdline_res = NULL; /* only used to resolv @name names */ ldns_rr_list *cmdline_rr_list = NULL; ldns_rdf *cmdline_dname = NULL; ldns_rdf *qname, *qname_tmp; ldns_pkt *pkt; ldns_pkt *qpkt; char *serv; char *src = NULL; const char *name; char *name2; char *progname; char *query_file = NULL; char *answer_file = NULL; ldns_buffer *query_buffer = NULL; ldns_rdf *serv_rdf; ldns_rdf *src_rdf = NULL; ldns_rr_type type; ldns_rr_class clas; #if 0 ldns_pkt_opcode opcode = LDNS_PACKET_QUERY; #endif int i, c; int int_type; int int_clas; int PURPOSE; char *tsig_name = NULL; char *tsig_data = NULL; char *tsig_algorithm = NULL; size_t tsig_separator; size_t tsig_separator2; ldns_rr *axfr_rr; ldns_status status; char *type_str; /* list of keys used in dnssec operations */ ldns_rr_list *key_list = ldns_rr_list_new(); /* what key verify the current answer */ ldns_rr_list *key_verified; /* resolver options */ uint16_t qflags; uint16_t qbuf; uint16_t qport; uint8_t qfamily; bool qdnssec; bool qfallback; bool qds; bool qusevc; bool qrandom; char *resolv_conf_file = NULL; ldns_rdf *trace_start_name = NULL; int result = 0; #ifdef USE_WINSOCK int r; WSADATA wsa_data; #endif int_type = -1; serv = NULL; type = 0; int_clas = -1; name = NULL; clas = 0; qname = NULL; src = NULL; progname = strdup(argv[0]); #ifdef USE_WINSOCK r = WSAStartup(MAKEWORD(2,2), &wsa_data); if(r != 0) { printf("Failed WSAStartup: %d\n", r); result = EXIT_FAILURE; goto exit; } #endif /* USE_WINSOCK */ PURPOSE = DRILL_QUERY; qflags = LDNS_RD; qport = LDNS_PORT; verbosity = 2; qdnssec = false; qfamily = LDNS_RESOLV_INETANY; qfallback = false; qds = false; qbuf = 0; qusevc = false; qrandom = true; key_verified = NULL; ldns_init_random(NULL, 0); if (argc == 0) { usage(stdout, progname); result = EXIT_FAILURE; goto exit; } /* string from orig drill: "i:w:I46Sk:TNp:b:DsvhVcuaq:f:xr" */ /* global first, query opt next, option with parm's last * and sorted */ /* "46DITSVQf:i:w:q:achuvxzy:so:p:b:k:" */ while ((c = getopt(argc, argv, "46ab:c:d:Df:hi:I:k:o:p:q:Qr:sStTuvV:w:xy:z")) != -1) { switch(c) { /* global options */ case '4': qfamily = LDNS_RESOLV_INET; break; case '6': qfamily = LDNS_RESOLV_INET6; break; case 'D': qdnssec = true; break; case 'I': src = optarg; break; case 'T': if (PURPOSE == DRILL_CHASE) { fprintf(stderr, "-T and -S cannot be used at the same time.\n"); exit(EXIT_FAILURE); } PURPOSE = DRILL_TRACE; break; #ifdef HAVE_SSL case 'S': if (PURPOSE == DRILL_TRACE) { fprintf(stderr, "-T and -S cannot be used at the same time.\n"); exit(EXIT_FAILURE); } PURPOSE = DRILL_CHASE; break; #endif /* HAVE_SSL */ case 'V': if (strtok(optarg, "0123456789") != NULL) { fprintf(stderr, "-V expects an number as an argument.\n"); exit(EXIT_FAILURE); } verbosity = atoi(optarg); break; case 'Q': verbosity = -1; break; case 'f': query_file = optarg; break; case 'i': answer_file = optarg; PURPOSE = DRILL_AFROMFILE; break; case 'w': answer_file = optarg; break; case 'q': query_file = optarg; PURPOSE = DRILL_QTOFILE; break; case 'r': if (global_dns_root) { fprintf(stderr, "There was already a series of root servers set\n"); exit(EXIT_FAILURE); } global_dns_root = read_root_hints(optarg); if (!global_dns_root) { fprintf(stderr, "Unable to read root hints file %s, aborting\n", optarg); exit(EXIT_FAILURE); } break; /* query options */ case 'a': qfallback = true; break; case 'b': qbuf = (uint16_t)atoi(optarg); if (qbuf == 0) { error("%s", " could not be converted"); } break; case 'c': resolv_conf_file = optarg; break; case 't': qusevc = true; break; case 'k': status = read_key_file(optarg, key_list, false); if (status != LDNS_STATUS_OK) { error("Could not parse the key file %s: %s", optarg, ldns_get_errorstr_by_id(status)); } qdnssec = true; /* enable that too */ break; case 'o': /* only looks at the first hit: capital=ON, lowercase=OFF*/ if (strstr(optarg, "QR")) { DRILL_ON(qflags, LDNS_QR); } if (strstr(optarg, "qr")) { DRILL_OFF(qflags, LDNS_QR); } if (strstr(optarg, "AA")) { DRILL_ON(qflags, LDNS_AA); } if (strstr(optarg, "aa")) { DRILL_OFF(qflags, LDNS_AA); } if (strstr(optarg, "TC")) { DRILL_ON(qflags, LDNS_TC); } if (strstr(optarg, "tc")) { DRILL_OFF(qflags, LDNS_TC); } if (strstr(optarg, "RD")) { DRILL_ON(qflags, LDNS_RD); } if (strstr(optarg, "rd")) { DRILL_OFF(qflags, LDNS_RD); } if (strstr(optarg, "CD")) { DRILL_ON(qflags, LDNS_CD); } if (strstr(optarg, "cd")) { DRILL_OFF(qflags, LDNS_CD); } if (strstr(optarg, "RA")) { DRILL_ON(qflags, LDNS_RA); } if (strstr(optarg, "ra")) { DRILL_OFF(qflags, LDNS_RA); } if (strstr(optarg, "AD")) { DRILL_ON(qflags, LDNS_AD); } if (strstr(optarg, "ad")) { DRILL_OFF(qflags, LDNS_AD); } break; case 'p': qport = (uint16_t)atoi(optarg); if (qport == 0) { error("%s", " could not be converted"); } break; case 's': qds = true; break; case 'u': qusevc = false; break; case 'v': version(stdout, progname); result = EXIT_SUCCESS; goto exit; case 'x': PURPOSE = DRILL_REVERSE; break; case 'y': #ifdef HAVE_SSL if (strchr(optarg, ':')) { tsig_separator = (size_t) (strchr(optarg, ':') - optarg); if (strchr(optarg + tsig_separator + 1, ':')) { tsig_separator2 = (size_t) (strchr(optarg + tsig_separator + 1, ':') - optarg); tsig_algorithm = xmalloc(strlen(optarg) - tsig_separator2); strncpy(tsig_algorithm, optarg + tsig_separator2 + 1, strlen(optarg) - tsig_separator2); tsig_algorithm[strlen(optarg) - tsig_separator2 - 1] = '\0'; } else { tsig_separator2 = strlen(optarg); tsig_algorithm = xmalloc(26); strncpy(tsig_algorithm, "hmac-md5.sig-alg.reg.int.", 25); tsig_algorithm[25] = '\0'; } tsig_name = xmalloc(tsig_separator + 1); tsig_data = xmalloc(tsig_separator2 - tsig_separator); strncpy(tsig_name, optarg, tsig_separator); strncpy(tsig_data, optarg + tsig_separator + 1, tsig_separator2 - tsig_separator - 1); /* strncpy does not append \0 if source is longer than n */ tsig_name[tsig_separator] = '\0'; tsig_data[ tsig_separator2 - tsig_separator - 1] = '\0'; } #else fprintf(stderr, "TSIG requested, but SSL is not supported\n"); result = EXIT_FAILURE; goto exit; #endif /* HAVE_SSL */ break; case 'z': qrandom = false; break; case 'd': trace_start_name = ldns_dname_new_frm_str(optarg); if (!trace_start_name) { fprintf(stderr, "Unable to parse argument for -%c\n", c); result = EXIT_FAILURE; goto exit; } break; case 'h': version(stdout, progname); usage(stdout, progname); result = EXIT_SUCCESS; goto exit; break; default: fprintf(stderr, "Unknown argument: -%c, use -h to see usage\n", c); result = EXIT_FAILURE; goto exit; } } argc -= optind; argv += optind; if ((PURPOSE == DRILL_CHASE || (PURPOSE == DRILL_TRACE && qdnssec)) && ldns_rr_list_rr_count(key_list) == 0) { (void) read_key_file(LDNS_TRUST_ANCHOR_FILE, key_list, true); } if (ldns_rr_list_rr_count(key_list) > 0) { printf(";; Number of trusted keys: %d\n", (int) ldns_rr_list_rr_count(key_list)); } /* do a secure trace when requested */ if (PURPOSE == DRILL_TRACE && qdnssec) { #ifdef HAVE_SSL if (ldns_rr_list_rr_count(key_list) == 0) { warning("%s", "No trusted keys were given. Will not be able to verify authenticity!"); } PURPOSE = DRILL_SECTRACE; #else fprintf(stderr, "ldns has not been compiled with OpenSSL support. Secure trace not available\n"); exit(1); #endif /* HAVE_SSL */ } /* parse the arguments, with multiple arguments, the last argument * found is used */ for(i = 0; i < argc; i++) { /* if ^@ then it's a server */ if (argv[i][0] == '@') { if (strlen(argv[i]) == 1) { warning("%s", "No nameserver given"); exit(EXIT_FAILURE); } serv = argv[i] + 1; continue; } /* if has a dot, it's a name */ if (strchr(argv[i], '.')) { name = argv[i]; continue; } /* if it matches a type, it's a type */ if (int_type == -1) { type = ldns_get_rr_type_by_name(argv[i]); if (type != 0) { int_type = 0; continue; } } /* if it matches a class, it's a class */ if (int_clas == -1) { clas = ldns_get_rr_class_by_name(argv[i]); if (clas != 0) { int_clas = 0; continue; } } /* it all fails assume it's a name */ name = argv[i]; } /* act like dig and use for . NS */ if (!name) { name = "."; int_type = 0; type = LDNS_RR_TYPE_NS; } /* defaults if not given */ if (int_clas == -1) { clas = LDNS_RR_CLASS_IN; } if (int_type == -1) { if (PURPOSE != DRILL_REVERSE) { type = LDNS_RR_TYPE_A; } else { type = LDNS_RR_TYPE_PTR; } } if (src) { src_rdf = ldns_rdf_new_addr_frm_str(src); if(!src_rdf) { fprintf(stderr, "-I must be (or resolve) to a valid IP[v6] address.\n"); exit(EXIT_FAILURE); } } /* set the nameserver to use */ if (!serv) { /* no server given make a resolver from /etc/resolv.conf */ status = ldns_resolver_new_frm_file(&res, resolv_conf_file); if (status != LDNS_STATUS_OK) { warning("Could not create a resolver structure: %s (%s)\n" "Try drill @localhost if you have a resolver running on your machine.", ldns_get_errorstr_by_id(status), resolv_conf_file); result = EXIT_FAILURE; goto exit; } } else { res = ldns_resolver_new(); if (!res || strlen(serv) <= 0) { warning("Could not create a resolver structure"); result = EXIT_FAILURE; goto exit; } /* add the nameserver */ serv_rdf = ldns_rdf_new_addr_frm_str(serv); if (!serv_rdf) { /* try to resolv the name if possible */ status = ldns_resolver_new_frm_file(&cmdline_res, resolv_conf_file); if (status != LDNS_STATUS_OK) { error("%s", "@server ip could not be converted"); } ldns_resolver_set_dnssec(cmdline_res, qdnssec); ldns_resolver_set_ip6(cmdline_res, qfamily); ldns_resolver_set_fallback(cmdline_res, qfallback); ldns_resolver_set_usevc(cmdline_res, qusevc); ldns_resolver_set_source(cmdline_res, src_rdf); cmdline_dname = ldns_dname_new_frm_str(serv); cmdline_rr_list = ldns_get_rr_list_addr_by_name( cmdline_res, cmdline_dname, LDNS_RR_CLASS_IN, qflags); ldns_rdf_deep_free(cmdline_dname); if (!cmdline_rr_list) { /* This error msg is not always accurate */ error("%s `%s\'", "could not find any address for the name:", serv); } else { if (ldns_resolver_push_nameserver_rr_list( res, cmdline_rr_list ) != LDNS_STATUS_OK) { error("%s", "pushing nameserver"); } } } else { if (ldns_resolver_push_nameserver(res, serv_rdf) != LDNS_STATUS_OK) { error("%s", "pushing nameserver"); } else { ldns_rdf_deep_free(serv_rdf); } } } /* set the resolver options */ ldns_resolver_set_port(res, qport); ldns_resolver_set_source(res, src_rdf); if (verbosity >= 5) { ldns_resolver_set_debug(res, true); } else { ldns_resolver_set_debug(res, false); } ldns_resolver_set_dnssec(res, qdnssec); /* ldns_resolver_set_dnssec_cd(res, qdnssec);*/ ldns_resolver_set_ip6(res, qfamily); ldns_resolver_set_fallback(res, qfallback); ldns_resolver_set_usevc(res, qusevc); ldns_resolver_set_random(res, qrandom); if (qbuf != 0) { ldns_resolver_set_edns_udp_size(res, qbuf); } if (!name && PURPOSE != DRILL_AFROMFILE && !query_file ) { usage(stdout, progname); result = EXIT_FAILURE; goto exit; } if (tsig_name && tsig_data) { ldns_resolver_set_tsig_keyname(res, tsig_name); ldns_resolver_set_tsig_keydata(res, tsig_data); ldns_resolver_set_tsig_algorithm(res, tsig_algorithm); } /* main switching part of drill */ switch(PURPOSE) { case DRILL_TRACE: /* do a trace from the root down */ if (!global_dns_root) { init_root(); } qname = ldns_dname_new_frm_str(name); if (!qname) { error("%s", "parsing query name"); } /* don't care about return packet */ (void)do_trace(res, qname, type, clas); clear_root(); break; case DRILL_SECTRACE: /* do a secure trace from the root down */ if (!global_dns_root) { init_root(); } qname = ldns_dname_new_frm_str(name); if (!qname) { error("%s", "making qname"); } /* don't care about return packet */ #ifdef HAVE_SSL result = do_secure_trace(res, qname, type, clas, key_list, trace_start_name); #endif /* HAVE_SSL */ clear_root(); break; case DRILL_CHASE: qname = ldns_dname_new_frm_str(name); if (!qname) { error("%s", "making qname"); } ldns_resolver_set_dnssec(res, true); ldns_resolver_set_dnssec_cd(res, true); /* set dnssec implies udp_size of 4096 */ ldns_resolver_set_edns_udp_size(res, 4096); pkt = NULL; status = ldns_resolver_query_status( &pkt, res, qname, type, clas, qflags); if (status != LDNS_STATUS_OK) { error("error sending query: %s", ldns_get_errorstr_by_id(status)); } if (!pkt) { if (status == LDNS_STATUS_OK) { error("%s", "error pkt sending"); } result = EXIT_FAILURE; } else { if (verbosity >= 3) { ldns_pkt_print(stdout, pkt); } if (!ldns_pkt_answer(pkt)) { mesg("No answer in packet"); } else { #ifdef HAVE_SSL ldns_resolver_set_dnssec_anchors(res, ldns_rr_list_clone(key_list)); result = do_chase(res, qname, type, clas, key_list, pkt, qflags, NULL, verbosity); if (result == LDNS_STATUS_OK) { if (verbosity != -1) { mesg("Chase successful"); } result = 0; } else { if (verbosity != -1) { mesg("Chase failed."); } } #endif /* HAVE_SSL */ } ldns_pkt_free(pkt); } break; case DRILL_AFROMFILE: pkt = read_hex_pkt(answer_file); if (pkt) { if (verbosity != -1) { ldns_pkt_print(stdout, pkt); } ldns_pkt_free(pkt); } break; case DRILL_QTOFILE: qname = ldns_dname_new_frm_str(name); if (!qname) { error("%s", "making qname"); } status = ldns_resolver_prepare_query_pkt(&qpkt, res, qname, type, clas, qflags); if(status != LDNS_STATUS_OK) { error("%s", "making query: %s", ldns_get_errorstr_by_id(status)); } dump_hex(qpkt, query_file); ldns_pkt_free(qpkt); break; case DRILL_NSEC: break; case DRILL_REVERSE: /* ipv4 or ipv6 addr? */ if (strchr(name, ':')) { if (strchr(name, '.')) { error("Syntax error: both '.' and ':' seen in address\n"); } name2 = malloc(IP6_ARPA_MAX_LEN + 20); c = 0; for (i=0; i<(int)strlen(name); i++) { if (i >= IP6_ARPA_MAX_LEN) { error("%s", "reverse argument to long"); } if (name[i] == ':') { if (i < (int) strlen(name) && name[i + 1] == ':') { error("%s", ":: not supported (yet)"); } else { if (i + 2 == (int) strlen(name) || name[i + 2] == ':') { name2[c++] = '0'; name2[c++] = '.'; name2[c++] = '0'; name2[c++] = '.'; name2[c++] = '0'; name2[c++] = '.'; } else if (i + 3 == (int) strlen(name) || name[i + 3] == ':') { name2[c++] = '0'; name2[c++] = '.'; name2[c++] = '0'; name2[c++] = '.'; } else if (i + 4 == (int) strlen(name) || name[i + 4] == ':') { name2[c++] = '0'; name2[c++] = '.'; } } } else { name2[c++] = name[i]; name2[c++] = '.'; } } name2[c++] = '\0'; qname = ldns_dname_new_frm_str(name2); qname_tmp = ldns_dname_reverse(qname); ldns_rdf_deep_free(qname); qname = qname_tmp; qname_tmp = ldns_dname_new_frm_str("ip6.arpa."); status = ldns_dname_cat(qname, qname_tmp); if (status != LDNS_STATUS_OK) { error("%s", "could not create reverse address for ip6: %s\n", ldns_get_errorstr_by_id(status)); } ldns_rdf_deep_free(qname_tmp); free(name2); } else { qname = ldns_dname_new_frm_str(name); qname_tmp = ldns_dname_reverse(qname); ldns_rdf_deep_free(qname); qname = qname_tmp; qname_tmp = ldns_dname_new_frm_str("in-addr.arpa."); status = ldns_dname_cat(qname, qname_tmp); if (status != LDNS_STATUS_OK) { error("%s", "could not create reverse address for ip4: %s\n", ldns_get_errorstr_by_id(status)); } ldns_rdf_deep_free(qname_tmp); } if (!qname) { error("%s", "-x implies an ip address"); } /* create a packet and set the RD flag on it */ pkt = NULL; status = ldns_resolver_query_status( &pkt, res, qname, type, clas, qflags); if (status != LDNS_STATUS_OK) { error("error sending query: %s", ldns_get_errorstr_by_id(status)); } if (!pkt) { if (status == LDNS_STATUS_OK) { error("%s", "pkt sending"); } result = EXIT_FAILURE; } else { if (verbosity != -1) { ldns_pkt_print(stdout, pkt); } ldns_pkt_free(pkt); } break; case DRILL_QUERY: default: if (query_file) { /* this old way, the query packet needed to be parseable, but we want to be able to send mangled packets, so we need to do it directly */ #if 0 qpkt = read_hex_pkt(query_file); if (qpkt) { status = ldns_resolver_send_pkt(&pkt, res, qpkt); if (status != LDNS_STATUS_OK) { printf("Error: %s\n", ldns_get_errorstr_by_id(status)); exit(1); } } else { /* qpkt was bogus, reset pkt */ pkt = NULL; } #endif query_buffer = read_hex_buffer(query_file); if (query_buffer) { status = ldns_send_buffer(&pkt, res, query_buffer, NULL); ldns_buffer_free(query_buffer); if (status != LDNS_STATUS_OK) { printf("Error: %s\n", ldns_get_errorstr_by_id(status)); exit(1); } } else { printf("NO BUFFER\n"); pkt = NULL; } } else { qname = ldns_dname_new_frm_str(name); if (!qname) { error("%s", "error in making qname"); } if (type == LDNS_RR_TYPE_AXFR) { status = ldns_axfr_start(res, qname, clas); if(status != LDNS_STATUS_OK) { error("Error starting axfr: %s", ldns_get_errorstr_by_id(status)); } axfr_rr = ldns_axfr_next(res); if(!axfr_rr) { fprintf(stderr, "AXFR failed.\n"); ldns_pkt_print(stdout, ldns_axfr_last_pkt(res)); goto exit; } while (axfr_rr) { if (verbosity != -1) { ldns_rr_print(stdout, axfr_rr); } ldns_rr_free(axfr_rr); axfr_rr = ldns_axfr_next(res); } goto exit; } else { /* create a packet and set the RD flag on it */ pkt = NULL; status = ldns_resolver_query_status( &pkt, res, qname, type, clas, qflags); if (status != LDNS_STATUS_OK) { error("error sending query: %s" , ldns_get_errorstr_by_id( status)); } } } if (!pkt) { mesg("No packet received"); result = EXIT_FAILURE; } else { if (verbosity != -1) { ldns_pkt_print(stdout, pkt); if (ldns_pkt_tc(pkt)) { fprintf(stdout, "\n;; WARNING: The answer packet was truncated; you might want to\n"); fprintf(stdout, ";; query again with TCP (-t argument), or EDNS0 (-b for buffer size)\n"); } } if (qds) { if (verbosity != -1) { print_ds_of_keys(pkt); printf("\n"); } } if (ldns_rr_list_rr_count(key_list) > 0) { /* -k's were given on the cmd line */ ldns_rr_list *rrset_verified; uint16_t key_count; rrset_verified = ldns_pkt_rr_list_by_name_and_type( pkt, qname, type, LDNS_SECTION_ANY_NOQUESTION); if (type == LDNS_RR_TYPE_ANY) { /* don't verify this */ break; } if (verbosity != -1) { printf("; "); ldns_rr_list_print(stdout, rrset_verified); } /* verify */ #ifdef HAVE_SSL key_verified = ldns_rr_list_new(); result = ldns_pkt_verify(pkt, type, qname, key_list, NULL, key_verified); if (result == LDNS_STATUS_ERR) { /* is the existence denied then? */ result = ldns_verify_denial(pkt, qname, type, NULL, NULL); if (result == LDNS_STATUS_OK) { if (verbosity != -1) { printf("Existence denied for "); ldns_rdf_print(stdout, qname); type_str = ldns_rr_type2str(type); printf("\t%s\n", type_str); LDNS_FREE(type_str); } } else { if (verbosity != -1) { printf("Bad data; RR for name and " "type not found or failed to " "verify, and denial of " "existence failed.\n"); } } } else if (result == LDNS_STATUS_OK) { for(key_count = 0; key_count < ldns_rr_list_rr_count(key_verified); key_count++) { if (verbosity != -1) { printf("; VALIDATED by id = %u, owner = ", (unsigned int)ldns_calc_keytag( ldns_rr_list_rr(key_verified, key_count))); ldns_rdf_print(stdout, ldns_rr_owner( ldns_rr_list_rr(key_list, key_count))); printf("\n"); } } } else { for(key_count = 0; key_count < ldns_rr_list_rr_count(key_list); key_count++) { if (verbosity != -1) { printf("; %s for id = %u, owner = ", ldns_get_errorstr_by_id(result), (unsigned int)ldns_calc_keytag( ldns_rr_list_rr(key_list, key_count))); ldns_rdf_print(stdout, ldns_rr_owner( ldns_rr_list_rr(key_list, key_count))); printf("\n"); } } } ldns_rr_list_free(key_verified); #else (void) key_count; #endif /* HAVE_SSL */ } if (answer_file) { dump_hex(pkt, answer_file); } ldns_pkt_free(pkt); } break; } exit: ldns_rdf_deep_free(qname); ldns_rdf_deep_free(src_rdf); ldns_resolver_deep_free(res); ldns_resolver_deep_free(cmdline_res); ldns_rr_list_deep_free(key_list); ldns_rr_list_deep_free(cmdline_rr_list); ldns_rdf_deep_free(trace_start_name); xfree(progname); xfree(tsig_name); xfree(tsig_data); xfree(tsig_algorithm); #ifdef HAVE_SSL ERR_remove_state(0); CRYPTO_cleanup_all_ex_data(); ERR_free_strings(); EVP_cleanup(); #endif #ifdef USE_WINSOCK WSACleanup(); #endif return result; } ldns-1.6.17/drill/drill_util.h0000664000175100017510000000223112264060151015533 0ustar willemwillem/* * util.h * util.c header file * in ldns * (c) 2005 NLnet Labs * * See the file LICENSE for the license * */ #ifndef _DRILL_UTIL_H_ #define _DRILL_UTIL_H_ #include /** * Read keys from filename and append to key_list. */ ldns_status read_key_file(const char *filename, ldns_rr_list *key_list, bool silently); /** * return a address rdf, either A or AAAA * NULL if anything goes wrong */ ldns_rdf * ldns_rdf_new_addr_frm_str(char *); /** * print all the ds of the keys in the packet */ void print_ds_of_keys(ldns_pkt *p); /** * print some rdfs of a signature */ void print_rrsig_abbr(FILE *fp, ldns_rr *sig); /** * print some rdfs of a dnskey */ void print_dnskey_abbr(FILE *fp, ldns_rr *key); /** * print some rdfs of a ds */ void print_ds_abbr(FILE *fp, ldns_rr *ds); /** * print some rdfs of a rr in a rr_list */ void print_rr_list_abbr(FILE *fp, ldns_rr_list *sig, const char *usr); /** * Alloc some memory, with error checking */ void *xmalloc(size_t s); /** * Realloc some memory, with error checking */ void *xrealloc(void *p, size_t s); /** * Free the data */ void xfree(void *q); #endif /* _DRILL_UTIL_H_ */ ldns-1.6.17/drill/securetrace.c0000664000175100017510000005452712264060151015707 0ustar willemwillem/* * securechasetrace.c * Where all the hard work concerning secure tracing is done * * (c) 2005, 2006 NLnet Labs * * See the file LICENSE for the license * */ #include "drill.h" #include #define SELF "[S]" /* self sig ok */ #define TRUST "[T]" /* chain from parent */ #define BOGUS "[B]" /* bogus */ #define UNSIGNED "[U]" /* no relevant dnssec data found */ #if 0 /* See if there is a key/ds in trusted that matches * a ds in *ds. */ static ldns_rr_list * ds_key_match(ldns_rr_list *ds, ldns_rr_list *trusted) { size_t i, j; bool match; ldns_rr *rr_i, *rr_j; ldns_rr_list *keys; if (!trusted || !ds) { return NULL; } match = false; keys = ldns_rr_list_new(); if (!keys) { return NULL; } if (!ds || !trusted) { return NULL; } for (i = 0; i < ldns_rr_list_rr_count(trusted); i++) { rr_i = ldns_rr_list_rr(trusted, i); for (j = 0; j < ldns_rr_list_rr_count(ds); j++) { rr_j = ldns_rr_list_rr(ds, j); if (ldns_rr_compare_ds(rr_i, rr_j)) { match = true; /* only allow unique RRs to match */ ldns_rr_set_push_rr(keys, rr_i); } } } if (match) { return keys; } else { return NULL; } } #endif ldns_pkt * get_dnssec_pkt(ldns_resolver *r, ldns_rdf *name, ldns_rr_type t) { ldns_pkt *p = NULL; p = ldns_resolver_query(r, name, t, LDNS_RR_CLASS_IN, 0); if (!p) { return NULL; } else { if (verbosity >= 5) { ldns_pkt_print(stdout, p); } return p; } } #ifdef HAVE_SSL /* * retrieve keys for this zone */ static ldns_pkt_type get_key(ldns_pkt *p, ldns_rdf *apexname, ldns_rr_list **rrlist, ldns_rr_list **opt_sig) { return get_dnssec_rr(p, apexname, LDNS_RR_TYPE_DNSKEY, rrlist, opt_sig); } /* * check to see if we can find a DS rrset here which we can then follow */ static ldns_pkt_type get_ds(ldns_pkt *p, ldns_rdf *ownername, ldns_rr_list **rrlist, ldns_rr_list **opt_sig) { return get_dnssec_rr(p, ownername, LDNS_RR_TYPE_DS, rrlist, opt_sig); } #endif /* HAVE_SSL */ void remove_resolver_nameservers(ldns_resolver *res) { ldns_rdf *pop; /* remove the old nameserver from the resolver */ while((pop = ldns_resolver_pop_nameserver(res))) { ldns_rdf_deep_free(pop); } } void show_current_nameservers(FILE *out, ldns_resolver *res) { size_t i; fprintf(out, "Current nameservers for resolver object:\n"); for (i = 0; i < ldns_resolver_nameserver_count(res); i++) { ldns_rdf_print(out, ldns_resolver_nameservers(res)[i]); fprintf(out, "\n"); } } /*ldns_pkt **/ #ifdef HAVE_SSL int do_secure_trace(ldns_resolver *local_res, ldns_rdf *name, ldns_rr_type t, ldns_rr_class c, ldns_rr_list *trusted_keys, ldns_rdf *start_name ) { ldns_resolver *res; ldns_pkt *p, *local_p; ldns_rr_list *new_nss; ldns_rr_list *ns_addr; ldns_rdf *pop; ldns_rdf **labels = NULL; ldns_status status, st; ssize_t i; size_t j; size_t k; size_t l; uint8_t labels_count = 0; /* dnssec */ ldns_rr_list *key_list; ldns_rr_list *key_sig_list; ldns_rr_list *ds_list; ldns_rr_list *ds_sig_list; ldns_rr_list *correct_key_list; ldns_rr_list *trusted_ds_rrs; bool new_keys_trusted = false; ldns_rr_list *current_correct_keys; ldns_rr_list *dataset; ldns_rr_list *nsec_rrs = NULL; ldns_rr_list *nsec_rr_sigs = NULL; /* empty non-terminal check */ bool ent; ldns_rr *nsecrr; /* The nsec that proofs the non-terminal */ ldns_rdf *hashed_name; /* The query hashed with nsec3 params */ ldns_rdf *label0; /* The first label of an nsec3 owner name */ /* glue handling */ ldns_rr_list *new_ns_addr; ldns_rr_list *old_ns_addr; ldns_rr *ns_rr; int result = 0; /* printing niceness */ const ldns_rr_descriptor *descriptor; descriptor = ldns_rr_descript(t); new_nss = NULL; ns_addr = NULL; key_list = NULL; ds_list = NULL; p = NULL; local_p = NULL; res = ldns_resolver_new(); key_sig_list = NULL; ds_sig_list = NULL; if (!res) { error("Memory allocation failed"); result = -1; return result; } correct_key_list = ldns_rr_list_new(); if (!correct_key_list) { error("Memory allocation failed"); result = -1; return result; } trusted_ds_rrs = ldns_rr_list_new(); if (!trusted_ds_rrs) { error("Memory allocation failed"); result = -1; return result; } /* Add all preset trusted DS signatures to the list of trusted DS RRs. */ for (j = 0; j < ldns_rr_list_rr_count(trusted_keys); j++) { ldns_rr* one_rr = ldns_rr_list_rr(trusted_keys, j); if (ldns_rr_get_type(one_rr) == LDNS_RR_TYPE_DS) { ldns_rr_list_push_rr(trusted_ds_rrs, ldns_rr_clone(one_rr)); } } /* transfer some properties of local_res to res */ ldns_resolver_set_ip6(res, ldns_resolver_ip6(local_res)); ldns_resolver_set_port(res, ldns_resolver_port(local_res)); ldns_resolver_set_debug(res, ldns_resolver_debug(local_res)); ldns_resolver_set_fail(res, ldns_resolver_fail(local_res)); ldns_resolver_set_usevc(res, ldns_resolver_usevc(local_res)); ldns_resolver_set_random(res, ldns_resolver_random(local_res)); ldns_resolver_set_source(res, ldns_resolver_source(local_res)); ldns_resolver_set_recursive(local_res, true); ldns_resolver_set_recursive(res, false); ldns_resolver_set_dnssec_cd(res, false); ldns_resolver_set_dnssec(res, true); /* setup the root nameserver in the new resolver */ status = ldns_resolver_push_nameserver_rr_list(res, global_dns_root); if (status != LDNS_STATUS_OK) { printf("ERRRRR: %s\n", ldns_get_errorstr_by_id(status)); ldns_rr_list_print(stdout, global_dns_root); result = status; goto done; } labels_count = ldns_dname_label_count(name); if (start_name) { if (ldns_dname_is_subdomain(name, start_name)) { labels_count -= ldns_dname_label_count(start_name); } else { fprintf(stderr, "Error; "); ldns_rdf_print(stderr, name); fprintf(stderr, " is not a subdomain of "); ldns_rdf_print(stderr, start_name); fprintf(stderr, "\n"); goto done; } } labels = LDNS_XMALLOC(ldns_rdf*, labels_count + 2); if (!labels) { goto done; } labels[0] = ldns_dname_new_frm_str(LDNS_ROOT_LABEL_STR); labels[1] = ldns_rdf_clone(name); for(i = 2 ; i < (ssize_t)labels_count + 2; i++) { labels[i] = ldns_dname_left_chop(labels[i - 1]); } /* get the nameserver for the label * ask: dnskey and ds for the label */ for(i = (ssize_t)labels_count + 1; i > 0; i--) { status = ldns_resolver_send(&local_p, res, labels[i], LDNS_RR_TYPE_NS, c, 0); if (verbosity >= 5) { ldns_pkt_print(stdout, local_p); } new_nss = ldns_pkt_rr_list_by_type(local_p, LDNS_RR_TYPE_NS, LDNS_SECTION_ANSWER); if (!new_nss) { /* if it's a delegation, servers put them in the auth section */ new_nss = ldns_pkt_rr_list_by_type(local_p, LDNS_RR_TYPE_NS, LDNS_SECTION_AUTHORITY); } /* if this is the final step there might not be nameserver records of course if the data is in the apex, there are, so cover both cases */ if (new_nss || i > 1) { for(j = 0; j < ldns_rr_list_rr_count(new_nss); j++) { ns_rr = ldns_rr_list_rr(new_nss, j); pop = ldns_rr_rdf(ns_rr, 0); if (!pop) { printf("nopo\n"); break; } /* retrieve it's addresses */ /* trust glue? */ new_ns_addr = NULL; if (ldns_dname_is_subdomain(pop, labels[i])) { new_ns_addr = ldns_pkt_rr_list_by_name_and_type(local_p, pop, LDNS_RR_TYPE_A, LDNS_SECTION_ADDITIONAL); } if (!new_ns_addr || ldns_rr_list_rr_count(new_ns_addr) == 0) { new_ns_addr = ldns_get_rr_list_addr_by_name(res, pop, c, 0); } if (!new_ns_addr || ldns_rr_list_rr_count(new_ns_addr) == 0) { new_ns_addr = ldns_get_rr_list_addr_by_name(local_res, pop, c, 0); } if (new_ns_addr) { old_ns_addr = ns_addr; ns_addr = ldns_rr_list_cat_clone(ns_addr, new_ns_addr); ldns_rr_list_deep_free(old_ns_addr); } ldns_rr_list_deep_free(new_ns_addr); } ldns_rr_list_deep_free(new_nss); if (ns_addr) { remove_resolver_nameservers(res); if (ldns_resolver_push_nameserver_rr_list(res, ns_addr) != LDNS_STATUS_OK) { error("Error adding new nameservers"); ldns_pkt_free(local_p); goto done; } ldns_rr_list_deep_free(ns_addr); } else { status = ldns_verify_denial(local_p, labels[i], LDNS_RR_TYPE_NS, &nsec_rrs, &nsec_rr_sigs); /* verify the nsec3 themselves*/ if (verbosity >= 4) { printf("NSEC(3) Records to verify:\n"); ldns_rr_list_print(stdout, nsec_rrs); printf("With signatures:\n"); ldns_rr_list_print(stdout, nsec_rr_sigs); printf("correct keys:\n"); ldns_rr_list_print(stdout, correct_key_list); } if (status == LDNS_STATUS_OK) { if ((st = ldns_verify(nsec_rrs, nsec_rr_sigs, trusted_keys, NULL)) == LDNS_STATUS_OK) { fprintf(stdout, "%s ", TRUST); fprintf(stdout, "Existence denied: "); ldns_rdf_print(stdout, labels[i]); /* if (descriptor && descriptor->_name) { printf(" %s", descriptor->_name); } else { printf(" TYPE%u", t); } */ fprintf(stdout, " NS\n"); } else if ((st = ldns_verify(nsec_rrs, nsec_rr_sigs, correct_key_list, NULL)) == LDNS_STATUS_OK) { fprintf(stdout, "%s ", SELF); fprintf(stdout, "Existence denied: "); ldns_rdf_print(stdout, labels[i]); /* if (descriptor && descriptor->_name) { printf(" %s", descriptor->_name); } else { printf(" TYPE%u", t); } */ fprintf(stdout, " NS\n"); } else { fprintf(stdout, "%s ", BOGUS); result = 1; printf(";; Error verifying denial of existence for name "); ldns_rdf_print(stdout, labels[i]); /* printf(" type "); if (descriptor && descriptor->_name) { printf("%s", descriptor->_name); } else { printf("TYPE%u", t); } */ printf("NS: %s\n", ldns_get_errorstr_by_id(st)); } } else { fprintf(stdout, "%s ", BOGUS); result = 1; printf(";; Error verifying denial of existence for name "); ldns_rdf_print(stdout, labels[i]); printf("NS: %s\n", ldns_get_errorstr_by_id(status)); } /* there might be an empty non-terminal, in which case we need to continue */ ent = false; for (j = 0; j < ldns_rr_list_rr_count(nsec_rrs); j++) { nsecrr = ldns_rr_list_rr(nsec_rrs, j); /* For NSEC when the next name is a subdomain of the question */ if (ldns_rr_get_type(nsecrr) == LDNS_RR_TYPE_NSEC && ldns_dname_is_subdomain(ldns_rr_rdf(nsecrr, 0), labels[i])) { ent = true; /* For NSEC3, the hash matches the name and the type bitmap is empty*/ } else if (ldns_rr_get_type(nsecrr) == LDNS_RR_TYPE_NSEC3) { hashed_name = ldns_nsec3_hash_name_frm_nsec3(nsecrr, labels[i]); label0 = ldns_dname_label(ldns_rr_owner(nsecrr), 0); if (hashed_name && label0 && ldns_dname_compare(hashed_name, label0) == 0 && ldns_nsec3_bitmap(nsecrr) == NULL) { ent = true; } if (label0) { LDNS_FREE(label0); } if (hashed_name) { LDNS_FREE(hashed_name); } } } if (!ent) { ldns_rr_list_deep_free(nsec_rrs); ldns_rr_list_deep_free(nsec_rr_sigs); ldns_pkt_free(local_p); goto done; } else { printf(";; There is an empty non-terminal here, continue\n"); continue; } } if (ldns_resolver_nameserver_count(res) == 0) { error("No nameservers found for this node"); goto done; } } ldns_pkt_free(local_p); fprintf(stdout, ";; Domain: "); ldns_rdf_print(stdout, labels[i]); fprintf(stdout, "\n"); /* retrieve keys for current domain, and verify them if they match an already trusted DS, or if one of the keys used to sign these is trusted, add the keys to the trusted list */ p = get_dnssec_pkt(res, labels[i], LDNS_RR_TYPE_DNSKEY); (void) get_key(p, labels[i], &key_list, &key_sig_list); if (key_sig_list) { if (key_list) { current_correct_keys = ldns_rr_list_new(); if ((st = ldns_verify(key_list, key_sig_list, key_list, current_correct_keys)) == LDNS_STATUS_OK) { /* add all signed keys (don't just add current_correct, you'd miss * the zsk's then */ for (j = 0; j < ldns_rr_list_rr_count(key_list); j++) { ldns_rr_list_push_rr(correct_key_list, ldns_rr_clone(ldns_rr_list_rr(key_list, j))); } /* check whether these keys were signed * by a trusted keys. if so, these * keys are also trusted */ new_keys_trusted = false; for (k = 0; k < ldns_rr_list_rr_count(current_correct_keys); k++) { for (j = 0; j < ldns_rr_list_rr_count(trusted_ds_rrs); j++) { if (ldns_rr_compare_ds(ldns_rr_list_rr(current_correct_keys, k), ldns_rr_list_rr(trusted_ds_rrs, j))) { new_keys_trusted = true; } } } /* also all keys are trusted if one of the current correct keys is trusted */ for (k = 0; k < ldns_rr_list_rr_count(current_correct_keys); k++) { for (j = 0; j < ldns_rr_list_rr_count(trusted_keys); j++) { if (ldns_rr_compare(ldns_rr_list_rr(current_correct_keys, k), ldns_rr_list_rr(trusted_keys, j)) == 0) { new_keys_trusted = true; } } } if (new_keys_trusted) { ldns_rr_list_push_rr_list(trusted_keys, key_list); print_rr_list_abbr(stdout, key_list, TRUST); ldns_rr_list_free(key_list); key_list = NULL; } else { if (verbosity >= 2) { printf(";; Signature ok but no chain to a trusted key or ds record\n"); } print_rr_list_abbr(stdout, key_list, SELF); ldns_rr_list_deep_free(key_list); key_list = NULL; } } else { print_rr_list_abbr(stdout, key_list, BOGUS); result = 2; ldns_rr_list_deep_free(key_list); key_list = NULL; } ldns_rr_list_free(current_correct_keys); current_correct_keys = NULL; } else { printf(";; No DNSKEY record found for "); ldns_rdf_print(stdout, labels[i]); printf("\n"); } } ldns_pkt_free(p); ldns_rr_list_deep_free(key_sig_list); key_sig_list = NULL; /* check the DS records for the next child domain */ if (i > 1) { p = get_dnssec_pkt(res, labels[i-1], LDNS_RR_TYPE_DS); (void) get_ds(p, labels[i-1], &ds_list, &ds_sig_list); if (!ds_list) { ldns_pkt_free(p); if (ds_sig_list) { ldns_rr_list_deep_free(ds_sig_list); } p = get_dnssec_pkt(res, name, LDNS_RR_TYPE_DNSKEY); (void) get_ds(p, NULL, &ds_list, &ds_sig_list); } if (ds_sig_list) { if (ds_list) { if (verbosity >= 4) { printf("VERIFYING:\n"); printf("DS LIST:\n"); ldns_rr_list_print(stdout, ds_list); printf("SIGS:\n"); ldns_rr_list_print(stdout, ds_sig_list); printf("KEYS:\n"); ldns_rr_list_print(stdout, correct_key_list); } current_correct_keys = ldns_rr_list_new(); if ((st = ldns_verify(ds_list, ds_sig_list, correct_key_list, current_correct_keys)) == LDNS_STATUS_OK) { /* if the ds is signed by a trusted key and a key from correct keys matches that ds, add that key to the trusted keys */ new_keys_trusted = false; if (verbosity >= 2) { printf("Checking if signing key is trusted:\n"); } for (j = 0; j < ldns_rr_list_rr_count(current_correct_keys); j++) { if (verbosity >= 2) { printf("New key: "); ldns_rr_print(stdout, ldns_rr_list_rr(current_correct_keys, j)); } for (k = 0; k < ldns_rr_list_rr_count(trusted_keys); k++) { if (verbosity >= 2) { printf("\tTrusted key: "); ldns_rr_print(stdout, ldns_rr_list_rr(trusted_keys, k)); } if (ldns_rr_compare(ldns_rr_list_rr(current_correct_keys, j), ldns_rr_list_rr(trusted_keys, k)) == 0) { if (verbosity >= 2) { printf("Key is now trusted!\n"); } for (l = 0; l < ldns_rr_list_rr_count(ds_list); l++) { ldns_rr_list_push_rr(trusted_ds_rrs, ldns_rr_clone(ldns_rr_list_rr(ds_list, l))); new_keys_trusted = true; } } } } if (new_keys_trusted) { print_rr_list_abbr(stdout, ds_list, TRUST); } else { print_rr_list_abbr(stdout, ds_list, SELF); } } else { result = 3; print_rr_list_abbr(stdout, ds_list, BOGUS); } ldns_rr_list_free(current_correct_keys); current_correct_keys = NULL; } else { /* wait apparently there were no keys either, go back to the ds packet */ ldns_pkt_free(p); ldns_rr_list_deep_free(ds_sig_list); p = get_dnssec_pkt(res, labels[i-1], LDNS_RR_TYPE_DS); (void) get_ds(p, labels[i-1], &ds_list, &ds_sig_list); status = ldns_verify_denial(p, labels[i-1], LDNS_RR_TYPE_DS, &nsec_rrs, &nsec_rr_sigs); if (verbosity >= 4) { printf("NSEC(3) Records to verify:\n"); ldns_rr_list_print(stdout, nsec_rrs); printf("With signatures:\n"); ldns_rr_list_print(stdout, nsec_rr_sigs); printf("correct keys:\n"); ldns_rr_list_print(stdout, correct_key_list); } if (status == LDNS_STATUS_OK) { if ((st = ldns_verify(nsec_rrs, nsec_rr_sigs, trusted_keys, NULL)) == LDNS_STATUS_OK) { fprintf(stdout, "%s ", TRUST); fprintf(stdout, "Existence denied: "); ldns_rdf_print(stdout, labels[i-1]); printf(" DS"); fprintf(stdout, "\n"); } else if ((st = ldns_verify(nsec_rrs, nsec_rr_sigs, correct_key_list, NULL)) == LDNS_STATUS_OK) { fprintf(stdout, "%s ", SELF); fprintf(stdout, "Existence denied: "); ldns_rdf_print(stdout, labels[i-1]); printf(" DS"); fprintf(stdout, "\n"); } else { result = 4; fprintf(stdout, "%s ", BOGUS); printf("Error verifying denial of existence for "); ldns_rdf_print(stdout, labels[i-1]); printf(" DS"); printf(": %s\n", ldns_get_errorstr_by_id(st)); } } else { if (status == LDNS_STATUS_CRYPTO_NO_RRSIG) { printf(";; No DS for "); ldns_rdf_print(stdout, labels[i - 1]); } else { printf("[B] Unable to verify denial of existence for "); ldns_rdf_print(stdout, labels[i - 1]); printf(" DS: %s\n", ldns_get_errorstr_by_id(status)); } } if (verbosity >= 2) { printf(";; No ds record for delegation\n"); } } } ldns_rr_list_deep_free(ds_list); ldns_pkt_free(p); } else { /* if this is the last label, just verify the data and stop */ p = get_dnssec_pkt(res, labels[i], t); (void) get_dnssec_rr(p, labels[i], t, &dataset, &key_sig_list); if (dataset && ldns_rr_list_rr_count(dataset) > 0) { if (key_sig_list && ldns_rr_list_rr_count(key_sig_list) > 0) { /* If this is a wildcard, you must be able to deny exact match */ if ((st = ldns_verify(dataset, key_sig_list, trusted_keys, NULL)) == LDNS_STATUS_OK) { fprintf(stdout, "%s ", TRUST); ldns_rr_list_print(stdout, dataset); } else if ((st = ldns_verify(dataset, key_sig_list, correct_key_list, NULL)) == LDNS_STATUS_OK) { fprintf(stdout, "%s ", SELF); ldns_rr_list_print(stdout, dataset); } else { result = 5; fprintf(stdout, "%s ", BOGUS); ldns_rr_list_print(stdout, dataset); printf(";; Error: %s\n", ldns_get_errorstr_by_id(st)); } } else { fprintf(stdout, "%s ", UNSIGNED); ldns_rr_list_print(stdout, dataset); } ldns_rr_list_deep_free(dataset); } else { status = ldns_verify_denial(p, name, t, &nsec_rrs, &nsec_rr_sigs); if (status == LDNS_STATUS_OK) { /* verify the nsec3 themselves*/ if (verbosity >= 5) { printf("NSEC(3) Records to verify:\n"); ldns_rr_list_print(stdout, nsec_rrs); printf("With signatures:\n"); ldns_rr_list_print(stdout, nsec_rr_sigs); printf("correct keys:\n"); ldns_rr_list_print(stdout, correct_key_list); /* printf("trusted keys at %p:\n", trusted_keys); ldns_rr_list_print(stdout, trusted_keys); */ } if ((st = ldns_verify(nsec_rrs, nsec_rr_sigs, trusted_keys, NULL)) == LDNS_STATUS_OK) { fprintf(stdout, "%s ", TRUST); fprintf(stdout, "Existence denied: "); ldns_rdf_print(stdout, name); if (descriptor && descriptor->_name) { printf(" %s", descriptor->_name); } else { printf(" TYPE%u", t); } fprintf(stdout, "\n"); } else if ((st = ldns_verify(nsec_rrs, nsec_rr_sigs, correct_key_list, NULL)) == LDNS_STATUS_OK) { fprintf(stdout, "%s ", SELF); fprintf(stdout, "Existence denied: "); ldns_rdf_print(stdout, name); if (descriptor && descriptor->_name) { printf(" %s", descriptor->_name); } else { printf(" TYPE%u", t); } fprintf(stdout, "\n"); } else { result = 6; fprintf(stdout, "%s ", BOGUS); printf("Error verifying denial of existence for "); ldns_rdf_print(stdout, name); printf(" type "); if (descriptor && descriptor->_name) { printf("%s", descriptor->_name); } else { printf("TYPE%u", t); } printf(": %s\n", ldns_get_errorstr_by_id(st)); } ldns_rr_list_deep_free(nsec_rrs); ldns_rr_list_deep_free(nsec_rr_sigs); } else { /* */ if (status == LDNS_STATUS_CRYPTO_NO_RRSIG) { printf("%s ", UNSIGNED); printf("No data found for: "); ldns_rdf_print(stdout, name); printf(" type "); if (descriptor && descriptor->_name) { printf("%s", descriptor->_name); } else { printf("TYPE%u", t); } printf("\n"); } else { printf("[B] Unable to verify denial of existence for "); ldns_rdf_print(stdout, name); printf(" type "); if (descriptor && descriptor->_name) { printf("%s", descriptor->_name); } else { printf("TYPE%u", t); } printf("\n"); } } } ldns_pkt_free(p); } new_nss = NULL; ns_addr = NULL; ldns_rr_list_deep_free(key_list); key_list = NULL; ldns_rr_list_deep_free(key_sig_list); key_sig_list = NULL; ds_list = NULL; ldns_rr_list_deep_free(ds_sig_list); ds_sig_list = NULL; } printf(";;" SELF " self sig OK; " BOGUS " bogus; " TRUST " trusted\n"); /* verbose mode? printf("Trusted keys:\n"); ldns_rr_list_print(stdout, trusted_keys); printf("trusted dss:\n"); ldns_rr_list_print(stdout, trusted_ds_rrs); */ done: ldns_rr_list_deep_free(trusted_ds_rrs); ldns_rr_list_deep_free(correct_key_list); ldns_resolver_deep_free(res); if (labels) { for(i = 0 ; i < (ssize_t)labels_count + 2; i++) { ldns_rdf_deep_free(labels[i]); } LDNS_FREE(labels); } return result; } #endif /* HAVE_SSL */ ldns-1.6.17/drill/install-sh0000775000175100017510000003253712264060151015237 0ustar willemwillem#!/bin/sh # install - install a program, script, or datafile scriptversion=2009-04-28.21; # UTC # This originates from X11R5 (mit/util/scripts/install.sh), which was # later released in X11R6 (xc/config/util/install.sh) with the # following copyright and license. # # Copyright (C) 1994 X Consortium # # Permission is hereby granted, free of charge, to any person obtaining a copy # of this software and associated documentation files (the "Software"), to # deal in the Software without restriction, including without limitation the # rights to use, copy, modify, merge, publish, distribute, sublicense, and/or # sell copies of the Software, and to permit persons to whom the Software is # furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included in # all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN # AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNEC- # TION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. # # Except as contained in this notice, the name of the X Consortium shall not # be used in advertising or otherwise to promote the sale, use or other deal- # ings in this Software without prior written authorization from the X Consor- # tium. # # # FSF changes to this file are in the public domain. # # Calling this script install-sh is preferred over install.sh, to prevent # `make' implicit rules from creating a file called install from it # when there is no Makefile. # # This script is compatible with the BSD install script, but was written # from scratch. nl=' ' IFS=" "" $nl" # set DOITPROG to echo to test this script # Don't use :- since 4.3BSD and earlier shells don't like it. doit=${DOITPROG-} if test -z "$doit"; then doit_exec=exec else doit_exec=$doit fi # Put in absolute file names if you don't have them in your path; # or use environment vars. chgrpprog=${CHGRPPROG-chgrp} chmodprog=${CHMODPROG-chmod} chownprog=${CHOWNPROG-chown} cmpprog=${CMPPROG-cmp} cpprog=${CPPROG-cp} mkdirprog=${MKDIRPROG-mkdir} mvprog=${MVPROG-mv} rmprog=${RMPROG-rm} stripprog=${STRIPPROG-strip} posix_glob='?' initialize_posix_glob=' test "$posix_glob" != "?" || { if (set -f) 2>/dev/null; then posix_glob= else posix_glob=: fi } ' posix_mkdir= # Desired mode of installed file. mode=0755 chgrpcmd= chmodcmd=$chmodprog chowncmd= mvcmd=$mvprog rmcmd="$rmprog -f" stripcmd= src= dst= dir_arg= dst_arg= copy_on_change=false no_target_directory= usage="\ Usage: $0 [OPTION]... [-T] SRCFILE DSTFILE or: $0 [OPTION]... SRCFILES... DIRECTORY or: $0 [OPTION]... -t DIRECTORY SRCFILES... or: $0 [OPTION]... -d DIRECTORIES... In the 1st form, copy SRCFILE to DSTFILE. In the 2nd and 3rd, copy all SRCFILES to DIRECTORY. In the 4th, create DIRECTORIES. Options: --help display this help and exit. --version display version info and exit. -c (ignored) -C install only if different (preserve the last data modification time) -d create directories instead of installing files. -g GROUP $chgrpprog installed files to GROUP. -m MODE $chmodprog installed files to MODE. -o USER $chownprog installed files to USER. -s $stripprog installed files. -t DIRECTORY install into DIRECTORY. -T report an error if DSTFILE is a directory. Environment variables override the default commands: CHGRPPROG CHMODPROG CHOWNPROG CMPPROG CPPROG MKDIRPROG MVPROG RMPROG STRIPPROG " while test $# -ne 0; do case $1 in -c) ;; -C) copy_on_change=true;; -d) dir_arg=true;; -g) chgrpcmd="$chgrpprog $2" shift;; --help) echo "$usage"; exit $?;; -m) mode=$2 case $mode in *' '* | *' '* | *' '* | *'*'* | *'?'* | *'['*) echo "$0: invalid mode: $mode" >&2 exit 1;; esac shift;; -o) chowncmd="$chownprog $2" shift;; -s) stripcmd=$stripprog;; -t) dst_arg=$2 shift;; -T) no_target_directory=true;; --version) echo "$0 $scriptversion"; exit $?;; --) shift break;; -*) echo "$0: invalid option: $1" >&2 exit 1;; *) break;; esac shift done if test $# -ne 0 && test -z "$dir_arg$dst_arg"; then # When -d is used, all remaining arguments are directories to create. # When -t is used, the destination is already specified. # Otherwise, the last argument is the destination. Remove it from $@. for arg do if test -n "$dst_arg"; then # $@ is not empty: it contains at least $arg. set fnord "$@" "$dst_arg" shift # fnord fi shift # arg dst_arg=$arg done fi if test $# -eq 0; then if test -z "$dir_arg"; then echo "$0: no input file specified." >&2 exit 1 fi # It's OK to call `install-sh -d' without argument. # This can happen when creating conditional directories. exit 0 fi if test -z "$dir_arg"; then trap '(exit $?); exit' 1 2 13 15 # Set umask so as not to create temps with too-generous modes. # However, 'strip' requires both read and write access to temps. case $mode in # Optimize common cases. *644) cp_umask=133;; *755) cp_umask=22;; *[0-7]) if test -z "$stripcmd"; then u_plus_rw= else u_plus_rw='% 200' fi cp_umask=`expr '(' 777 - $mode % 1000 ')' $u_plus_rw`;; *) if test -z "$stripcmd"; then u_plus_rw= else u_plus_rw=,u+rw fi cp_umask=$mode$u_plus_rw;; esac fi for src do # Protect names starting with `-'. case $src in -*) src=./$src;; esac if test -n "$dir_arg"; then dst=$src dstdir=$dst test -d "$dstdir" dstdir_status=$? else # Waiting for this to be detected by the "$cpprog $src $dsttmp" command # might cause directories to be created, which would be especially bad # if $src (and thus $dsttmp) contains '*'. if test ! -f "$src" && test ! -d "$src"; then echo "$0: $src does not exist." >&2 exit 1 fi if test -z "$dst_arg"; then echo "$0: no destination specified." >&2 exit 1 fi dst=$dst_arg # Protect names starting with `-'. case $dst in -*) dst=./$dst;; esac # If destination is a directory, append the input filename; won't work # if double slashes aren't ignored. if test -d "$dst"; then if test -n "$no_target_directory"; then echo "$0: $dst_arg: Is a directory" >&2 exit 1 fi dstdir=$dst dst=$dstdir/`basename "$src"` dstdir_status=0 else # Prefer dirname, but fall back on a substitute if dirname fails. dstdir=` (dirname "$dst") 2>/dev/null || expr X"$dst" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$dst" : 'X\(//\)[^/]' \| \ X"$dst" : 'X\(//\)$' \| \ X"$dst" : 'X\(/\)' \| . 2>/dev/null || echo X"$dst" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q } /^X\(\/\/\)[^/].*/{ s//\1/ q } /^X\(\/\/\)$/{ s//\1/ q } /^X\(\/\).*/{ s//\1/ q } s/.*/./; q' ` test -d "$dstdir" dstdir_status=$? fi fi obsolete_mkdir_used=false if test $dstdir_status != 0; then case $posix_mkdir in '') # Create intermediate dirs using mode 755 as modified by the umask. # This is like FreeBSD 'install' as of 1997-10-28. umask=`umask` case $stripcmd.$umask in # Optimize common cases. *[2367][2367]) mkdir_umask=$umask;; .*0[02][02] | .[02][02] | .[02]) mkdir_umask=22;; *[0-7]) mkdir_umask=`expr $umask + 22 \ - $umask % 100 % 40 + $umask % 20 \ - $umask % 10 % 4 + $umask % 2 `;; *) mkdir_umask=$umask,go-w;; esac # With -d, create the new directory with the user-specified mode. # Otherwise, rely on $mkdir_umask. if test -n "$dir_arg"; then mkdir_mode=-m$mode else mkdir_mode= fi posix_mkdir=false case $umask in *[123567][0-7][0-7]) # POSIX mkdir -p sets u+wx bits regardless of umask, which # is incompatible with FreeBSD 'install' when (umask & 300) != 0. ;; *) tmpdir=${TMPDIR-/tmp}/ins$RANDOM-$$ trap 'ret=$?; rmdir "$tmpdir/d" "$tmpdir" 2>/dev/null; exit $ret' 0 if (umask $mkdir_umask && exec $mkdirprog $mkdir_mode -p -- "$tmpdir/d") >/dev/null 2>&1 then if test -z "$dir_arg" || { # Check for POSIX incompatibilities with -m. # HP-UX 11.23 and IRIX 6.5 mkdir -m -p sets group- or # other-writeable bit of parent directory when it shouldn't. # FreeBSD 6.1 mkdir -m -p sets mode of existing directory. ls_ld_tmpdir=`ls -ld "$tmpdir"` case $ls_ld_tmpdir in d????-?r-*) different_mode=700;; d????-?--*) different_mode=755;; *) false;; esac && $mkdirprog -m$different_mode -p -- "$tmpdir" && { ls_ld_tmpdir_1=`ls -ld "$tmpdir"` test "$ls_ld_tmpdir" = "$ls_ld_tmpdir_1" } } then posix_mkdir=: fi rmdir "$tmpdir/d" "$tmpdir" else # Remove any dirs left behind by ancient mkdir implementations. rmdir ./$mkdir_mode ./-p ./-- 2>/dev/null fi trap '' 0;; esac;; esac if $posix_mkdir && ( umask $mkdir_umask && $doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir" ) then : else # The umask is ridiculous, or mkdir does not conform to POSIX, # or it failed possibly due to a race condition. Create the # directory the slow way, step by step, checking for races as we go. case $dstdir in /*) prefix='/';; -*) prefix='./';; *) prefix='';; esac eval "$initialize_posix_glob" oIFS=$IFS IFS=/ $posix_glob set -f set fnord $dstdir shift $posix_glob set +f IFS=$oIFS prefixes= for d do test -z "$d" && continue prefix=$prefix$d if test -d "$prefix"; then prefixes= else if $posix_mkdir; then (umask=$mkdir_umask && $doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir") && break # Don't fail if two instances are running concurrently. test -d "$prefix" || exit 1 else case $prefix in *\'*) qprefix=`echo "$prefix" | sed "s/'/'\\\\\\\\''/g"`;; *) qprefix=$prefix;; esac prefixes="$prefixes '$qprefix'" fi fi prefix=$prefix/ done if test -n "$prefixes"; then # Don't fail if two instances are running concurrently. (umask $mkdir_umask && eval "\$doit_exec \$mkdirprog $prefixes") || test -d "$dstdir" || exit 1 obsolete_mkdir_used=true fi fi fi if test -n "$dir_arg"; then { test -z "$chowncmd" || $doit $chowncmd "$dst"; } && { test -z "$chgrpcmd" || $doit $chgrpcmd "$dst"; } && { test "$obsolete_mkdir_used$chowncmd$chgrpcmd" = false || test -z "$chmodcmd" || $doit $chmodcmd $mode "$dst"; } || exit 1 else # Make a couple of temp file names in the proper directory. dsttmp=$dstdir/_inst.$$_ rmtmp=$dstdir/_rm.$$_ # Trap to clean up those temp files at exit. trap 'ret=$?; rm -f "$dsttmp" "$rmtmp" && exit $ret' 0 # Copy the file name to the temp name. (umask $cp_umask && $doit_exec $cpprog "$src" "$dsttmp") && # and set any options; do chmod last to preserve setuid bits. # # If any of these fail, we abort the whole thing. If we want to # ignore errors from any of these, just make sure not to ignore # errors from the above "$doit $cpprog $src $dsttmp" command. # { test -z "$chowncmd" || $doit $chowncmd "$dsttmp"; } && { test -z "$chgrpcmd" || $doit $chgrpcmd "$dsttmp"; } && { test -z "$stripcmd" || $doit $stripcmd "$dsttmp"; } && { test -z "$chmodcmd" || $doit $chmodcmd $mode "$dsttmp"; } && # If -C, don't bother to copy if it wouldn't change the file. if $copy_on_change && old=`LC_ALL=C ls -dlL "$dst" 2>/dev/null` && new=`LC_ALL=C ls -dlL "$dsttmp" 2>/dev/null` && eval "$initialize_posix_glob" && $posix_glob set -f && set X $old && old=:$2:$4:$5:$6 && set X $new && new=:$2:$4:$5:$6 && $posix_glob set +f && test "$old" = "$new" && $cmpprog "$dst" "$dsttmp" >/dev/null 2>&1 then rm -f "$dsttmp" else # Rename the file to the real destination. $doit $mvcmd -f "$dsttmp" "$dst" 2>/dev/null || # The rename failed, perhaps because mv can't rename something else # to itself, or perhaps because mv is so ancient that it does not # support -f. { # Now remove or move aside any old file at destination location. # We try this two ways since rm can't unlink itself on some # systems and the destination file might be busy for other # reasons. In this case, the final cleanup might fail but the new # file should still install successfully. { test ! -f "$dst" || $doit $rmcmd -f "$dst" 2>/dev/null || { $doit $mvcmd -f "$dst" "$rmtmp" 2>/dev/null && { $doit $rmcmd -f "$rmtmp" 2>/dev/null; :; } } || { echo "$0: cannot unlink or rename $dst" >&2 (exit 1); exit 1 } } && # Now rename the file to the real destination. $doit $mvcmd "$dsttmp" "$dst" } fi || exit 1 trap '' 0 fi done # Local variables: # eval: (add-hook 'write-file-hooks 'time-stamp) # time-stamp-start: "scriptversion=" # time-stamp-format: "%:y-%02m-%02d.%02H" # time-stamp-time-zone: "UTC" # time-stamp-end: "; # UTC" # End: ldns-1.6.17/drill/work.c0000664000175100017510000001173212264060151014353 0ustar willemwillem/* * work.c * Where all the hard work is done * (c) 2005 NLnet Labs * * See the file LICENSE for the license * */ #include "drill.h" #include /** * Converts a hex string to binary data * len is the length of the string * buf is the buffer to store the result in * offset is the starting position in the result buffer * * This function returns the length of the result */ size_t hexstr2bin(char *hexstr, int len, uint8_t *buf, size_t offset, size_t buf_len) { char c; int i; uint8_t int8 = 0; int sec = 0; size_t bufpos = 0; if (len % 2 != 0) { return 0; } for (i=0; i= '0' && c <= '9') { int8 += c & 0x0f; } else if (c >= 'a' && c <= 'z') { int8 += (c & 0x0f) + 9; } else if (c >= 'A' && c <= 'Z') { int8 += (c & 0x0f) + 9; } else { return 0; } if (sec == 0) { int8 = int8 << 4; sec = 1; } else { if (bufpos + offset + 1 <= buf_len) { buf[bufpos+offset] = int8; int8 = 0; sec = 0; bufpos++; } else { error("Buffer too small in hexstr2bin"); } } } } return bufpos; } size_t packetbuffromfile(char *filename, uint8_t *wire) { FILE *fp = NULL; int c; /* stat hack * 0 = normal * 1 = comment (skip to end of line) * 2 = unprintable character found, read binary data directly */ int state = 0; uint8_t *hexbuf = xmalloc(LDNS_MAX_PACKETLEN); int hexbufpos = 0; size_t wirelen; if (strncmp(filename, "-", 2) == 0) { fp = stdin; } else { fp = fopen(filename, "r"); } if (fp == NULL) { perror("Unable to open file for reading"); xfree(hexbuf); return 0; } /*verbose("Opened %s\n", filename);*/ c = fgetc(fp); while (c != EOF && hexbufpos < LDNS_MAX_PACKETLEN) { if (state < 2 && !isascii(c)) { /*verbose("non ascii character found in file: (%d) switching to raw mode\n", c);*/ state = 2; } switch (state) { case 0: if ( (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F') ) { hexbuf[hexbufpos] = (uint8_t) c; hexbufpos++; } else if (c == ';') { state = 1; } else if (c == ' ' || c == '\t' || c == '\n') { /* skip whitespace */ } break; case 1: if (c == '\n' || c == EOF) { state = 0; } break; case 2: hexbuf[hexbufpos] = (uint8_t) c; hexbufpos++; break; } c = fgetc(fp); } if (c == EOF) { /* if (have_drill_opt && drill_opt->verbose) { verbose("END OF FILE REACHED\n"); if (state < 2) { verbose("read:\n"); verbose("%s\n", hexbuf); } else { verbose("Not printing wire because it contains non ascii data\n"); } } */ } if (hexbufpos >= LDNS_MAX_PACKETLEN) { /*verbose("packet size reached\n");*/ } /* lenient mode: length must be multiple of 2 */ if (hexbufpos % 2 != 0) { hexbuf[hexbufpos] = (uint8_t) '0'; hexbufpos++; } if (state < 2) { wirelen = hexstr2bin((char *) hexbuf, hexbufpos, wire, 0, LDNS_MAX_PACKETLEN); } else { memcpy(wire, hexbuf, (size_t) hexbufpos); wirelen = (size_t) hexbufpos; } if (fp != stdin) { fclose(fp); } xfree(hexbuf); return wirelen; } ldns_buffer * read_hex_buffer(char *filename) { uint8_t *wire; size_t wiresize; ldns_buffer *result_buffer = NULL; wire = xmalloc(LDNS_MAX_PACKETLEN); wiresize = packetbuffromfile(filename, wire); result_buffer = LDNS_MALLOC(ldns_buffer); ldns_buffer_new_frm_data(result_buffer, wire, wiresize); ldns_buffer_set_position(result_buffer, ldns_buffer_capacity(result_buffer)); xfree(wire); return result_buffer; } ldns_pkt * read_hex_pkt(char *filename) { uint8_t *wire; size_t wiresize; ldns_pkt *pkt = NULL; ldns_status status = LDNS_STATUS_ERR; wire = xmalloc(LDNS_MAX_PACKETLEN); wiresize = packetbuffromfile(filename, wire); if (wiresize > 0) { status = ldns_wire2pkt(&pkt, wire, wiresize); } xfree(wire); if (status == LDNS_STATUS_OK) { return pkt; } else { fprintf(stderr, "Error parsing hex file: %s\n", ldns_get_errorstr_by_id(status)); return NULL; } } void dump_hex(const ldns_pkt *pkt, const char *filename) { uint8_t *wire = NULL; size_t size, i; FILE *fp; ldns_status status; fp = fopen(filename, "w"); if (fp == NULL) { error("Unable to open %s for writing", filename); return; } status = ldns_pkt2wire(&wire, pkt, &size); if (status != LDNS_STATUS_OK) { error("Unable to convert packet: error code %u", status); LDNS_FREE(wire); fclose(fp); return; } fprintf(fp, "; 0"); for (i = 1; i < 20; i++) { fprintf(fp, " %2u", (unsigned int) i); } fprintf(fp, "\n"); fprintf(fp, ";--"); for (i = 1; i < 20; i++) { fprintf(fp, " --"); } fprintf(fp, "\n"); for (i = 0; i < size; i++) { if (i % 20 == 0 && i > 0) { fprintf(fp, "\t;\t%4u-%4u\n", (unsigned int) i-19, (unsigned int) i); } fprintf(fp, " %02x", (unsigned int)wire[i]); } fprintf(fp, "\n"); fclose(fp); LDNS_FREE(wire); } ldns-1.6.17/drill/config.h.in0000664000175100017510000001524612264060171015256 0ustar willemwillem/* config.h.in. Generated from configure.ac by autoheader. */ /* Define to 1 if you have the header file. */ #undef HAVE_ARPA_INET_H /* Define to 1 if you have the header file. */ #undef HAVE_ASSERT_H /* Define to 1 if you have the header file. */ #undef HAVE_CTYPE_H /* Whether getaddrinfo is available */ #undef HAVE_GETADDRINFO /* Define to 1 if you have the header file. */ #undef HAVE_GETOPT_H /* If you have HMAC_CTX_init */ #undef HAVE_HMAC_CTX_INIT /* Define to 1 if you have the header file. */ #undef HAVE_INTTYPES_H /* Define to 1 if you have the `isblank' function. */ #undef HAVE_ISBLANK /* Define to 1 if you have the `ldns' library (-lldns). */ #undef HAVE_LIBLDNS /* Define to 1 if you have the header file. */ #undef HAVE_MEMORY_H /* Define to 1 if you have the header file. */ #undef HAVE_NETINET_IF_ETHER_H /* Define to 1 if you have the header file. */ #undef HAVE_NETINET_IN_H /* Define to 1 if you have the header file. */ #undef HAVE_NETINET_IN_SYSTM_H /* Define to 1 if you have the header file. */ #undef HAVE_NETINET_IP6_H /* Define to 1 if you have the header file. */ #undef HAVE_NETINET_IP_H /* Define to 1 if you have the header file. */ #undef HAVE_NETINET_UDP_H /* Define to 1 if you have the header file. */ #undef HAVE_NET_IF_H /* Define to 1 if you have the header file. */ #undef HAVE_OPENSSL_ERR_H /* Define to 1 if you have the header file. */ #undef HAVE_OPENSSL_RAND_H /* Define to 1 if you have the header file. */ #undef HAVE_OPENSSL_SSL_H /* Define if you have the SSL libraries installed. */ #undef HAVE_SSL /* Define to 1 if you have the header file. */ #undef HAVE_STDINT_H /* Define to 1 if you have the header file. */ #undef HAVE_STDIO_H /* Define to 1 if you have the header file. */ #undef HAVE_STDLIB_H /* Define to 1 if you have the header file. */ #undef HAVE_STRINGS_H /* Define to 1 if you have the header file. */ #undef HAVE_STRING_H /* Define to 1 if you have the header file. */ #undef HAVE_SYS_MOUNT_H /* Define to 1 if you have the header file. */ #undef HAVE_SYS_PARAM_H /* Define to 1 if you have the header file. */ #undef HAVE_SYS_SELECT_H /* Define to 1 if you have the header file. */ #undef HAVE_SYS_SOCKET_H /* Define to 1 if you have the header file. */ #undef HAVE_SYS_STAT_H /* Define to 1 if you have the header file. */ #undef HAVE_SYS_TIME_H /* Define to 1 if you have the header file. */ #undef HAVE_SYS_TYPES_H /* Define to 1 if you have the header file. */ #undef HAVE_TIME_H /* Define to 1 if you have the header file. */ #undef HAVE_UNISTD_H /* Define to 1 if you have the header file. */ #undef HAVE_WINSOCK2_H /* Define to 1 if you have the header file. */ #undef HAVE_WS2TCPIP_H /* Default trust anchor file */ #undef LDNS_TRUST_ANCHOR_FILE /* Define to the address where bug reports for this package should be sent. */ #undef PACKAGE_BUGREPORT /* Define to the full name of this package. */ #undef PACKAGE_NAME /* Define to the full name and version of this package. */ #undef PACKAGE_STRING /* Define to the one symbol short name of this package. */ #undef PACKAGE_TARNAME /* Define to the home page for this package. */ #undef PACKAGE_URL /* Define to the version of this package. */ #undef PACKAGE_VERSION /* Define to 1 if you have the ANSI C header files. */ #undef STDC_HEADERS /* Enable extensions on AIX 3, Interix. */ #ifndef _ALL_SOURCE # undef _ALL_SOURCE #endif /* Enable GNU extensions on systems that have them. */ #ifndef _GNU_SOURCE # undef _GNU_SOURCE #endif /* Enable threading extensions on Solaris. */ #ifndef _POSIX_PTHREAD_SEMANTICS # undef _POSIX_PTHREAD_SEMANTICS #endif /* Enable extensions on HP NonStop. */ #ifndef _TANDEM_SOURCE # undef _TANDEM_SOURCE #endif /* Enable general extensions on Solaris. */ #ifndef __EXTENSIONS__ # undef __EXTENSIONS__ #endif /* Whether the windows socket API is used */ #undef USE_WINSOCK /* the version of the windows API enabled */ #undef WINVER /* Define to 1 if on MINIX. */ #undef _MINIX /* Define to 2 if the system does not provide POSIX.1 features except with this defined. */ #undef _POSIX_1_SOURCE /* Define to 1 if you need to in order for `stat' and other things to work. */ #undef _POSIX_SOURCE /* in_addr_t */ #undef in_addr_t /* in_port_t */ #undef in_port_t /* Define to `__inline__' or `__inline' if that's what the C compiler calls it, or to nothing if 'inline' is not supported under any name. */ #ifndef __cplusplus #undef inline #endif /* Define to `short' if does not define. */ #undef int16_t /* Define to `int' if does not define. */ #undef int32_t /* Define to `long long' if does not define. */ #undef int64_t /* Define to `char' if does not define. */ #undef int8_t /* Define to `unsigned int' if does not define. */ #undef size_t /* Define to 'int' if not defined */ #undef socklen_t /* Define to `int' if does not define. */ #undef ssize_t /* Define to `unsigned short' if does not define. */ #undef uint16_t /* Define to `unsigned int' if does not define. */ #undef uint32_t /* Define to `unsigned long long' if does not define. */ #undef uint64_t /* Define to `unsigned char' if does not define. */ #undef uint8_t #include #include #include #include #if STDC_HEADERS #include #include #endif #ifdef HAVE_STDINT_H #include #endif #ifdef HAVE_SYS_SOCKET_H #include #endif #ifdef HAVE_NETINET_IN_H #include #endif #ifdef HAVE_ARPA_INET_H #include #endif #ifdef HAVE_NETINET_UDP_H #include #endif #ifdef HAVE_TIME_H #include #endif #ifdef HAVE_NETINET_IN_SYSTM_H #include #endif #ifdef HAVE_NETINET_IP_H #include #endif #ifdef HAVE_NET_IF_H #include #endif #ifdef HAVE_NETINET_IF_ETHER_H #include #endif #ifdef HAVE_WINSOCK2_H #define USE_WINSOCK 1 #include #endif #ifdef HAVE_WS2TCPIP_H #include #endif extern char *optarg; extern int optind, opterr; #ifndef EXIT_FAILURE #define EXIT_FAILURE 1 #endif #ifndef EXIT_SUCCESS #define EXIT_SUCCESS 0 #endif #ifdef S_SPLINT_S #define FD_ZERO(a) /* a */ #define FD_SET(a,b) /* a, b */ #endif ldns-1.6.17/drill/ChangeLog.22-nov-20050000664000175100017510000000641512264060151016407 0ustar willemwillem--------- Drill now is a subdirectory in ldns. To make life easier --------- we are using ldns' version numbering for drill from now on. --------- Sadly this means we GO BACKWARDS in the versions --------- This ChangeLog will not be updated anymore - all changes are --------- documented in ldns' ChangeLog 1.0-pre3: to be released: drill-team * Secure tracing works * Added section about DNSSEC in the manual page * Allow the class information to be given to do_chase() * Lint fixes for the code * Bugzilla was setup for drill * Bug #97 (drill); -S crash was fixed * Add -Q (quiet) flag was added. This supresses output from drill. 1.0-pre2: 20 Jun 2005: drill-team * Second prerelease * Bugs where fix in the chasing functionality 1.0-pre1: 1 Jun 2005: drill-team * First drill release based on ldns * drill's core code is not much more simple, as all the difficult stuff is moved to ldns. * Much saner argument parsing ---------- Above Newer drill based on ldns -------------- ---------- Below Older drill with it's own DNS handling -------------- 0.9.2: Feb 3 2005: drill-team * Added two more options (borrowed from dig) --rd, don't set the RD bit in queries --fail, don't query the next nameserver on SERVFAIL * Fixed handling of obscure data types * Handle classes other the 'IN' when making a query * For people using FreeBSD: drill is now in the ports (Thanks to Jaap Akkerhuis) 0.9.1: Jan 5 2005: drill-team * Makefile tweaks * drill ns . works * re-check the root in when tracing * added handling for some lesser known types (including WKS) 0.9: Dec 6 2004: drill-team * big configure.ac and Makefile.in updates (made more general) * escapes in names argument and txt and dname data * gcc 2(.95) support * packet wire data is now checked for dangerous elements (like looping compression etc) * (Multiple) Octal char representation * Responses can be saved to file * 'Answers' can be read from file instead of server * Lots and lots of bugfixes and improvements 0.8.1: Oct 27 2004: Miek * configure.ac updates * secure resolving updates (still doesn't work) * printing additions - CERT RR supported - LOC RR support * All non supported RRs are handled as unknown * If no namservers found in /etc/resolv.conf default to 127.0.0.1 * Various bugs fixed - Close sockets after using them - Some memory leaks were plugged 0.8: Oct 26 2004: Miek * Lots of features added. Drill is almost feature complete * Unknown RR's are supported * Numerous smaller updates in documentation * Numerous code cleanups * Dig is no longer needed to build drill 0.7: Oct 21 2004: Miek * reworked interal code * DNSSEC is working, except the secure resolving * build updates * more sane options parsing * more sane argument handling 0.6-alpha: Oct 2004: Jelte * No log 0.5-alpha: Sept 22 2004: Miek * most of the DNS stuff is working * moved to configure * tested on Linux/FreeBSD * fully IPV6 capable * new DNSSEC types supported * DNSSEC somewhat working * gcc => 3 is needed for building 0.4-alpha: Sept 9 2004: Miek * moved to autoconf for building * lots of various updates * really a workable program now 0.3-alpha: Sept 6 2004: Miek * IPv6 support * automatic secure resolving * --trace updates * --chase updates * more checks ldns-1.6.17/drill/REGRESSIONS0000664000175100017510000000156212264060151014753 0ustar willemwillemREGRESSIONS This version of drill is based on ldns and as such some things are slightly changed. This file documents the changes. o When tracing (-T option) we use the local resolver (as specified in /etc/resolv.conf) to lookup names. This increases the speed dramatically, but you obviously need to be able to reach a recursive server/cache. Previously drill would try to resolve the names by itself. o Printing of DSs after DNSKEY records. Because we don't parse our own packets anymore, we cannot print the DS directly after the DNSKEY record. The DSs are now printed AFTER the packet. o The long options are removed. o The chase function has a different output, and will be subject to change in the near future. o The useless (for jokes only) -I option was dropped. FIXED: o the argument parsing is much smarter, the order doesn't matter (much) anymore ldns-1.6.17/drill/drill.1.in0000664000175100017510000001435612264060151015027 0ustar willemwillem.\" @(#)drill.1 1.7.0 14-Jul-2004 OF; .TH drill 1 "28 May 2006" .SH NAME drill \- get (debug) information out of DNS(SEC) .SH SYNOPSIS .B drill [ .IR OPTIONS ] .IR name [ .IR @server ] [ .IR type ] [ .IR class ] .SH DESCRIPTION \fBdrill\fR is a tool to designed to get all sorts of information out of the DNS. It is specificly designed to be used with DNSSEC. .PP The name \fBdrill\fR is a pun on \fBdig\fR. With \fBdrill\fR you should be able get even more information than with \fBdig\fR. .PP If no arguments are given class defaults to 'IN' and type to 'A'. The server(s) specified in /etc/resolv.conf are used to query against. .PP \fIname\fR Ask for this name. .PP \fI@server\fR Send to query to this server. If not specified use the nameservers from \fI/etc/resolv.conf\fR. .PP \fItype\fR Ask for this RR type. If type is not given on the command line it defaults to 'A'. Except when doing to reverse lookup when it defaults to 'PTR'. .PP \fIclass\fR Use this class when querying. .SH SAMPLE USAGE \fBdrill mx miek.nl\fR Show the MX records of the domain miek.nl .TP \fBdrill -S jelte.nlnetlabs.nl\fR Chase any signatures in the jelte.nlnetlab.nl domain. This option is only available when ldns has been compiled with openssl-support. .TP \fBdrill -TD www.example.com\fR Do a DNSSEC (-D) trace (-T) from the rootservers down to www.example.com. This option only works when ldns has been compiled with openssl support. .TP \fBdrill -s dnskey jelte.nlnetlabs.nl\fR Show the DNSKEY record(s) for jelte.nlnetlabs.nl. For each found DNSKEY record also print the DS record. .SH OPTIONS .TP \fB\-D Enable DNSSEC in the query. When querying for DNSSEC types (DNSKEY, RRSIG, DS and NSEC) this is \fInot\fR automaticly enabled. .TP \fB\-T Trace \fIname\fR from the root down. When using this option the @server and the type arguments are not used. .TP \fB\-S Chase the signature(s) of 'name' to a known key or as high up in the tree as possible. .TP \fB\-I \fIIPv4 or IPv6 address\fR Source address to query from. The source address has to be present on an interface of the host running drill. .TP \fB\-V \fIlevel\fR Be more verbose. Set level to 5 to see the actual query that is sent. .TP \fB\-Q Quiet mode, this overrules -V. .TP \fB\-f \fIfile\fR Read the query from a file. The query must be dumped with -w. .TP \fB\-i \fIfile\fR read the answer from the file instead from the network. This aids in debugging and can be used to check if a query on disk is valid. If the file contains binary data it is assumed to be a query in network order. .TP \fB\-w \fIfile\fR Write an answer packet to file. .TP \fB\-q \fIfile\fR Write the query packet to file. .TP \fB\-v Show drill's version. .TP \fB\-h Show a short help message. .SS QUERY OPTIONS .TP \fB\-4 Stay on ip4. Only send queries to ip4 enabled nameservers. .TP \fB\-6 Stay on ip6. Only send queries to ip6 enabled nameservers. .TP \fB\-a Use the resolver structure's fallback mechanism if the answer is truncated (TC=1). If a truncated packet is received and this option is set, drill will first send a new query with EDNS0 buffer size 4096. If the EDNS0 buffer size was already set to 512+ bytes, or the above retry also results in a truncated answer, the resolver structure will fall back to TCP. .TP \fB\-b \fIsize\fR Use size as the buffer size in the EDNS0 pseudo RR. .TP \fB\-c \fIfile\fR Use file instead of /etc/resolv.conf for nameserver configuration. .TP \fB\-d \fIdomain\fR When tracing (-T), start from this domain instead of the root. .TP \fB\-t Use TCP/IP when querying a server .TP \fB\-k \fIkeyfile\fR Use this file to read a (trusted) key from. When this options is given \fBdrill\fR tries to validate the current answer with this key. No chasing is done. When \fBdrill\fR is doing a secure trace, this key will be used as trust anchor. Can contain a DNSKEY or a DS record. Alternatively, when DNSSEC enabled tracing (\fB-TD\fR) or signature chasing (\fB-S\fR), if \fB-k\fR is not specified, and a default trust anchor (@LDNS_TRUST_ANCHOR_FILE@) exists and contains a valid DNSKEY or DS record, it will be used as the trust anchor. .TP \fB\-o \fImnemonic\fR Use this option to set or unset specific header bits. A bit is set by using the bit mnemonic in CAPITAL letters. A bit is unset when the mnemonic is given in lowercase. The following mnemonics are understood by \fBdrill\fR: QR, qr: set, unset QueRy (default: on) AA, aa: set, unset Authoritative Answer (default: off) TC, tc: set, unset TrunCated (default: off) RD, rd: set, unset Recursion Desired (default: on) CD, cd: set, unset Checking Disabled (default: off) RA, ra: set, unset Recursion Available (default: off) AD, ad: set, unset Authenticated Data (default: off) Thus: \fB-o CD\fR, will enable Checking Disabled, which instructs the cache to not validate the answers it gives out. .TP \fB\-p \fIport\fR Use this port instead of the default of 53. .TP \fB\-r \fIfile\fR When tracing (-T), use file as a root servers hint file. .TP \fB\-s When encountering a DNSKEY print the equivalent DS also. .TP \fB\-u Use UDP when querying a server. This is the default. .TP \fB\-w \fIfile\fR write the answer to a file. The file will contain a hexadecimal dump of the query. This can be used in conjunction with -f. .TP \fB\-x Do a reverse loopup. The type argument is not used, it is preset to PTR. .TP \fB\-y \fI\fR specify named base64 tsig key, and optional an algorithm (defaults to hmac-md5.sig-alg.reg.int) .TP \fB\-z \fR don't randomize the nameserver list before sending queries. .SH "EXIT STATUS" The exit status is 0 if the looked up answer is secure and trusted, or insecure. The exit status is not 0 if the looked up answer is untrusted or bogus, or an error occurred while performing the lookup. .SH "FILES" .TP @LDNS_TRUST_ANCHOR_FILE@ The file from which trusted keys are loaded when no \fB-k\fR option is given. .SH "SEE ALSO" .LP unbound-anchor(8) .SH AUTHOR Jelte Jansen and Miek Gieben. Both of NLnet Labs. .SH REPORTING BUGS Report bugs to . .SH BUGS .SH COPYRIGHT Copyright (c) 2004-2008 NLnet Labs. Licensed under the revised BSD license. There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. .SH SEE ALSO \fBdig\fR(1), \fIRFC403{3,4,5}\fR. ldns-1.6.17/drill/drill_util.c0000664000175100017510000001545612264060151015543 0ustar willemwillem/* * util.c * some handy function needed in drill and not implemented * in ldns * (c) 2005 NLnet Labs * * See the file LICENSE for the license * */ #include "drill.h" #include #include static int read_line(FILE *input, char *line, size_t len) { int i; int c; for (i = 0; i < (int)len-1; i++) { c = getc(input); if (c == EOF) { return -1; } else if (c != '\n') { line[i] = c; } else { break; } } line[i] = '\0'; return i; } /* key_list must be initialized with ldns_rr_list_new() */ ldns_status read_key_file(const char *filename, ldns_rr_list *key_list, bool silently) { int line_len = 0; int line_nr = 0; int key_count = 0; char line[LDNS_MAX_LINELEN]; ldns_status status; FILE *input_file; ldns_rr *rr; input_file = fopen(filename, "r"); if (!input_file) { if (! silently) { fprintf(stderr, "Error opening %s: %s\n", filename, strerror(errno)); } return LDNS_STATUS_ERR; } while (line_len >= 0) { line_len = (int) read_line(input_file, line, sizeof(line)); line_nr++; if (line_len > 0 && line[0] != ';') { status = ldns_rr_new_frm_str(&rr, line, 0, NULL, NULL); if (status != LDNS_STATUS_OK) { if (! silently) { fprintf(stderr, "Error parsing DNSKEY RR " "in line %d: %s\n", line_nr, ldns_get_errorstr_by_id(status) ); } } else if (ldns_rr_get_type(rr) == LDNS_RR_TYPE_DNSKEY || ldns_rr_get_type(rr) == LDNS_RR_TYPE_DS) { ldns_rr_list_push_rr(key_list, rr); key_count++; } else { ldns_rr_free(rr); } } } fclose(input_file); if (key_count > 0) { return LDNS_STATUS_OK; } else { /*fprintf(stderr, "No keys read\n");*/ return LDNS_STATUS_ERR; } } ldns_rdf * ldns_rdf_new_addr_frm_str(char *str) { ldns_rdf *a; a = ldns_rdf_new_frm_str(LDNS_RDF_TYPE_A, str); if (!a) { /* maybe ip6 */ a = ldns_rdf_new_frm_str(LDNS_RDF_TYPE_AAAA, str); if (!a) { return NULL; } } return a; } static inline void local_print_ds(FILE* out, const char* pre, ldns_rr* ds) { if (out && ds) { fprintf(out, "%s", pre); ldns_rr_print(out, ds); ldns_rr_free(ds); } } /* * For all keys in a packet print the DS */ void print_ds_of_keys(ldns_pkt *p) { ldns_rr_list *keys; uint16_t i; ldns_rr *ds; /* TODO fix the section stuff, here or in ldns */ keys = ldns_pkt_rr_list_by_type(p, LDNS_RR_TYPE_DNSKEY, LDNS_SECTION_ANSWER); /* this also returns the question section rr, which does not * have any data.... and this inturn crashes everything */ if (keys) { for (i = 0; i < ldns_rr_list_rr_count(keys); i++) { fprintf(stdout, ";\n; equivalent DS records for key %u:\n", (unsigned int)ldns_calc_keytag(ldns_rr_list_rr(keys, i))); ds = ldns_key_rr2ds(ldns_rr_list_rr(keys, i), LDNS_SHA1); local_print_ds(stdout, "; sha1: ", ds); ds = ldns_key_rr2ds(ldns_rr_list_rr(keys, i), LDNS_SHA256); local_print_ds(stdout, "; sha256: ", ds); } ldns_rr_list_deep_free(keys); } } static void print_class_type(FILE *fp, ldns_rr *r) { ldns_lookup_table *lt; lt = ldns_lookup_by_id(ldns_rr_classes, ldns_rr_get_class(r)); if (lt) { fprintf(fp, " %s", lt->name); } else { fprintf(fp, " CLASS%d", ldns_rr_get_class(r)); } /* okay not THE way - but the quickest */ switch (ldns_rr_get_type(r)) { case LDNS_RR_TYPE_RRSIG: fprintf(fp, " RRSIG "); break; case LDNS_RR_TYPE_DNSKEY: fprintf(fp, " DNSKEY "); break; case LDNS_RR_TYPE_DS: fprintf(fp, " DS "); break; default: break; } } void print_ds_abbr(FILE *fp, ldns_rr *ds) { if (!ds || (ldns_rr_get_type(ds) != LDNS_RR_TYPE_DS)) { return; } ldns_rdf_print(fp, ldns_rr_owner(ds)); fprintf(fp, " %d", (int)ldns_rr_ttl(ds)); print_class_type(fp, ds); ldns_rdf_print(fp, ldns_rr_rdf(ds, 0)); fprintf(fp, " "); ldns_rdf_print(fp, ldns_rr_rdf(ds, 1)); fprintf(fp, " "); ldns_rdf_print(fp, ldns_rr_rdf(ds, 2)); fprintf(fp, " "); ldns_rdf_print(fp, ldns_rr_rdf(ds, 3)); fprintf(fp, " "); } /* print some of the elements of a signature */ void print_rrsig_abbr(FILE *fp, ldns_rr *sig) { if (!sig || (ldns_rr_get_type(sig) != LDNS_RR_TYPE_RRSIG)) { return; } ldns_rdf_print(fp, ldns_rr_owner(sig)); fprintf(fp, " %d", (int)ldns_rr_ttl(sig)); print_class_type(fp, sig); /* print a number of rdf's */ /* typecovered */ ldns_rdf_print(fp, ldns_rr_rdf(sig, 0)); fprintf(fp, " "); /* algo */ ldns_rdf_print(fp, ldns_rr_rdf(sig, 1)); fprintf(fp, " "); /* labels */ ldns_rdf_print(fp, ldns_rr_rdf(sig, 2)); fprintf(fp, " (\n\t\t\t"); /* expir */ ldns_rdf_print(fp, ldns_rr_rdf(sig, 4)); fprintf(fp, " "); /* incep */ ldns_rdf_print(fp, ldns_rr_rdf(sig, 5)); fprintf(fp, " "); /* key-id */ ldns_rdf_print(fp, ldns_rr_rdf(sig, 6)); fprintf(fp, " "); /* key owner */ ldns_rdf_print(fp, ldns_rr_rdf(sig, 7)); fprintf(fp, ")"); } void print_dnskey_abbr(FILE *fp, ldns_rr *key) { if (!key || (ldns_rr_get_type(key) != LDNS_RR_TYPE_DNSKEY)) { return; } ldns_rdf_print(fp, ldns_rr_owner(key)); fprintf(fp, " %d", (int)ldns_rr_ttl(key)); print_class_type(fp, key); /* print a number of rdf's */ /* flags */ ldns_rdf_print(fp, ldns_rr_rdf(key, 0)); fprintf(fp, " "); /* proto */ ldns_rdf_print(fp, ldns_rr_rdf(key, 1)); fprintf(fp, " "); /* algo */ ldns_rdf_print(fp, ldns_rr_rdf(key, 2)); if (ldns_rdf2native_int16(ldns_rr_rdf(key, 0)) == 256) { fprintf(fp, " ;{id = %u (zsk), size = %db}", (unsigned int)ldns_calc_keytag(key), (int)ldns_rr_dnskey_key_size(key)); return; } if (ldns_rdf2native_int16(ldns_rr_rdf(key, 0)) == 257) { fprintf(fp, " ;{id = %u (ksk), size = %db}", (unsigned int)ldns_calc_keytag(key), (int)ldns_rr_dnskey_key_size(key)); return; } fprintf(fp, " ;{id = %u, size = %db}", (unsigned int)ldns_calc_keytag(key), (int)ldns_rr_dnskey_key_size(key)); } void print_rr_list_abbr(FILE *fp, ldns_rr_list *rrlist, const char *usr) { size_t i; ldns_rr_type tp; for(i = 0; i < ldns_rr_list_rr_count(rrlist); i++) { tp = ldns_rr_get_type(ldns_rr_list_rr(rrlist, i)); if (i == 0 && tp != LDNS_RR_TYPE_RRSIG) { if (usr) { fprintf(fp, "%s ", usr); } } switch(tp) { case LDNS_RR_TYPE_DNSKEY: print_dnskey_abbr(fp, ldns_rr_list_rr(rrlist, i)); break; case LDNS_RR_TYPE_RRSIG: print_rrsig_abbr(fp, ldns_rr_list_rr(rrlist, i)); break; case LDNS_RR_TYPE_DS: print_ds_abbr(fp, ldns_rr_list_rr(rrlist, i)); break; default: /* not handled */ break; } fputs("\n", fp); } } void * xmalloc(size_t s) { void *p; p = malloc(s); if (!p) { printf("Mem failure\n"); exit(EXIT_FAILURE); } return p; } void * xrealloc(void *p, size_t size) { void *q; q = realloc(p, size); if (!q) { printf("Mem failure\n"); exit(EXIT_FAILURE); } return q; } void xfree(void *p) { if (p) { free(p); } } ldns-1.6.17/drill/configure.ac0000664000175100017510000001500012264060151015503 0ustar willemwillem# -*- Autoconf -*- # Process this file with autoconf to produce a configure script. AC_PREREQ(2.56) AC_INIT(ldns, 1.6.17, libdns@nlnetlabs.nl,libdns) AC_CONFIG_SRCDIR([drill.c]) sinclude(../acx_nlnetlabs.m4) OURCPPFLAGS='' CPPFLAGS=${CPPFLAGS:-${OURCPPFLAGS}} OURCFLAGS='-g' CFLAGS=${CFLAGS:-${OURCFLAGS}} AC_DEFINE(WINVER, 0x0502, [the version of the windows API enabled]) AC_AIX # Checks for programs. AC_PROG_CC AC_PROG_MAKE_SET AC_CHECK_PROGS(libtool, [glibtool libtool15 libtool], [../libtool]) # add option to disable the evil rpath dnl Check whether to use rpath or not AC_ARG_ENABLE(rpath, [ --disable-rpath disable hardcoded rpath (default=enabled)], enable_rpath=$enableval, enable_rpath=yes) if test "x$enable_rpath" = xyes; then RPATH_VAL="-Wl,-rpath=\${libdir}" fi ACX_CHECK_COMPILER_FLAG(std=c99, [C99FLAG="-std=c99"]) ACX_CHECK_COMPILER_FLAG(xc99, [C99FLAG="-xc99"]) AC_TYPE_SIZE_T ACX_CHECK_COMPILER_FLAG(O2, [CFLAGS="$CFLAGS -O2"]) ACX_CHECK_COMPILER_FLAG_NEEDED($C99FLAG -D__EXTENSIONS__ -D_BSD_SOURCE -D_POSIX_C_SOURCE=200112 -D_XOPEN_SOURCE=600, [ #include "confdefs.h" #include #include #include #ifdef HAVE_TIME_H #include #endif #include #ifdef HAVE_GETOPT_H #include #endif int test() { int a; char **opts = NULL; struct timeval tv; char *t; time_t time = 0; char *buf = NULL; t = ctime_r(&time, buf); tv.tv_usec = 10; srandom(32); a = getopt(2, opts, "a"); a = isascii(32); return a; } ], [CFLAGS="$CFLAGS $C99FLAG -D__EXTENSIONS__ -D_BSD_SOURCE -D_POSIX_C_SOURCE=200112 -D_XOPEN_SOURCE=600"]) ACX_CHECK_COMPILER_FLAG_NEEDED($C99FLAG, [#include ], [CFLAGS="$CFLAGS $C99FLAG"]) AC_C_INLINE AC_CHECK_TYPE(int8_t, char) AC_CHECK_TYPE(int16_t, short) AC_CHECK_TYPE(int32_t, int) AC_CHECK_TYPE(int64_t, long long) AC_CHECK_TYPE(uint8_t, unsigned char) AC_CHECK_TYPE(uint16_t, unsigned short) AC_CHECK_TYPE(uint32_t, unsigned int) AC_CHECK_TYPE(uint64_t, unsigned long long) AC_CHECK_TYPE(ssize_t, int) AC_CHECK_HEADERS([sys/types.h getopt.h stdlib.h stdio.h assert.h netinet/in.h ctype.h time.h arpa/inet.h sys/time.h sys/socket.h sys/select.h],,, [AC_INCLUDES_DEFAULT]) AC_CHECK_HEADERS([netinet/in_systm.h net/if.h netinet/ip.h netinet/udp.h netinet/if_ether.h netinet/ip6.h],,, [ AC_INCLUDES_DEFAULT #ifdef HAVE_NETINET_IN_SYSTM_H #include #endif #ifdef HAVE_NETINET_IN_H #include #endif #ifdef HAVE_SYS_SOCKET_H #include #endif #ifdef HAVE_NET_IF_H #include #endif]) # MinGW32 tests AC_CHECK_HEADERS([winsock2.h ws2tcpip.h],,, [AC_INCLUDES_DEFAULT]) ACX_TYPE_SOCKLEN_T AC_CHECK_HEADERS([sys/param.h sys/mount.h],,, [AC_INCLUDES_DEFAULT] [ [ #if HAVE_SYS_PARAM_H # include #endif ] ]) AC_CHECK_TYPE(in_addr_t, [], [AC_DEFINE([in_addr_t], [uint32_t], [in_addr_t])], [ #if HAVE_SYS_TYPES_H # include #endif #if HAVE_NETINET_IN_H # include #endif]) AC_CHECK_TYPE(in_port_t, [], [AC_DEFINE([in_port_t], [uint16_t], [in_port_t])], [ #if HAVE_SYS_TYPES_H # include #endif #if HAVE_NETINET_IN_H # include #endif]) # check to see if libraries are needed for these functions. AC_SEARCH_LIBS(socket, socket) AC_SEARCH_LIBS([inet_pton], [nsl]) ACX_WITH_SSL_OPTIONAL ACX_CHECK_GETADDRINFO_WITH_INCLUDES LIBS_STC="$LIBS" AC_SUBST(LIBS_STC) # check for ldns AC_ARG_WITH(ldns, AC_HELP_STRING([--with-ldns=PATH specify prefix of path of ldns library to use]) , [ specialldnsdir="$withval" CPPFLAGS="$CPPFLAGS -I$withval/include" LDFLAGS="-L$withval -L$withval/lib $LDFLAGS" LDNSDIR="$withval" LIBS="-lldns $LIBS" LIBS_STC="$withval/lib/libldns.a $LIBS_STC" ] ) #AC_CHECK_HEADER(ldns/ldns.h,, [ # AC_MSG_ERROR([Can't find ldns headers (make copy-headers in devel source.)]) # ], [AC_INCLUDES_DEFAULT] #) AC_CHECK_FUNCS(isblank) # check for ldns development source tree AC_MSG_CHECKING([for ldns devel source]) ldns_dev_dir=.. if test -f $ldns_dev_dir/ldns/util.h && \ grep LDNS_VERSION $ldns_dev_dir/ldns/util.h >/dev/null; then ldns_version=`grep LDNS_VERSION $ldns_dev_dir/ldns/util.h | sed -e 's/^.*"\(.*\)".*$/\1/'` AC_MSG_RESULT([using $ldns_dev_dir with $ldns_version]) CPPFLAGS="$CPPFLAGS -I$ldns_dev_dir/include" LDFLAGS="-L$ldns_dev_dir -L$ldns_dev_dir/lib $LDFLAGS" LIBS="-lldns $LIBS" AC_DEFINE(HAVE_LIBLDNS, 1, [If the ldns library is available.]) LDNSDIR="$ldns_dev_dir" LIBS_STC="$ldns_dev_dir/lib/libldns.a $LIBS_STC" else AC_MSG_RESULT([no]) AC_CHECK_LIB(ldns, ldns_rr_new, , [ AC_MSG_ERROR([Can't find ldns library])dnl ' ] ) fi AC_SUBST(LDNSDIR) AC_ARG_WITH(trust-anchor, AC_HELP_STRING([--with-trust-anchor=KEYFILE], [Default location of the trust anchor file. [default=SYSCONFDIR/unbound/root.key]]), [ LDNS_TRUST_ANCHOR_FILE="$withval" ],[ if test "x$LDNS_TRUST_ANCHOR_FILE" = "x"; then if test "x$sysconfdir" = 'x${prefix}/etc' ; then if test "x$prefix" = 'xNONE' ; then LDNS_TRUST_ANCHOR_FILE="/etc/unbound/root.key" else LDNS_TRUST_ANCHOR_FILE="${prefix}/etc/unbound/root.key" fi else LDNS_TRUST_ANCHOR_FILE="${sysconfdir}/unbound/root.key" fi fi ]) AC_DEFINE_UNQUOTED([LDNS_TRUST_ANCHOR_FILE], ["$LDNS_TRUST_ANCHOR_FILE"], [Default trust anchor file]) AC_SUBST(LDNS_TRUST_ANCHOR_FILE) AC_MSG_NOTICE([Default trust anchor: $LDNS_TRUST_ANCHOR_FILE]) AH_BOTTOM([ #include #include #include #include #if STDC_HEADERS #include #include #endif #ifdef HAVE_STDINT_H #include #endif #ifdef HAVE_SYS_SOCKET_H #include #endif #ifdef HAVE_NETINET_IN_H #include #endif #ifdef HAVE_ARPA_INET_H #include #endif #ifdef HAVE_NETINET_UDP_H #include #endif #ifdef HAVE_TIME_H #include #endif #ifdef HAVE_NETINET_IN_SYSTM_H #include #endif #ifdef HAVE_NETINET_IP_H #include #endif #ifdef HAVE_NET_IF_H #include #endif #ifdef HAVE_NETINET_IF_ETHER_H #include #endif #ifdef HAVE_WINSOCK2_H #define USE_WINSOCK 1 #include #endif #ifdef HAVE_WS2TCPIP_H #include #endif extern char *optarg; extern int optind, opterr; #ifndef EXIT_FAILURE #define EXIT_FAILURE 1 #endif #ifndef EXIT_SUCCESS #define EXIT_SUCCESS 0 #endif #ifdef S_SPLINT_S #define FD_ZERO(a) /* a */ #define FD_SET(a,b) /* a, b */ #endif ]) AC_CONFIG_FILES([Makefile drill.1]) AC_CONFIG_HEADER([config.h]) AC_OUTPUT ldns-1.6.17/drill/configure0000775000175100017510000055553412264060171015153 0ustar willemwillem#! /bin/sh # Guess values for system-dependent variables and create Makefiles. # Generated by GNU Autoconf 2.68 for ldns 1.6.17. # # Report bugs to . # # # Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, # 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 Free Software # Foundation, Inc. # # # This configure script is free software; the Free Software Foundation # gives unlimited permission to copy, distribute and modify it. ## -------------------- ## ## M4sh Initialization. ## ## -------------------- ## # Be more Bourne compatible DUALCASE=1; export DUALCASE # for MKS sh if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then : emulate sh NULLCMD=: # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which # is contrary to our usage. Disable this feature. alias -g '${1+"$@"}'='"$@"' setopt NO_GLOB_SUBST else case `(set -o) 2>/dev/null` in #( *posix*) : set -o posix ;; #( *) : ;; esac fi as_nl=' ' export as_nl # Printing a long string crashes Solaris 7 /usr/bin/printf. as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo # Prefer a ksh shell builtin over an external printf program on Solaris, # but without wasting forks for bash or zsh. if test -z "$BASH_VERSION$ZSH_VERSION" \ && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then as_echo='print -r --' as_echo_n='print -rn --' elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then as_echo='printf %s\n' as_echo_n='printf %s' else if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"' as_echo_n='/usr/ucb/echo -n' else as_echo_body='eval expr "X$1" : "X\\(.*\\)"' as_echo_n_body='eval arg=$1; case $arg in #( *"$as_nl"*) expr "X$arg" : "X\\(.*\\)$as_nl"; arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;; esac; expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl" ' export as_echo_n_body as_echo_n='sh -c $as_echo_n_body as_echo' fi export as_echo_body as_echo='sh -c $as_echo_body as_echo' fi # The user is always right. if test "${PATH_SEPARATOR+set}" != set; then PATH_SEPARATOR=: (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && { (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 || PATH_SEPARATOR=';' } fi # IFS # We need space, tab and new line, in precisely that order. Quoting is # there to prevent editors from complaining about space-tab. # (If _AS_PATH_WALK were called with IFS unset, it would disable word # splitting by setting IFS to empty value.) IFS=" "" $as_nl" # Find who we are. Look in the path if we contain no directory separator. as_myself= case $0 in #(( *[\\/]* ) as_myself=$0 ;; *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break done IFS=$as_save_IFS ;; esac # We did not find ourselves, most probably we were run as `sh COMMAND' # in which case we are not to be found in the path. if test "x$as_myself" = x; then as_myself=$0 fi if test ! -f "$as_myself"; then $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2 exit 1 fi # Unset variables that we do not need and which cause bugs (e.g. in # pre-3.0 UWIN ksh). But do not cause bugs in bash 2.01; the "|| exit 1" # suppresses any "Segmentation fault" message there. '((' could # trigger a bug in pdksh 5.2.14. for as_var in BASH_ENV ENV MAIL MAILPATH do eval test x\${$as_var+set} = xset \ && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || : done PS1='$ ' PS2='> ' PS4='+ ' # NLS nuisances. LC_ALL=C export LC_ALL LANGUAGE=C export LANGUAGE # CDPATH. (unset CDPATH) >/dev/null 2>&1 && unset CDPATH if test "x$CONFIG_SHELL" = x; then as_bourne_compatible="if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then : emulate sh NULLCMD=: # Pre-4.2 versions of Zsh do word splitting on \${1+\"\$@\"}, which # is contrary to our usage. Disable this feature. alias -g '\${1+\"\$@\"}'='\"\$@\"' setopt NO_GLOB_SUBST else case \`(set -o) 2>/dev/null\` in #( *posix*) : set -o posix ;; #( *) : ;; esac fi " as_required="as_fn_return () { (exit \$1); } as_fn_success () { as_fn_return 0; } as_fn_failure () { as_fn_return 1; } as_fn_ret_success () { return 0; } as_fn_ret_failure () { return 1; } exitcode=0 as_fn_success || { exitcode=1; echo as_fn_success failed.; } as_fn_failure && { exitcode=1; echo as_fn_failure succeeded.; } as_fn_ret_success || { exitcode=1; echo as_fn_ret_success failed.; } as_fn_ret_failure && { exitcode=1; echo as_fn_ret_failure succeeded.; } if ( set x; as_fn_ret_success y && test x = \"\$1\" ); then : else exitcode=1; echo positional parameters were not saved. fi test x\$exitcode = x0 || exit 1" as_suggested=" as_lineno_1=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_1a=\$LINENO as_lineno_2=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_2a=\$LINENO eval 'test \"x\$as_lineno_1'\$as_run'\" != \"x\$as_lineno_2'\$as_run'\" && test \"x\`expr \$as_lineno_1'\$as_run' + 1\`\" = \"x\$as_lineno_2'\$as_run'\"' || exit 1 test \$(( 1 + 1 )) = 2 || exit 1" if (eval "$as_required") 2>/dev/null; then : as_have_required=yes else as_have_required=no fi if test x$as_have_required = xyes && (eval "$as_suggested") 2>/dev/null; then : else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR as_found=false for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. as_found=: case $as_dir in #( /*) for as_base in sh bash ksh sh5; do # Try only shells that exist, to save several forks. as_shell=$as_dir/$as_base if { test -f "$as_shell" || test -f "$as_shell.exe"; } && { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$as_shell"; } 2>/dev/null; then : CONFIG_SHELL=$as_shell as_have_required=yes if { $as_echo "$as_bourne_compatible""$as_suggested" | as_run=a "$as_shell"; } 2>/dev/null; then : break 2 fi fi done;; esac as_found=false done $as_found || { if { test -f "$SHELL" || test -f "$SHELL.exe"; } && { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$SHELL"; } 2>/dev/null; then : CONFIG_SHELL=$SHELL as_have_required=yes fi; } IFS=$as_save_IFS if test "x$CONFIG_SHELL" != x; then : # We cannot yet assume a decent shell, so we have to provide a # neutralization value for shells without unset; and this also # works around shells that cannot unset nonexistent variables. # Preserve -v and -x to the replacement shell. BASH_ENV=/dev/null ENV=/dev/null (unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV export CONFIG_SHELL case $- in # (((( *v*x* | *x*v* ) as_opts=-vx ;; *v* ) as_opts=-v ;; *x* ) as_opts=-x ;; * ) as_opts= ;; esac exec "$CONFIG_SHELL" $as_opts "$as_myself" ${1+"$@"} fi if test x$as_have_required = xno; then : $as_echo "$0: This script requires a shell more modern than all" $as_echo "$0: the shells that I found on your system." if test x${ZSH_VERSION+set} = xset ; then $as_echo "$0: In particular, zsh $ZSH_VERSION has bugs and should" $as_echo "$0: be upgraded to zsh 4.3.4 or later." else $as_echo "$0: Please tell bug-autoconf@gnu.org and $0: libdns@nlnetlabs.nl about your system, including any $0: error possibly output before this message. Then install $0: a modern shell, or manually run the script under such a $0: shell if you do have one." fi exit 1 fi fi fi SHELL=${CONFIG_SHELL-/bin/sh} export SHELL # Unset more variables known to interfere with behavior of common tools. CLICOLOR_FORCE= GREP_OPTIONS= unset CLICOLOR_FORCE GREP_OPTIONS ## --------------------- ## ## M4sh Shell Functions. ## ## --------------------- ## # as_fn_unset VAR # --------------- # Portably unset VAR. as_fn_unset () { { eval $1=; unset $1;} } as_unset=as_fn_unset # as_fn_set_status STATUS # ----------------------- # Set $? to STATUS, without forking. as_fn_set_status () { return $1 } # as_fn_set_status # as_fn_exit STATUS # ----------------- # Exit the shell with STATUS, even in a "trap 0" or "set -e" context. as_fn_exit () { set +e as_fn_set_status $1 exit $1 } # as_fn_exit # as_fn_mkdir_p # ------------- # Create "$as_dir" as a directory, including parents if necessary. as_fn_mkdir_p () { case $as_dir in #( -*) as_dir=./$as_dir;; esac test -d "$as_dir" || eval $as_mkdir_p || { as_dirs= while :; do case $as_dir in #( *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'( *) as_qdir=$as_dir;; esac as_dirs="'$as_qdir' $as_dirs" as_dir=`$as_dirname -- "$as_dir" || $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$as_dir" : 'X\(//\)[^/]' \| \ X"$as_dir" : 'X\(//\)$' \| \ X"$as_dir" : 'X\(/\)' \| . 2>/dev/null || $as_echo X"$as_dir" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q } /^X\(\/\/\)[^/].*/{ s//\1/ q } /^X\(\/\/\)$/{ s//\1/ q } /^X\(\/\).*/{ s//\1/ q } s/.*/./; q'` test -d "$as_dir" && break done test -z "$as_dirs" || eval "mkdir $as_dirs" } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir" } # as_fn_mkdir_p # as_fn_append VAR VALUE # ---------------------- # Append the text in VALUE to the end of the definition contained in VAR. Take # advantage of any shell optimizations that allow amortized linear growth over # repeated appends, instead of the typical quadratic growth present in naive # implementations. if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then : eval 'as_fn_append () { eval $1+=\$2 }' else as_fn_append () { eval $1=\$$1\$2 } fi # as_fn_append # as_fn_arith ARG... # ------------------ # Perform arithmetic evaluation on the ARGs, and store the result in the # global $as_val. Take advantage of shells that can avoid forks. The arguments # must be portable across $(()) and expr. if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then : eval 'as_fn_arith () { as_val=$(( $* )) }' else as_fn_arith () { as_val=`expr "$@" || test $? -eq 1` } fi # as_fn_arith # as_fn_error STATUS ERROR [LINENO LOG_FD] # ---------------------------------------- # Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are # provided, also output the error to LOG_FD, referencing LINENO. Then exit the # script with STATUS, using 1 if that was 0. as_fn_error () { as_status=$1; test $as_status -eq 0 && as_status=1 if test "$4"; then as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4 fi $as_echo "$as_me: error: $2" >&2 as_fn_exit $as_status } # as_fn_error if expr a : '\(a\)' >/dev/null 2>&1 && test "X`expr 00001 : '.*\(...\)'`" = X001; then as_expr=expr else as_expr=false fi if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then as_basename=basename else as_basename=false fi if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then as_dirname=dirname else as_dirname=false fi as_me=`$as_basename -- "$0" || $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \ X"$0" : 'X\(//\)$' \| \ X"$0" : 'X\(/\)' \| . 2>/dev/null || $as_echo X/"$0" | sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/ q } /^X\/\(\/\/\)$/{ s//\1/ q } /^X\/\(\/\).*/{ s//\1/ q } s/.*/./; q'` # Avoid depending upon Character Ranges. as_cr_letters='abcdefghijklmnopqrstuvwxyz' as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ' as_cr_Letters=$as_cr_letters$as_cr_LETTERS as_cr_digits='0123456789' as_cr_alnum=$as_cr_Letters$as_cr_digits as_lineno_1=$LINENO as_lineno_1a=$LINENO as_lineno_2=$LINENO as_lineno_2a=$LINENO eval 'test "x$as_lineno_1'$as_run'" != "x$as_lineno_2'$as_run'" && test "x`expr $as_lineno_1'$as_run' + 1`" = "x$as_lineno_2'$as_run'"' || { # Blame Lee E. McMahon (1931-1989) for sed's syntax. :-) sed -n ' p /[$]LINENO/= ' <$as_myself | sed ' s/[$]LINENO.*/&-/ t lineno b :lineno N :loop s/[$]LINENO\([^'$as_cr_alnum'_].*\n\)\(.*\)/\2\1\2/ t loop s/-\n.*// ' >$as_me.lineno && chmod +x "$as_me.lineno" || { $as_echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2; as_fn_exit 1; } # Don't try to exec as it changes $[0], causing all sort of problems # (the dirname of $[0] is not the place where we might find the # original and so on. Autoconf is especially sensitive to this). . "./$as_me.lineno" # Exit status is that of the last command. exit } ECHO_C= ECHO_N= ECHO_T= case `echo -n x` in #((((( -n*) case `echo 'xy\c'` in *c*) ECHO_T=' ';; # ECHO_T is single tab character. xy) ECHO_C='\c';; *) echo `echo ksh88 bug on AIX 6.1` > /dev/null ECHO_T=' ';; esac;; *) ECHO_N='-n';; esac rm -f conf$$ conf$$.exe conf$$.file if test -d conf$$.dir; then rm -f conf$$.dir/conf$$.file else rm -f conf$$.dir mkdir conf$$.dir 2>/dev/null fi if (echo >conf$$.file) 2>/dev/null; then if ln -s conf$$.file conf$$ 2>/dev/null; then as_ln_s='ln -s' # ... but there are two gotchas: # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail. # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable. # In both cases, we have to default to `cp -p'. ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe || as_ln_s='cp -p' elif ln conf$$.file conf$$ 2>/dev/null; then as_ln_s=ln else as_ln_s='cp -p' fi else as_ln_s='cp -p' fi rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file rmdir conf$$.dir 2>/dev/null if mkdir -p . 2>/dev/null; then as_mkdir_p='mkdir -p "$as_dir"' else test -d ./-p && rmdir ./-p as_mkdir_p=false fi if test -x / >/dev/null 2>&1; then as_test_x='test -x' else if ls -dL / >/dev/null 2>&1; then as_ls_L_option=L else as_ls_L_option= fi as_test_x=' eval sh -c '\'' if test -d "$1"; then test -d "$1/."; else case $1 in #( -*)set "./$1";; esac; case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in #(( ???[sx]*):;;*)false;;esac;fi '\'' sh ' fi as_executable_p=$as_test_x # Sed expression to map a string onto a valid CPP name. as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'" # Sed expression to map a string onto a valid variable name. as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'" test -n "$DJDIR" || exec 7<&0 &1 # Name of the host. # hostname on some systems (SVR3.2, old GNU/Linux) returns a bogus exit status, # so uname gets run too. ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q` # # Initializations. # ac_default_prefix=/usr/local ac_clean_files= ac_config_libobj_dir=. LIBOBJS= cross_compiling=no subdirs= MFLAGS= MAKEFLAGS= # Identity of this package. PACKAGE_NAME='ldns' PACKAGE_TARNAME='libdns' PACKAGE_VERSION='1.6.17' PACKAGE_STRING='ldns 1.6.17' PACKAGE_BUGREPORT='libdns@nlnetlabs.nl' PACKAGE_URL='' ac_unique_file="drill.c" # Factoring default headers for most tests. ac_includes_default="\ #include #ifdef HAVE_SYS_TYPES_H # include #endif #ifdef HAVE_SYS_STAT_H # include #endif #ifdef STDC_HEADERS # include # include #else # ifdef HAVE_STDLIB_H # include # endif #endif #ifdef HAVE_STRING_H # if !defined STDC_HEADERS && defined HAVE_MEMORY_H # include # endif # include #endif #ifdef HAVE_STRINGS_H # include #endif #ifdef HAVE_INTTYPES_H # include #endif #ifdef HAVE_STDINT_H # include #endif #ifdef HAVE_UNISTD_H # include #endif" ac_subst_vars='LTLIBOBJS LIBOBJS LDNS_TRUST_ANCHOR_FILE LDNSDIR LIBS_STC RUNTIME_PATH HAVE_SSL libtool SET_MAKE EGREP GREP CPP OBJEXT EXEEXT ac_ct_CC CPPFLAGS LDFLAGS CFLAGS CC target_alias host_alias build_alias LIBS ECHO_T ECHO_N ECHO_C DEFS mandir localedir libdir psdir pdfdir dvidir htmldir infodir docdir oldincludedir includedir localstatedir sharedstatedir sysconfdir datadir datarootdir libexecdir sbindir bindir program_transform_name prefix exec_prefix PACKAGE_URL PACKAGE_BUGREPORT PACKAGE_STRING PACKAGE_VERSION PACKAGE_TARNAME PACKAGE_NAME PATH_SEPARATOR SHELL' ac_subst_files='' ac_user_opts=' enable_option_checking enable_rpath with_ssl with_ldns with_trust_anchor ' ac_precious_vars='build_alias host_alias target_alias CC CFLAGS LDFLAGS LIBS CPPFLAGS CPP' # Initialize some variables set by options. ac_init_help= ac_init_version=false ac_unrecognized_opts= ac_unrecognized_sep= # The variables have the same names as the options, with # dashes changed to underlines. cache_file=/dev/null exec_prefix=NONE no_create= no_recursion= prefix=NONE program_prefix=NONE program_suffix=NONE program_transform_name=s,x,x, silent= site= srcdir= verbose= x_includes=NONE x_libraries=NONE # Installation directory options. # These are left unexpanded so users can "make install exec_prefix=/foo" # and all the variables that are supposed to be based on exec_prefix # by default will actually change. # Use braces instead of parens because sh, perl, etc. also accept them. # (The list follows the same order as the GNU Coding Standards.) bindir='${exec_prefix}/bin' sbindir='${exec_prefix}/sbin' libexecdir='${exec_prefix}/libexec' datarootdir='${prefix}/share' datadir='${datarootdir}' sysconfdir='${prefix}/etc' sharedstatedir='${prefix}/com' localstatedir='${prefix}/var' includedir='${prefix}/include' oldincludedir='/usr/include' docdir='${datarootdir}/doc/${PACKAGE_TARNAME}' infodir='${datarootdir}/info' htmldir='${docdir}' dvidir='${docdir}' pdfdir='${docdir}' psdir='${docdir}' libdir='${exec_prefix}/lib' localedir='${datarootdir}/locale' mandir='${datarootdir}/man' ac_prev= ac_dashdash= for ac_option do # If the previous option needs an argument, assign it. if test -n "$ac_prev"; then eval $ac_prev=\$ac_option ac_prev= continue fi case $ac_option in *=?*) ac_optarg=`expr "X$ac_option" : '[^=]*=\(.*\)'` ;; *=) ac_optarg= ;; *) ac_optarg=yes ;; esac # Accept the important Cygnus configure options, so we can diagnose typos. case $ac_dashdash$ac_option in --) ac_dashdash=yes ;; -bindir | --bindir | --bindi | --bind | --bin | --bi) ac_prev=bindir ;; -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*) bindir=$ac_optarg ;; -build | --build | --buil | --bui | --bu) ac_prev=build_alias ;; -build=* | --build=* | --buil=* | --bui=* | --bu=*) build_alias=$ac_optarg ;; -cache-file | --cache-file | --cache-fil | --cache-fi \ | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c) ac_prev=cache_file ;; -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \ | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*) cache_file=$ac_optarg ;; --config-cache | -C) cache_file=config.cache ;; -datadir | --datadir | --datadi | --datad) ac_prev=datadir ;; -datadir=* | --datadir=* | --datadi=* | --datad=*) datadir=$ac_optarg ;; -datarootdir | --datarootdir | --datarootdi | --datarootd | --dataroot \ | --dataroo | --dataro | --datar) ac_prev=datarootdir ;; -datarootdir=* | --datarootdir=* | --datarootdi=* | --datarootd=* \ | --dataroot=* | --dataroo=* | --dataro=* | --datar=*) datarootdir=$ac_optarg ;; -disable-* | --disable-*) ac_useropt=`expr "x$ac_option" : 'x-*disable-\(.*\)'` # Reject names that are not valid shell variable names. expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && as_fn_error $? "invalid feature name: $ac_useropt" ac_useropt_orig=$ac_useropt ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'` case $ac_user_opts in *" "enable_$ac_useropt" "*) ;; *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--disable-$ac_useropt_orig" ac_unrecognized_sep=', ';; esac eval enable_$ac_useropt=no ;; -docdir | --docdir | --docdi | --doc | --do) ac_prev=docdir ;; -docdir=* | --docdir=* | --docdi=* | --doc=* | --do=*) docdir=$ac_optarg ;; -dvidir | --dvidir | --dvidi | --dvid | --dvi | --dv) ac_prev=dvidir ;; -dvidir=* | --dvidir=* | --dvidi=* | --dvid=* | --dvi=* | --dv=*) dvidir=$ac_optarg ;; -enable-* | --enable-*) ac_useropt=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'` # Reject names that are not valid shell variable names. expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && as_fn_error $? "invalid feature name: $ac_useropt" ac_useropt_orig=$ac_useropt ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'` case $ac_user_opts in *" "enable_$ac_useropt" "*) ;; *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--enable-$ac_useropt_orig" ac_unrecognized_sep=', ';; esac eval enable_$ac_useropt=\$ac_optarg ;; -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \ | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \ | --exec | --exe | --ex) ac_prev=exec_prefix ;; -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \ | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \ | --exec=* | --exe=* | --ex=*) exec_prefix=$ac_optarg ;; -gas | --gas | --ga | --g) # Obsolete; use --with-gas. with_gas=yes ;; -help | --help | --hel | --he | -h) ac_init_help=long ;; -help=r* | --help=r* | --hel=r* | --he=r* | -hr*) ac_init_help=recursive ;; -help=s* | --help=s* | --hel=s* | --he=s* | -hs*) ac_init_help=short ;; -host | --host | --hos | --ho) ac_prev=host_alias ;; -host=* | --host=* | --hos=* | --ho=*) host_alias=$ac_optarg ;; -htmldir | --htmldir | --htmldi | --htmld | --html | --htm | --ht) ac_prev=htmldir ;; -htmldir=* | --htmldir=* | --htmldi=* | --htmld=* | --html=* | --htm=* \ | --ht=*) htmldir=$ac_optarg ;; -includedir | --includedir | --includedi | --included | --include \ | --includ | --inclu | --incl | --inc) ac_prev=includedir ;; -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \ | --includ=* | --inclu=* | --incl=* | --inc=*) includedir=$ac_optarg ;; -infodir | --infodir | --infodi | --infod | --info | --inf) ac_prev=infodir ;; -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*) infodir=$ac_optarg ;; -libdir | --libdir | --libdi | --libd) ac_prev=libdir ;; -libdir=* | --libdir=* | --libdi=* | --libd=*) libdir=$ac_optarg ;; -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \ | --libexe | --libex | --libe) ac_prev=libexecdir ;; -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \ | --libexe=* | --libex=* | --libe=*) libexecdir=$ac_optarg ;; -localedir | --localedir | --localedi | --localed | --locale) ac_prev=localedir ;; -localedir=* | --localedir=* | --localedi=* | --localed=* | --locale=*) localedir=$ac_optarg ;; -localstatedir | --localstatedir | --localstatedi | --localstated \ | --localstate | --localstat | --localsta | --localst | --locals) ac_prev=localstatedir ;; -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \ | --localstate=* | --localstat=* | --localsta=* | --localst=* | --locals=*) localstatedir=$ac_optarg ;; -mandir | --mandir | --mandi | --mand | --man | --ma | --m) ac_prev=mandir ;; -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*) mandir=$ac_optarg ;; -nfp | --nfp | --nf) # Obsolete; use --without-fp. with_fp=no ;; -no-create | --no-create | --no-creat | --no-crea | --no-cre \ | --no-cr | --no-c | -n) no_create=yes ;; -no-recursion | --no-recursion | --no-recursio | --no-recursi \ | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r) no_recursion=yes ;; -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \ | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \ | --oldin | --oldi | --old | --ol | --o) ac_prev=oldincludedir ;; -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \ | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \ | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*) oldincludedir=$ac_optarg ;; -prefix | --prefix | --prefi | --pref | --pre | --pr | --p) ac_prev=prefix ;; -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*) prefix=$ac_optarg ;; -program-prefix | --program-prefix | --program-prefi | --program-pref \ | --program-pre | --program-pr | --program-p) ac_prev=program_prefix ;; -program-prefix=* | --program-prefix=* | --program-prefi=* \ | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*) program_prefix=$ac_optarg ;; -program-suffix | --program-suffix | --program-suffi | --program-suff \ | --program-suf | --program-su | --program-s) ac_prev=program_suffix ;; -program-suffix=* | --program-suffix=* | --program-suffi=* \ | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*) program_suffix=$ac_optarg ;; -program-transform-name | --program-transform-name \ | --program-transform-nam | --program-transform-na \ | --program-transform-n | --program-transform- \ | --program-transform | --program-transfor \ | --program-transfo | --program-transf \ | --program-trans | --program-tran \ | --progr-tra | --program-tr | --program-t) ac_prev=program_transform_name ;; -program-transform-name=* | --program-transform-name=* \ | --program-transform-nam=* | --program-transform-na=* \ | --program-transform-n=* | --program-transform-=* \ | --program-transform=* | --program-transfor=* \ | --program-transfo=* | --program-transf=* \ | --program-trans=* | --program-tran=* \ | --progr-tra=* | --program-tr=* | --program-t=*) program_transform_name=$ac_optarg ;; -pdfdir | --pdfdir | --pdfdi | --pdfd | --pdf | --pd) ac_prev=pdfdir ;; -pdfdir=* | --pdfdir=* | --pdfdi=* | --pdfd=* | --pdf=* | --pd=*) pdfdir=$ac_optarg ;; -psdir | --psdir | --psdi | --psd | --ps) ac_prev=psdir ;; -psdir=* | --psdir=* | --psdi=* | --psd=* | --ps=*) psdir=$ac_optarg ;; -q | -quiet | --quiet | --quie | --qui | --qu | --q \ | -silent | --silent | --silen | --sile | --sil) silent=yes ;; -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb) ac_prev=sbindir ;; -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \ | --sbi=* | --sb=*) sbindir=$ac_optarg ;; -sharedstatedir | --sharedstatedir | --sharedstatedi \ | --sharedstated | --sharedstate | --sharedstat | --sharedsta \ | --sharedst | --shareds | --shared | --share | --shar \ | --sha | --sh) ac_prev=sharedstatedir ;; -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \ | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \ | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \ | --sha=* | --sh=*) sharedstatedir=$ac_optarg ;; -site | --site | --sit) ac_prev=site ;; -site=* | --site=* | --sit=*) site=$ac_optarg ;; -srcdir | --srcdir | --srcdi | --srcd | --src | --sr) ac_prev=srcdir ;; -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*) srcdir=$ac_optarg ;; -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \ | --syscon | --sysco | --sysc | --sys | --sy) ac_prev=sysconfdir ;; -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \ | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*) sysconfdir=$ac_optarg ;; -target | --target | --targe | --targ | --tar | --ta | --t) ac_prev=target_alias ;; -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*) target_alias=$ac_optarg ;; -v | -verbose | --verbose | --verbos | --verbo | --verb) verbose=yes ;; -version | --version | --versio | --versi | --vers | -V) ac_init_version=: ;; -with-* | --with-*) ac_useropt=`expr "x$ac_option" : 'x-*with-\([^=]*\)'` # Reject names that are not valid shell variable names. expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && as_fn_error $? "invalid package name: $ac_useropt" ac_useropt_orig=$ac_useropt ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'` case $ac_user_opts in *" "with_$ac_useropt" "*) ;; *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--with-$ac_useropt_orig" ac_unrecognized_sep=', ';; esac eval with_$ac_useropt=\$ac_optarg ;; -without-* | --without-*) ac_useropt=`expr "x$ac_option" : 'x-*without-\(.*\)'` # Reject names that are not valid shell variable names. expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && as_fn_error $? "invalid package name: $ac_useropt" ac_useropt_orig=$ac_useropt ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'` case $ac_user_opts in *" "with_$ac_useropt" "*) ;; *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--without-$ac_useropt_orig" ac_unrecognized_sep=', ';; esac eval with_$ac_useropt=no ;; --x) # Obsolete; use --with-x. with_x=yes ;; -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \ | --x-incl | --x-inc | --x-in | --x-i) ac_prev=x_includes ;; -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \ | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*) x_includes=$ac_optarg ;; -x-libraries | --x-libraries | --x-librarie | --x-librari \ | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l) ac_prev=x_libraries ;; -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \ | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*) x_libraries=$ac_optarg ;; -*) as_fn_error $? "unrecognized option: \`$ac_option' Try \`$0 --help' for more information" ;; *=*) ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='` # Reject names that are not valid shell variable names. case $ac_envvar in #( '' | [0-9]* | *[!_$as_cr_alnum]* ) as_fn_error $? "invalid variable name: \`$ac_envvar'" ;; esac eval $ac_envvar=\$ac_optarg export $ac_envvar ;; *) # FIXME: should be removed in autoconf 3.0. $as_echo "$as_me: WARNING: you should use --build, --host, --target" >&2 expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null && $as_echo "$as_me: WARNING: invalid host type: $ac_option" >&2 : "${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}" ;; esac done if test -n "$ac_prev"; then ac_option=--`echo $ac_prev | sed 's/_/-/g'` as_fn_error $? "missing argument to $ac_option" fi if test -n "$ac_unrecognized_opts"; then case $enable_option_checking in no) ;; fatal) as_fn_error $? "unrecognized options: $ac_unrecognized_opts" ;; *) $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2 ;; esac fi # Check all directory arguments for consistency. for ac_var in exec_prefix prefix bindir sbindir libexecdir datarootdir \ datadir sysconfdir sharedstatedir localstatedir includedir \ oldincludedir docdir infodir htmldir dvidir pdfdir psdir \ libdir localedir mandir do eval ac_val=\$$ac_var # Remove trailing slashes. case $ac_val in */ ) ac_val=`expr "X$ac_val" : 'X\(.*[^/]\)' \| "X$ac_val" : 'X\(.*\)'` eval $ac_var=\$ac_val;; esac # Be sure to have absolute directory names. case $ac_val in [\\/$]* | ?:[\\/]* ) continue;; NONE | '' ) case $ac_var in *prefix ) continue;; esac;; esac as_fn_error $? "expected an absolute directory name for --$ac_var: $ac_val" done # There might be people who depend on the old broken behavior: `$host' # used to hold the argument of --host etc. # FIXME: To remove some day. build=$build_alias host=$host_alias target=$target_alias # FIXME: To remove some day. if test "x$host_alias" != x; then if test "x$build_alias" = x; then cross_compiling=maybe $as_echo "$as_me: WARNING: if you wanted to set the --build type, don't use --host. If a cross compiler is detected then cross compile mode will be used" >&2 elif test "x$build_alias" != "x$host_alias"; then cross_compiling=yes fi fi ac_tool_prefix= test -n "$host_alias" && ac_tool_prefix=$host_alias- test "$silent" = yes && exec 6>/dev/null ac_pwd=`pwd` && test -n "$ac_pwd" && ac_ls_di=`ls -di .` && ac_pwd_ls_di=`cd "$ac_pwd" && ls -di .` || as_fn_error $? "working directory cannot be determined" test "X$ac_ls_di" = "X$ac_pwd_ls_di" || as_fn_error $? "pwd does not report name of working directory" # Find the source files, if location was not specified. if test -z "$srcdir"; then ac_srcdir_defaulted=yes # Try the directory containing this script, then the parent directory. ac_confdir=`$as_dirname -- "$as_myself" || $as_expr X"$as_myself" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$as_myself" : 'X\(//\)[^/]' \| \ X"$as_myself" : 'X\(//\)$' \| \ X"$as_myself" : 'X\(/\)' \| . 2>/dev/null || $as_echo X"$as_myself" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q } /^X\(\/\/\)[^/].*/{ s//\1/ q } /^X\(\/\/\)$/{ s//\1/ q } /^X\(\/\).*/{ s//\1/ q } s/.*/./; q'` srcdir=$ac_confdir if test ! -r "$srcdir/$ac_unique_file"; then srcdir=.. fi else ac_srcdir_defaulted=no fi if test ! -r "$srcdir/$ac_unique_file"; then test "$ac_srcdir_defaulted" = yes && srcdir="$ac_confdir or .." as_fn_error $? "cannot find sources ($ac_unique_file) in $srcdir" fi ac_msg="sources are in $srcdir, but \`cd $srcdir' does not work" ac_abs_confdir=`( cd "$srcdir" && test -r "./$ac_unique_file" || as_fn_error $? "$ac_msg" pwd)` # When building in place, set srcdir=. if test "$ac_abs_confdir" = "$ac_pwd"; then srcdir=. fi # Remove unnecessary trailing slashes from srcdir. # Double slashes in file names in object file debugging info # mess up M-x gdb in Emacs. case $srcdir in */) srcdir=`expr "X$srcdir" : 'X\(.*[^/]\)' \| "X$srcdir" : 'X\(.*\)'`;; esac for ac_var in $ac_precious_vars; do eval ac_env_${ac_var}_set=\${${ac_var}+set} eval ac_env_${ac_var}_value=\$${ac_var} eval ac_cv_env_${ac_var}_set=\${${ac_var}+set} eval ac_cv_env_${ac_var}_value=\$${ac_var} done # # Report the --help message. # if test "$ac_init_help" = "long"; then # Omit some internal or obsolete options to make the list less imposing. # This message is too long to be a string in the A/UX 3.1 sh. cat <<_ACEOF \`configure' configures ldns 1.6.17 to adapt to many kinds of systems. Usage: $0 [OPTION]... [VAR=VALUE]... To assign environment variables (e.g., CC, CFLAGS...), specify them as VAR=VALUE. See below for descriptions of some of the useful variables. Defaults for the options are specified in brackets. Configuration: -h, --help display this help and exit --help=short display options specific to this package --help=recursive display the short help of all the included packages -V, --version display version information and exit -q, --quiet, --silent do not print \`checking ...' messages --cache-file=FILE cache test results in FILE [disabled] -C, --config-cache alias for \`--cache-file=config.cache' -n, --no-create do not create output files --srcdir=DIR find the sources in DIR [configure dir or \`..'] Installation directories: --prefix=PREFIX install architecture-independent files in PREFIX [$ac_default_prefix] --exec-prefix=EPREFIX install architecture-dependent files in EPREFIX [PREFIX] By default, \`make install' will install all the files in \`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc. You can specify an installation prefix other than \`$ac_default_prefix' using \`--prefix', for instance \`--prefix=\$HOME'. For better control, use the options below. Fine tuning of the installation directories: --bindir=DIR user executables [EPREFIX/bin] --sbindir=DIR system admin executables [EPREFIX/sbin] --libexecdir=DIR program executables [EPREFIX/libexec] --sysconfdir=DIR read-only single-machine data [PREFIX/etc] --sharedstatedir=DIR modifiable architecture-independent data [PREFIX/com] --localstatedir=DIR modifiable single-machine data [PREFIX/var] --libdir=DIR object code libraries [EPREFIX/lib] --includedir=DIR C header files [PREFIX/include] --oldincludedir=DIR C header files for non-gcc [/usr/include] --datarootdir=DIR read-only arch.-independent data root [PREFIX/share] --datadir=DIR read-only architecture-independent data [DATAROOTDIR] --infodir=DIR info documentation [DATAROOTDIR/info] --localedir=DIR locale-dependent data [DATAROOTDIR/locale] --mandir=DIR man documentation [DATAROOTDIR/man] --docdir=DIR documentation root [DATAROOTDIR/doc/libdns] --htmldir=DIR html documentation [DOCDIR] --dvidir=DIR dvi documentation [DOCDIR] --pdfdir=DIR pdf documentation [DOCDIR] --psdir=DIR ps documentation [DOCDIR] _ACEOF cat <<\_ACEOF _ACEOF fi if test -n "$ac_init_help"; then case $ac_init_help in short | recursive ) echo "Configuration of ldns 1.6.17:";; esac cat <<\_ACEOF Optional Features: --disable-option-checking ignore unrecognized --enable/--with options --disable-FEATURE do not include FEATURE (same as --enable-FEATURE=no) --enable-FEATURE[=ARG] include FEATURE [ARG=yes] --disable-rpath disable hardcoded rpath (default=enabled) Optional Packages: --with-PACKAGE[=ARG] use PACKAGE [ARG=yes] --without-PACKAGE do not use PACKAGE (same as --with-PACKAGE=no) --with-ssl=pathname enable SSL (will check /usr/local/ssl /usr/lib/ssl /usr/ssl /usr/pkg /usr/local /opt/local /usr/sfw /usr) --with-ldns=PATH specify prefix of path of ldns library to use --with-trust-anchor=KEYFILE Default location of the trust anchor file. [default=SYSCONFDIR/unbound/root.key] Some influential environment variables: CC C compiler command CFLAGS C compiler flags LDFLAGS linker flags, e.g. -L if you have libraries in a nonstandard directory LIBS libraries to pass to the linker, e.g. -l CPPFLAGS (Objective) C/C++ preprocessor flags, e.g. -I if you have headers in a nonstandard directory CPP C preprocessor Use these variables to override the choices made by `configure' or to help it to find libraries and programs with nonstandard names/locations. Report bugs to . _ACEOF ac_status=$? fi if test "$ac_init_help" = "recursive"; then # If there are subdirs, report their specific --help. for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue test -d "$ac_dir" || { cd "$srcdir" && ac_pwd=`pwd` && srcdir=. && test -d "$ac_dir"; } || continue ac_builddir=. case "$ac_dir" in .) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;; *) ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'` # A ".." for each directory in $ac_dir_suffix. ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'` case $ac_top_builddir_sub in "") ac_top_builddir_sub=. ac_top_build_prefix= ;; *) ac_top_build_prefix=$ac_top_builddir_sub/ ;; esac ;; esac ac_abs_top_builddir=$ac_pwd ac_abs_builddir=$ac_pwd$ac_dir_suffix # for backward compatibility: ac_top_builddir=$ac_top_build_prefix case $srcdir in .) # We are building in place. ac_srcdir=. ac_top_srcdir=$ac_top_builddir_sub ac_abs_top_srcdir=$ac_pwd ;; [\\/]* | ?:[\\/]* ) # Absolute name. ac_srcdir=$srcdir$ac_dir_suffix; ac_top_srcdir=$srcdir ac_abs_top_srcdir=$srcdir ;; *) # Relative name. ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix ac_top_srcdir=$ac_top_build_prefix$srcdir ac_abs_top_srcdir=$ac_pwd/$srcdir ;; esac ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix cd "$ac_dir" || { ac_status=$?; continue; } # Check for guested configure. if test -f "$ac_srcdir/configure.gnu"; then echo && $SHELL "$ac_srcdir/configure.gnu" --help=recursive elif test -f "$ac_srcdir/configure"; then echo && $SHELL "$ac_srcdir/configure" --help=recursive else $as_echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2 fi || ac_status=$? cd "$ac_pwd" || { ac_status=$?; break; } done fi test -n "$ac_init_help" && exit $ac_status if $ac_init_version; then cat <<\_ACEOF ldns configure 1.6.17 generated by GNU Autoconf 2.68 Copyright (C) 2010 Free Software Foundation, Inc. This configure script is free software; the Free Software Foundation gives unlimited permission to copy, distribute and modify it. _ACEOF exit fi ## ------------------------ ## ## Autoconf initialization. ## ## ------------------------ ## # ac_fn_c_try_compile LINENO # -------------------------- # Try to compile conftest.$ac_ext, and return whether this succeeded. ac_fn_c_try_compile () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack rm -f conftest.$ac_objext if { { ac_try="$ac_compile" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_compile") 2>conftest.err ac_status=$? if test -s conftest.err; then grep -v '^ *+' conftest.err >conftest.er1 cat conftest.er1 >&5 mv -f conftest.er1 conftest.err fi $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } && { test -z "$ac_c_werror_flag" || test ! -s conftest.err } && test -s conftest.$ac_objext; then : ac_retval=0 else $as_echo "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 ac_retval=1 fi eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno as_fn_set_status $ac_retval } # ac_fn_c_try_compile # ac_fn_c_try_cpp LINENO # ---------------------- # Try to preprocess conftest.$ac_ext, and return whether this succeeded. ac_fn_c_try_cpp () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack if { { ac_try="$ac_cpp conftest.$ac_ext" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err ac_status=$? if test -s conftest.err; then grep -v '^ *+' conftest.err >conftest.er1 cat conftest.er1 >&5 mv -f conftest.er1 conftest.err fi $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } > conftest.i && { test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" || test ! -s conftest.err }; then : ac_retval=0 else $as_echo "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 ac_retval=1 fi eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno as_fn_set_status $ac_retval } # ac_fn_c_try_cpp # ac_fn_c_check_header_mongrel LINENO HEADER VAR INCLUDES # ------------------------------------------------------- # Tests whether HEADER exists, giving a warning if it cannot be compiled using # the include files in INCLUDES and setting the cache variable VAR # accordingly. ac_fn_c_check_header_mongrel () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack if eval \${$3+:} false; then : { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 $as_echo_n "checking for $2... " >&6; } if eval \${$3+:} false; then : $as_echo_n "(cached) " >&6 fi eval ac_res=\$$3 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 $as_echo "$ac_res" >&6; } else # Is the header compilable? { $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 usability" >&5 $as_echo_n "checking $2 usability... " >&6; } cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $4 #include <$2> _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ac_header_compiler=yes else ac_header_compiler=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_compiler" >&5 $as_echo "$ac_header_compiler" >&6; } # Is the header present? { $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 presence" >&5 $as_echo_n "checking $2 presence... " >&6; } cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include <$2> _ACEOF if ac_fn_c_try_cpp "$LINENO"; then : ac_header_preproc=yes else ac_header_preproc=no fi rm -f conftest.err conftest.i conftest.$ac_ext { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_preproc" >&5 $as_echo "$ac_header_preproc" >&6; } # So? What about this header? case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in #(( yes:no: ) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&5 $as_echo "$as_me: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&2;} { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5 $as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;} ;; no:yes:* ) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: present but cannot be compiled" >&5 $as_echo "$as_me: WARNING: $2: present but cannot be compiled" >&2;} { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: check for missing prerequisite headers?" >&5 $as_echo "$as_me: WARNING: $2: check for missing prerequisite headers?" >&2;} { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: see the Autoconf documentation" >&5 $as_echo "$as_me: WARNING: $2: see the Autoconf documentation" >&2;} { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: section \"Present But Cannot Be Compiled\"" >&5 $as_echo "$as_me: WARNING: $2: section \"Present But Cannot Be Compiled\"" >&2;} { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5 $as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;} ( $as_echo "## ---------------------------------- ## ## Report this to libdns@nlnetlabs.nl ## ## ---------------------------------- ##" ) | sed "s/^/$as_me: WARNING: /" >&2 ;; esac { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 $as_echo_n "checking for $2... " >&6; } if eval \${$3+:} false; then : $as_echo_n "(cached) " >&6 else eval "$3=\$ac_header_compiler" fi eval ac_res=\$$3 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 $as_echo "$ac_res" >&6; } fi eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno } # ac_fn_c_check_header_mongrel # ac_fn_c_try_run LINENO # ---------------------- # Try to link conftest.$ac_ext, and return whether this succeeded. Assumes # that executables *can* be run. ac_fn_c_try_run () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack if { { ac_try="$ac_link" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_link") 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } && { ac_try='./conftest$ac_exeext' { { case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_try") 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; }; then : ac_retval=0 else $as_echo "$as_me: program exited with status $ac_status" >&5 $as_echo "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 ac_retval=$ac_status fi rm -rf conftest.dSYM conftest_ipa8_conftest.oo eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno as_fn_set_status $ac_retval } # ac_fn_c_try_run # ac_fn_c_check_header_compile LINENO HEADER VAR INCLUDES # ------------------------------------------------------- # Tests whether HEADER exists and can be compiled using the include files in # INCLUDES, setting the cache variable VAR accordingly. ac_fn_c_check_header_compile () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 $as_echo_n "checking for $2... " >&6; } if eval \${$3+:} false; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $4 #include <$2> _ACEOF if ac_fn_c_try_compile "$LINENO"; then : eval "$3=yes" else eval "$3=no" fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi eval ac_res=\$$3 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 $as_echo "$ac_res" >&6; } eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno } # ac_fn_c_check_header_compile # ac_fn_c_check_type LINENO TYPE VAR INCLUDES # ------------------------------------------- # Tests whether TYPE exists after having included INCLUDES, setting cache # variable VAR accordingly. ac_fn_c_check_type () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 $as_echo_n "checking for $2... " >&6; } if eval \${$3+:} false; then : $as_echo_n "(cached) " >&6 else eval "$3=no" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $4 int main () { if (sizeof ($2)) return 0; ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $4 int main () { if (sizeof (($2))) return 0; ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : else eval "$3=yes" fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi eval ac_res=\$$3 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 $as_echo "$ac_res" >&6; } eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno } # ac_fn_c_check_type # ac_fn_c_try_link LINENO # ----------------------- # Try to link conftest.$ac_ext, and return whether this succeeded. ac_fn_c_try_link () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack rm -f conftest.$ac_objext conftest$ac_exeext if { { ac_try="$ac_link" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_link") 2>conftest.err ac_status=$? if test -s conftest.err; then grep -v '^ *+' conftest.err >conftest.er1 cat conftest.er1 >&5 mv -f conftest.er1 conftest.err fi $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } && { test -z "$ac_c_werror_flag" || test ! -s conftest.err } && test -s conftest$ac_exeext && { test "$cross_compiling" = yes || $as_test_x conftest$ac_exeext }; then : ac_retval=0 else $as_echo "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 ac_retval=1 fi # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would # interfere with the next link command; also delete a directory that is # left behind by Apple's compiler. We do this before executing the actions. rm -rf conftest.dSYM conftest_ipa8_conftest.oo eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno as_fn_set_status $ac_retval } # ac_fn_c_try_link # ac_fn_c_check_func LINENO FUNC VAR # ---------------------------------- # Tests whether FUNC exists, setting the cache variable VAR accordingly ac_fn_c_check_func () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 $as_echo_n "checking for $2... " >&6; } if eval \${$3+:} false; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ /* Define $2 to an innocuous variant, in case declares $2. For example, HP-UX 11i declares gettimeofday. */ #define $2 innocuous_$2 /* System header to define __stub macros and hopefully few prototypes, which can conflict with char $2 (); below. Prefer to if __STDC__ is defined, since exists even on freestanding compilers. */ #ifdef __STDC__ # include #else # include #endif #undef $2 /* Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC builtin and then its argument prototype would still apply. */ #ifdef __cplusplus extern "C" #endif char $2 (); /* The GNU C library defines this for functions which it implements to always fail with ENOSYS. Some functions are actually named something starting with __ and the normal name is an alias. */ #if defined __stub_$2 || defined __stub___$2 choke me #endif int main () { return $2 (); ; return 0; } _ACEOF if ac_fn_c_try_link "$LINENO"; then : eval "$3=yes" else eval "$3=no" fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext conftest.$ac_ext fi eval ac_res=\$$3 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 $as_echo "$ac_res" >&6; } eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno } # ac_fn_c_check_func cat >config.log <<_ACEOF This file contains any messages produced by compilers while running configure, to aid debugging if configure makes a mistake. It was created by ldns $as_me 1.6.17, which was generated by GNU Autoconf 2.68. Invocation command line was $ $0 $@ _ACEOF exec 5>>config.log { cat <<_ASUNAME ## --------- ## ## Platform. ## ## --------- ## hostname = `(hostname || uname -n) 2>/dev/null | sed 1q` uname -m = `(uname -m) 2>/dev/null || echo unknown` uname -r = `(uname -r) 2>/dev/null || echo unknown` uname -s = `(uname -s) 2>/dev/null || echo unknown` uname -v = `(uname -v) 2>/dev/null || echo unknown` /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown` /bin/uname -X = `(/bin/uname -X) 2>/dev/null || echo unknown` /bin/arch = `(/bin/arch) 2>/dev/null || echo unknown` /usr/bin/arch -k = `(/usr/bin/arch -k) 2>/dev/null || echo unknown` /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown` /usr/bin/hostinfo = `(/usr/bin/hostinfo) 2>/dev/null || echo unknown` /bin/machine = `(/bin/machine) 2>/dev/null || echo unknown` /usr/bin/oslevel = `(/usr/bin/oslevel) 2>/dev/null || echo unknown` /bin/universe = `(/bin/universe) 2>/dev/null || echo unknown` _ASUNAME as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. $as_echo "PATH: $as_dir" done IFS=$as_save_IFS } >&5 cat >&5 <<_ACEOF ## ----------- ## ## Core tests. ## ## ----------- ## _ACEOF # Keep a trace of the command line. # Strip out --no-create and --no-recursion so they do not pile up. # Strip out --silent because we don't want to record it for future runs. # Also quote any args containing shell meta-characters. # Make two passes to allow for proper duplicate-argument suppression. ac_configure_args= ac_configure_args0= ac_configure_args1= ac_must_keep_next=false for ac_pass in 1 2 do for ac_arg do case $ac_arg in -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;; -q | -quiet | --quiet | --quie | --qui | --qu | --q \ | -silent | --silent | --silen | --sile | --sil) continue ;; *\'*) ac_arg=`$as_echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;; esac case $ac_pass in 1) as_fn_append ac_configure_args0 " '$ac_arg'" ;; 2) as_fn_append ac_configure_args1 " '$ac_arg'" if test $ac_must_keep_next = true; then ac_must_keep_next=false # Got value, back to normal. else case $ac_arg in *=* | --config-cache | -C | -disable-* | --disable-* \ | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \ | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \ | -with-* | --with-* | -without-* | --without-* | --x) case "$ac_configure_args0 " in "$ac_configure_args1"*" '$ac_arg' "* ) continue ;; esac ;; -* ) ac_must_keep_next=true ;; esac fi as_fn_append ac_configure_args " '$ac_arg'" ;; esac done done { ac_configure_args0=; unset ac_configure_args0;} { ac_configure_args1=; unset ac_configure_args1;} # When interrupted or exit'd, cleanup temporary files, and complete # config.log. We remove comments because anyway the quotes in there # would cause problems or look ugly. # WARNING: Use '\'' to represent an apostrophe within the trap. # WARNING: Do not start the trap code with a newline, due to a FreeBSD 4.0 bug. trap 'exit_status=$? # Save into config.log some information that might help in debugging. { echo $as_echo "## ---------------- ## ## Cache variables. ## ## ---------------- ##" echo # The following way of writing the cache mishandles newlines in values, ( for ac_var in `(set) 2>&1 | sed -n '\''s/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'\''`; do eval ac_val=\$$ac_var case $ac_val in #( *${as_nl}*) case $ac_var in #( *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5 $as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;; esac case $ac_var in #( _ | IFS | as_nl) ;; #( BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #( *) { eval $ac_var=; unset $ac_var;} ;; esac ;; esac done (set) 2>&1 | case $as_nl`(ac_space='\'' '\''; set) 2>&1` in #( *${as_nl}ac_space=\ *) sed -n \ "s/'\''/'\''\\\\'\'''\''/g; s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\''\\2'\''/p" ;; #( *) sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p" ;; esac | sort ) echo $as_echo "## ----------------- ## ## Output variables. ## ## ----------------- ##" echo for ac_var in $ac_subst_vars do eval ac_val=\$$ac_var case $ac_val in *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;; esac $as_echo "$ac_var='\''$ac_val'\''" done | sort echo if test -n "$ac_subst_files"; then $as_echo "## ------------------- ## ## File substitutions. ## ## ------------------- ##" echo for ac_var in $ac_subst_files do eval ac_val=\$$ac_var case $ac_val in *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;; esac $as_echo "$ac_var='\''$ac_val'\''" done | sort echo fi if test -s confdefs.h; then $as_echo "## ----------- ## ## confdefs.h. ## ## ----------- ##" echo cat confdefs.h echo fi test "$ac_signal" != 0 && $as_echo "$as_me: caught signal $ac_signal" $as_echo "$as_me: exit $exit_status" } >&5 rm -f core *.core core.conftest.* && rm -f -r conftest* confdefs* conf$$* $ac_clean_files && exit $exit_status ' 0 for ac_signal in 1 2 13 15; do trap 'ac_signal='$ac_signal'; as_fn_exit 1' $ac_signal done ac_signal=0 # confdefs.h avoids OS command line length limits that DEFS can exceed. rm -f -r conftest* confdefs.h $as_echo "/* confdefs.h */" > confdefs.h # Predefined preprocessor variables. cat >>confdefs.h <<_ACEOF #define PACKAGE_NAME "$PACKAGE_NAME" _ACEOF cat >>confdefs.h <<_ACEOF #define PACKAGE_TARNAME "$PACKAGE_TARNAME" _ACEOF cat >>confdefs.h <<_ACEOF #define PACKAGE_VERSION "$PACKAGE_VERSION" _ACEOF cat >>confdefs.h <<_ACEOF #define PACKAGE_STRING "$PACKAGE_STRING" _ACEOF cat >>confdefs.h <<_ACEOF #define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT" _ACEOF cat >>confdefs.h <<_ACEOF #define PACKAGE_URL "$PACKAGE_URL" _ACEOF # Let the site file select an alternate cache file if it wants to. # Prefer an explicitly selected file to automatically selected ones. ac_site_file1=NONE ac_site_file2=NONE if test -n "$CONFIG_SITE"; then # We do not want a PATH search for config.site. case $CONFIG_SITE in #(( -*) ac_site_file1=./$CONFIG_SITE;; */*) ac_site_file1=$CONFIG_SITE;; *) ac_site_file1=./$CONFIG_SITE;; esac elif test "x$prefix" != xNONE; then ac_site_file1=$prefix/share/config.site ac_site_file2=$prefix/etc/config.site else ac_site_file1=$ac_default_prefix/share/config.site ac_site_file2=$ac_default_prefix/etc/config.site fi for ac_site_file in "$ac_site_file1" "$ac_site_file2" do test "x$ac_site_file" = xNONE && continue if test /dev/null != "$ac_site_file" && test -r "$ac_site_file"; then { $as_echo "$as_me:${as_lineno-$LINENO}: loading site script $ac_site_file" >&5 $as_echo "$as_me: loading site script $ac_site_file" >&6;} sed 's/^/| /' "$ac_site_file" >&5 . "$ac_site_file" \ || { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error $? "failed to load site script $ac_site_file See \`config.log' for more details" "$LINENO" 5; } fi done if test -r "$cache_file"; then # Some versions of bash will fail to source /dev/null (special files # actually), so we avoid doing that. DJGPP emulates it as a regular file. if test /dev/null != "$cache_file" && test -f "$cache_file"; then { $as_echo "$as_me:${as_lineno-$LINENO}: loading cache $cache_file" >&5 $as_echo "$as_me: loading cache $cache_file" >&6;} case $cache_file in [\\/]* | ?:[\\/]* ) . "$cache_file";; *) . "./$cache_file";; esac fi else { $as_echo "$as_me:${as_lineno-$LINENO}: creating cache $cache_file" >&5 $as_echo "$as_me: creating cache $cache_file" >&6;} >$cache_file fi # Check that the precious variables saved in the cache have kept the same # value. ac_cache_corrupted=false for ac_var in $ac_precious_vars; do eval ac_old_set=\$ac_cv_env_${ac_var}_set eval ac_new_set=\$ac_env_${ac_var}_set eval ac_old_val=\$ac_cv_env_${ac_var}_value eval ac_new_val=\$ac_env_${ac_var}_value case $ac_old_set,$ac_new_set in set,) { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5 $as_echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;} ac_cache_corrupted=: ;; ,set) { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was not set in the previous run" >&5 $as_echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;} ac_cache_corrupted=: ;; ,);; *) if test "x$ac_old_val" != "x$ac_new_val"; then # differences in whitespace do not lead to failure. ac_old_val_w=`echo x $ac_old_val` ac_new_val_w=`echo x $ac_new_val` if test "$ac_old_val_w" != "$ac_new_val_w"; then { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' has changed since the previous run:" >&5 $as_echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;} ac_cache_corrupted=: else { $as_echo "$as_me:${as_lineno-$LINENO}: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5 $as_echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;} eval $ac_var=\$ac_old_val fi { $as_echo "$as_me:${as_lineno-$LINENO}: former value: \`$ac_old_val'" >&5 $as_echo "$as_me: former value: \`$ac_old_val'" >&2;} { $as_echo "$as_me:${as_lineno-$LINENO}: current value: \`$ac_new_val'" >&5 $as_echo "$as_me: current value: \`$ac_new_val'" >&2;} fi;; esac # Pass precious variables to config.status. if test "$ac_new_set" = set; then case $ac_new_val in *\'*) ac_arg=$ac_var=`$as_echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;; *) ac_arg=$ac_var=$ac_new_val ;; esac case " $ac_configure_args " in *" '$ac_arg' "*) ;; # Avoid dups. Use of quotes ensures accuracy. *) as_fn_append ac_configure_args " '$ac_arg'" ;; esac fi done if $ac_cache_corrupted; then { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} { $as_echo "$as_me:${as_lineno-$LINENO}: error: changes in the environment can compromise the build" >&5 $as_echo "$as_me: error: changes in the environment can compromise the build" >&2;} as_fn_error $? "run \`make distclean' and/or \`rm $cache_file' and start over" "$LINENO" 5 fi ## -------------------- ## ## Main body of script. ## ## -------------------- ## ac_ext=c ac_cpp='$CPP $CPPFLAGS' ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_c_compiler_gnu # acx_nlnetlabs.m4 - common macros for configure checks # Copyright 2009, Wouter Wijngaards, NLnet Labs. # BSD licensed. # # Version 26 # 2013-09-19 FLTO help text improved. # 2013-07-18 Enable ACX_CHECK_COMPILER_FLAG to test for -Wstrict-prototypes # 2013-06-25 FLTO has --disable-flto option. # 2013-05-03 Update W32_SLEEP for newer mingw that links but not defines it. # 2013-03-22 Fix ACX_RSRC_VERSION for long version numbers. # 2012-02-09 Fix AHX_MEMCMP_BROKEN with undef in compat/memcmp.h. # 2012-01-20 Fix COMPILER_FLAGS_UNBOUND for gcc 4.6.2 assigned-not-used-warns. # 2011-12-05 Fix getaddrinfowithincludes on windows with fedora16 mingw32-gcc. # Fix ACX_MALLOC for redefined malloc error. # Fix GETADDRINFO_WITH_INCLUDES to add -lws2_32 # 2011-11-10 Fix FLTO test to not drop a.out in current directory. # 2011-11-01 Fix FLTO test for llvm on Lion. # 2011-08-01 Fix nonblock test (broken at v13). # 2011-08-01 Fix autoconf 2.68 warnings # 2011-06-23 Add ACX_CHECK_FLTO to check -flto. # 2010-08-16 Fix FLAG_OMITTED for AS_TR_CPP changes in autoconf-2.66. # 2010-07-02 Add check for ss_family (for minix). # 2010-04-26 Fix to use CPPFLAGS for CHECK_COMPILER_FLAGS. # 2010-03-01 Fix RPATH using CONFIG_COMMANDS to run at the very end. # 2010-02-18 WITH_SSL outputs the LIBSSL_LDFLAGS, LIBS, CPPFLAGS separate, -ldl # 2010-02-01 added ACX_CHECK_MEMCMP_SIGNED, AHX_MEMCMP_BROKEN # 2010-01-20 added AHX_COONFIG_STRLCAT # 2009-07-14 U_CHAR detection improved for windows crosscompile. # added ACX_FUNC_MALLOC # fixup some #if to #ifdef # NONBLOCKING test for mingw crosscompile. # 2009-07-13 added ACX_WITH_SSL_OPTIONAL # 2009-07-03 fixup LDFLAGS for empty ssl dir. # # Automates some of the checking constructs. Aims at portability for POSIX. # Documentation for functions is below. # # the following macro's are provided in this file: # (see below for details on each macro). # # ACX_ESCAPE_BACKSLASH - escape backslashes in var for C-preproc. # ACX_RSRC_VERSION - create windows resource version number. # ACX_CHECK_COMPILER_FLAG - see if cc supports a flag. # ACX_CHECK_ERROR_FLAGS - see which flag is -werror (used below). # ACX_CHECK_COMPILER_FLAG_NEEDED - see if flags make the code compile cleanly. # ACX_DEPFLAG - find cc dependency flags. # ACX_DETERMINE_EXT_FLAGS_UNBOUND - find out which flags enable BSD and POSIX. # ACX_CHECK_FORMAT_ATTRIBUTE - find cc printf format syntax. # ACX_CHECK_UNUSED_ATTRIBUTE - find cc variable unused syntax. # ACX_CHECK_FLTO - see if cc supports -flto and use it if so. # ACX_LIBTOOL_C_ONLY - create libtool for C only, improved. # ACX_TYPE_U_CHAR - u_char type. # ACX_TYPE_RLIM_T - rlim_t type. # ACX_TYPE_SOCKLEN_T - socklen_t type. # ACX_TYPE_IN_ADDR_T - in_addr_t type. # ACX_TYPE_IN_PORT_T - in_port_t type. # ACX_ARG_RPATH - add --disable-rpath option. # ACX_WITH_SSL - add --with-ssl option, link -lcrypto. # ACX_WITH_SSL_OPTIONAL - add --with-ssl option, link -lcrypto, # where --without-ssl is also accepted # ACX_LIB_SSL - setup to link -lssl. # ACX_SYS_LARGEFILE - improved sys_largefile, fseeko, >2G files. # ACX_CHECK_GETADDRINFO_WITH_INCLUDES - find getaddrinfo, portably. # ACX_FUNC_DEPRECATED - see if func is deprecated. # ACX_CHECK_NONBLOCKING_BROKEN - see if nonblocking sockets really work. # ACX_MKDIR_ONE_ARG - determine mkdir(2) number of arguments. # ACX_FUNC_IOCTLSOCKET - find ioctlsocket, portably. # ACX_FUNC_MALLOC - check malloc, define replacement . # AHX_CONFIG_FORMAT_ATTRIBUTE - config.h text for format. # AHX_CONFIG_UNUSED_ATTRIBUTE - config.h text for unused. # AHX_CONFIG_FSEEKO - define fseeko, ftello fallback. # AHX_CONFIG_RAND_MAX - define RAND_MAX if needed. # AHX_CONFIG_MAXHOSTNAMELEN - define MAXHOSTNAMELEN if needed. # AHX_CONFIG_IPV6_MIN_MTU - define IPV6_MIN_MTU if needed. # AHX_CONFIG_SNPRINTF - snprintf compat prototype # AHX_CONFIG_INET_PTON - inet_pton compat prototype # AHX_CONFIG_INET_NTOP - inet_ntop compat prototype # AHX_CONFIG_INET_ATON - inet_aton compat prototype # AHX_CONFIG_MEMMOVE - memmove compat prototype # AHX_CONFIG_STRLCAT - strlcat compat prototype # AHX_CONFIG_STRLCPY - strlcpy compat prototype # AHX_CONFIG_GMTIME_R - gmtime_r compat prototype # AHX_CONFIG_W32_SLEEP - w32 compat for sleep # AHX_CONFIG_W32_USLEEP - w32 compat for usleep # AHX_CONFIG_W32_RANDOM - w32 compat for random # AHX_CONFIG_W32_SRANDOM - w32 compat for srandom # AHX_CONFIG_W32_FD_SET_T - w32 detection of FD_SET_T. # ACX_CFLAGS_STRIP - strip one flag from CFLAGS # ACX_STRIP_EXT_FLAGS - strip extension flags from CFLAGS # AHX_CONFIG_FLAG_OMITTED - define omitted flag # AHX_CONFIG_FLAG_EXT - define omitted extension flag # AHX_CONFIG_EXT_FLAGS - define the stripped extension flags # ACX_CHECK_MEMCMP_SIGNED - check if memcmp uses signed characters. # AHX_MEMCMP_BROKEN - replace memcmp func for CHECK_MEMCMP_SIGNED. # ACX_CHECK_SS_FAMILY - check for sockaddr_storage.ss_family # OURCPPFLAGS='' CPPFLAGS=${CPPFLAGS:-${OURCPPFLAGS}} OURCFLAGS='-g' CFLAGS=${CFLAGS:-${OURCFLAGS}} $as_echo "#define WINVER 0x0502" >>confdefs.h ac_ext=c ac_cpp='$CPP $CPPFLAGS' ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_c_compiler_gnu if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args. set dummy ${ac_tool_prefix}gcc; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_CC+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$CC"; then ac_cv_prog_CC="$CC" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then ac_cv_prog_CC="${ac_tool_prefix}gcc" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi CC=$ac_cv_prog_CC if test -n "$CC"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 $as_echo "$CC" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi fi if test -z "$ac_cv_prog_CC"; then ac_ct_CC=$CC # Extract the first word of "gcc", so it can be a program name with args. set dummy gcc; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_ac_ct_CC+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$ac_ct_CC"; then ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then ac_cv_prog_ac_ct_CC="gcc" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi ac_ct_CC=$ac_cv_prog_ac_ct_CC if test -n "$ac_ct_CC"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5 $as_echo "$ac_ct_CC" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi if test "x$ac_ct_CC" = x; then CC="" else case $cross_compiling:$ac_tool_warned in yes:) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac CC=$ac_ct_CC fi else CC="$ac_cv_prog_CC" fi if test -z "$CC"; then if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args. set dummy ${ac_tool_prefix}cc; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_CC+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$CC"; then ac_cv_prog_CC="$CC" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then ac_cv_prog_CC="${ac_tool_prefix}cc" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi CC=$ac_cv_prog_CC if test -n "$CC"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 $as_echo "$CC" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi fi fi if test -z "$CC"; then # Extract the first word of "cc", so it can be a program name with args. set dummy cc; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_CC+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$CC"; then ac_cv_prog_CC="$CC" # Let the user override the test. else ac_prog_rejected=no as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then ac_prog_rejected=yes continue fi ac_cv_prog_CC="cc" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS if test $ac_prog_rejected = yes; then # We found a bogon in the path, so make sure we never use it. set dummy $ac_cv_prog_CC shift if test $# != 0; then # We chose a different compiler from the bogus one. # However, it has the same basename, so the bogon will be chosen # first if we set CC to just the basename; use the full file name. shift ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@" fi fi fi fi CC=$ac_cv_prog_CC if test -n "$CC"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 $as_echo "$CC" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi fi if test -z "$CC"; then if test -n "$ac_tool_prefix"; then for ac_prog in cl.exe do # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args. set dummy $ac_tool_prefix$ac_prog; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_CC+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$CC"; then ac_cv_prog_CC="$CC" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then ac_cv_prog_CC="$ac_tool_prefix$ac_prog" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi CC=$ac_cv_prog_CC if test -n "$CC"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 $as_echo "$CC" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi test -n "$CC" && break done fi if test -z "$CC"; then ac_ct_CC=$CC for ac_prog in cl.exe do # Extract the first word of "$ac_prog", so it can be a program name with args. set dummy $ac_prog; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_ac_ct_CC+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$ac_ct_CC"; then ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then ac_cv_prog_ac_ct_CC="$ac_prog" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi ac_ct_CC=$ac_cv_prog_ac_ct_CC if test -n "$ac_ct_CC"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5 $as_echo "$ac_ct_CC" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi test -n "$ac_ct_CC" && break done if test "x$ac_ct_CC" = x; then CC="" else case $cross_compiling:$ac_tool_warned in yes:) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac CC=$ac_ct_CC fi fi fi test -z "$CC" && { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error $? "no acceptable C compiler found in \$PATH See \`config.log' for more details" "$LINENO" 5; } # Provide some information about the compiler. $as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5 set X $ac_compile ac_compiler=$2 for ac_option in --version -v -V -qversion; do { { ac_try="$ac_compiler $ac_option >&5" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_compiler $ac_option >&5") 2>conftest.err ac_status=$? if test -s conftest.err; then sed '10a\ ... rest of stderr output deleted ... 10q' conftest.err >conftest.er1 cat conftest.er1 >&5 fi rm -f conftest.er1 conftest.err $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } done cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { ; return 0; } _ACEOF ac_clean_files_save=$ac_clean_files ac_clean_files="$ac_clean_files a.out a.out.dSYM a.exe b.out" # Try to create an executable without -o first, disregard a.out. # It will help us diagnose broken compilers, and finding out an intuition # of exeext. { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the C compiler works" >&5 $as_echo_n "checking whether the C compiler works... " >&6; } ac_link_default=`$as_echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'` # The possible output files: ac_files="a.out conftest.exe conftest a.exe a_out.exe b.out conftest.*" ac_rmfiles= for ac_file in $ac_files do case $ac_file in *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;; * ) ac_rmfiles="$ac_rmfiles $ac_file";; esac done rm -f $ac_rmfiles if { { ac_try="$ac_link_default" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_link_default") 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; then : # Autoconf-2.13 could set the ac_cv_exeext variable to `no'. # So ignore a value of `no', otherwise this would lead to `EXEEXT = no' # in a Makefile. We should not override ac_cv_exeext if it was cached, # so that the user can short-circuit this test for compilers unknown to # Autoconf. for ac_file in $ac_files '' do test -f "$ac_file" || continue case $ac_file in *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;; [ab].out ) # We found the default executable, but exeext='' is most # certainly right. break;; *.* ) if test "${ac_cv_exeext+set}" = set && test "$ac_cv_exeext" != no; then :; else ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'` fi # We set ac_cv_exeext here because the later test for it is not # safe: cross compilers may not add the suffix if given an `-o' # argument, so we may need to know it at that point already. # Even if this section looks crufty: it has the advantage of # actually working. break;; * ) break;; esac done test "$ac_cv_exeext" = no && ac_cv_exeext= else ac_file='' fi if test -z "$ac_file"; then : { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } $as_echo "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error 77 "C compiler cannot create executables See \`config.log' for more details" "$LINENO" 5; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 $as_echo "yes" >&6; } fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler default output file name" >&5 $as_echo_n "checking for C compiler default output file name... " >&6; } { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_file" >&5 $as_echo "$ac_file" >&6; } ac_exeext=$ac_cv_exeext rm -f -r a.out a.out.dSYM a.exe conftest$ac_cv_exeext b.out ac_clean_files=$ac_clean_files_save { $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of executables" >&5 $as_echo_n "checking for suffix of executables... " >&6; } if { { ac_try="$ac_link" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_link") 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; then : # If both `conftest.exe' and `conftest' are `present' (well, observable) # catch `conftest.exe'. For instance with Cygwin, `ls conftest' will # work properly (i.e., refer to `conftest.exe'), while it won't with # `rm'. for ac_file in conftest.exe conftest conftest.*; do test -f "$ac_file" || continue case $ac_file in *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;; *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'` break;; * ) break;; esac done else { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error $? "cannot compute suffix of executables: cannot compile and link See \`config.log' for more details" "$LINENO" 5; } fi rm -f conftest conftest$ac_cv_exeext { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_exeext" >&5 $as_echo "$ac_cv_exeext" >&6; } rm -f conftest.$ac_ext EXEEXT=$ac_cv_exeext ac_exeext=$EXEEXT cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include int main () { FILE *f = fopen ("conftest.out", "w"); return ferror (f) || fclose (f) != 0; ; return 0; } _ACEOF ac_clean_files="$ac_clean_files conftest.out" # Check that the compiler produces executables we can run. If not, either # the compiler is broken, or we cross compile. { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are cross compiling" >&5 $as_echo_n "checking whether we are cross compiling... " >&6; } if test "$cross_compiling" != yes; then { { ac_try="$ac_link" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_link") 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } if { ac_try='./conftest$ac_cv_exeext' { { case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_try") 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; }; then cross_compiling=no else if test "$cross_compiling" = maybe; then cross_compiling=yes else { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error $? "cannot run C compiled programs. If you meant to cross compile, use \`--host'. See \`config.log' for more details" "$LINENO" 5; } fi fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $cross_compiling" >&5 $as_echo "$cross_compiling" >&6; } rm -f conftest.$ac_ext conftest$ac_cv_exeext conftest.out ac_clean_files=$ac_clean_files_save { $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of object files" >&5 $as_echo_n "checking for suffix of object files... " >&6; } if ${ac_cv_objext+:} false; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { ; return 0; } _ACEOF rm -f conftest.o conftest.obj if { { ac_try="$ac_compile" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_compile") 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; then : for ac_file in conftest.o conftest.obj conftest.*; do test -f "$ac_file" || continue; case $ac_file in *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM ) ;; *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'` break;; esac done else $as_echo "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error $? "cannot compute suffix of object files: cannot compile See \`config.log' for more details" "$LINENO" 5; } fi rm -f conftest.$ac_cv_objext conftest.$ac_ext fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_objext" >&5 $as_echo "$ac_cv_objext" >&6; } OBJEXT=$ac_cv_objext ac_objext=$OBJEXT { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C compiler" >&5 $as_echo_n "checking whether we are using the GNU C compiler... " >&6; } if ${ac_cv_c_compiler_gnu+:} false; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { #ifndef __GNUC__ choke me #endif ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ac_compiler_gnu=yes else ac_compiler_gnu=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext ac_cv_c_compiler_gnu=$ac_compiler_gnu fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_compiler_gnu" >&5 $as_echo "$ac_cv_c_compiler_gnu" >&6; } if test $ac_compiler_gnu = yes; then GCC=yes else GCC= fi ac_test_CFLAGS=${CFLAGS+set} ac_save_CFLAGS=$CFLAGS { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC accepts -g" >&5 $as_echo_n "checking whether $CC accepts -g... " >&6; } if ${ac_cv_prog_cc_g+:} false; then : $as_echo_n "(cached) " >&6 else ac_save_c_werror_flag=$ac_c_werror_flag ac_c_werror_flag=yes ac_cv_prog_cc_g=no CFLAGS="-g" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ac_cv_prog_cc_g=yes else CFLAGS="" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : else ac_c_werror_flag=$ac_save_c_werror_flag CFLAGS="-g" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ac_cv_prog_cc_g=yes fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext ac_c_werror_flag=$ac_save_c_werror_flag fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_g" >&5 $as_echo "$ac_cv_prog_cc_g" >&6; } if test "$ac_test_CFLAGS" = set; then CFLAGS=$ac_save_CFLAGS elif test $ac_cv_prog_cc_g = yes; then if test "$GCC" = yes; then CFLAGS="-g -O2" else CFLAGS="-g" fi else if test "$GCC" = yes; then CFLAGS="-O2" else CFLAGS= fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO C89" >&5 $as_echo_n "checking for $CC option to accept ISO C89... " >&6; } if ${ac_cv_prog_cc_c89+:} false; then : $as_echo_n "(cached) " >&6 else ac_cv_prog_cc_c89=no ac_save_CC=$CC cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include #include #include /* Most of the following tests are stolen from RCS 5.7's src/conf.sh. */ struct buf { int x; }; FILE * (*rcsopen) (struct buf *, struct stat *, int); static char *e (p, i) char **p; int i; { return p[i]; } static char *f (char * (*g) (char **, int), char **p, ...) { char *s; va_list v; va_start (v,p); s = g (p, va_arg (v,int)); va_end (v); return s; } /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default. It has function prototypes and stuff, but not '\xHH' hex character constants. These don't provoke an error unfortunately, instead are silently treated as 'x'. The following induces an error, until -std is added to get proper ANSI mode. Curiously '\x00'!='x' always comes out true, for an array size at least. It's necessary to write '\x00'==0 to get something that's true only with -std. */ int osf4_cc_array ['\x00' == 0 ? 1 : -1]; /* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters inside strings and character constants. */ #define FOO(x) 'x' int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1]; int test (int i, double x); struct s1 {int (*f) (int a);}; struct s2 {int (*f) (double a);}; int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int); int argc; char **argv; int main () { return f (e, argv, 0) != argv[0] || f (e, argv, 1) != argv[1]; ; return 0; } _ACEOF for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std \ -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__" do CC="$ac_save_CC $ac_arg" if ac_fn_c_try_compile "$LINENO"; then : ac_cv_prog_cc_c89=$ac_arg fi rm -f core conftest.err conftest.$ac_objext test "x$ac_cv_prog_cc_c89" != "xno" && break done rm -f conftest.$ac_ext CC=$ac_save_CC fi # AC_CACHE_VAL case "x$ac_cv_prog_cc_c89" in x) { $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5 $as_echo "none needed" >&6; } ;; xno) { $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5 $as_echo "unsupported" >&6; } ;; *) CC="$CC $ac_cv_prog_cc_c89" { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5 $as_echo "$ac_cv_prog_cc_c89" >&6; } ;; esac if test "x$ac_cv_prog_cc_c89" != xno; then : fi ac_ext=c ac_cpp='$CPP $CPPFLAGS' ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_c_compiler_gnu ac_ext=c ac_cpp='$CPP $CPPFLAGS' ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_c_compiler_gnu { $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C preprocessor" >&5 $as_echo_n "checking how to run the C preprocessor... " >&6; } # On Suns, sometimes $CPP names a directory. if test -n "$CPP" && test -d "$CPP"; then CPP= fi if test -z "$CPP"; then if ${ac_cv_prog_CPP+:} false; then : $as_echo_n "(cached) " >&6 else # Double quotes because CPP needs to be expanded for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp" do ac_preproc_ok=false for ac_c_preproc_warn_flag in '' yes do # Use a header file that comes with gcc, so configuring glibc # with a fresh cross-compiler works. # Prefer to if __STDC__ is defined, since # exists even on freestanding compilers. # On the NeXT, cc -E runs the code through the compiler's parser, # not just through cpp. "Syntax error" is here to catch this case. cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #ifdef __STDC__ # include #else # include #endif Syntax error _ACEOF if ac_fn_c_try_cpp "$LINENO"; then : else # Broken: fails on valid input. continue fi rm -f conftest.err conftest.i conftest.$ac_ext # OK, works on sane cases. Now check whether nonexistent headers # can be detected and how. cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include _ACEOF if ac_fn_c_try_cpp "$LINENO"; then : # Broken: success on invalid input. continue else # Passes both tests. ac_preproc_ok=: break fi rm -f conftest.err conftest.i conftest.$ac_ext done # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. rm -f conftest.i conftest.err conftest.$ac_ext if $ac_preproc_ok; then : break fi done ac_cv_prog_CPP=$CPP fi CPP=$ac_cv_prog_CPP else ac_cv_prog_CPP=$CPP fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPP" >&5 $as_echo "$CPP" >&6; } ac_preproc_ok=false for ac_c_preproc_warn_flag in '' yes do # Use a header file that comes with gcc, so configuring glibc # with a fresh cross-compiler works. # Prefer to if __STDC__ is defined, since # exists even on freestanding compilers. # On the NeXT, cc -E runs the code through the compiler's parser, # not just through cpp. "Syntax error" is here to catch this case. cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #ifdef __STDC__ # include #else # include #endif Syntax error _ACEOF if ac_fn_c_try_cpp "$LINENO"; then : else # Broken: fails on valid input. continue fi rm -f conftest.err conftest.i conftest.$ac_ext # OK, works on sane cases. Now check whether nonexistent headers # can be detected and how. cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include _ACEOF if ac_fn_c_try_cpp "$LINENO"; then : # Broken: success on invalid input. continue else # Passes both tests. ac_preproc_ok=: break fi rm -f conftest.err conftest.i conftest.$ac_ext done # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. rm -f conftest.i conftest.err conftest.$ac_ext if $ac_preproc_ok; then : else { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error $? "C preprocessor \"$CPP\" fails sanity check See \`config.log' for more details" "$LINENO" 5; } fi ac_ext=c ac_cpp='$CPP $CPPFLAGS' ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_c_compiler_gnu { $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5 $as_echo_n "checking for grep that handles long lines and -e... " >&6; } if ${ac_cv_path_GREP+:} false; then : $as_echo_n "(cached) " >&6 else if test -z "$GREP"; then ac_path_GREP_found=false # Loop through the user's path and test for each of PROGNAME-LIST as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_prog in grep ggrep; do for ac_exec_ext in '' $ac_executable_extensions; do ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext" { test -f "$ac_path_GREP" && $as_test_x "$ac_path_GREP"; } || continue # Check for GNU ac_path_GREP and select it if it is found. # Check for GNU $ac_path_GREP case `"$ac_path_GREP" --version 2>&1` in *GNU*) ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;; *) ac_count=0 $as_echo_n 0123456789 >"conftest.in" while : do cat "conftest.in" "conftest.in" >"conftest.tmp" mv "conftest.tmp" "conftest.in" cp "conftest.in" "conftest.nl" $as_echo 'GREP' >> "conftest.nl" "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break as_fn_arith $ac_count + 1 && ac_count=$as_val if test $ac_count -gt ${ac_path_GREP_max-0}; then # Best one so far, save it but keep looking for a better one ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_max=$ac_count fi # 10*(2^10) chars as input seems more than enough test $ac_count -gt 10 && break done rm -f conftest.in conftest.tmp conftest.nl conftest.out;; esac $ac_path_GREP_found && break 3 done done done IFS=$as_save_IFS if test -z "$ac_cv_path_GREP"; then as_fn_error $? "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5 fi else ac_cv_path_GREP=$GREP fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5 $as_echo "$ac_cv_path_GREP" >&6; } GREP="$ac_cv_path_GREP" { $as_echo "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5 $as_echo_n "checking for egrep... " >&6; } if ${ac_cv_path_EGREP+:} false; then : $as_echo_n "(cached) " >&6 else if echo a | $GREP -E '(a|b)' >/dev/null 2>&1 then ac_cv_path_EGREP="$GREP -E" else if test -z "$EGREP"; then ac_path_EGREP_found=false # Loop through the user's path and test for each of PROGNAME-LIST as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_prog in egrep; do for ac_exec_ext in '' $ac_executable_extensions; do ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext" { test -f "$ac_path_EGREP" && $as_test_x "$ac_path_EGREP"; } || continue # Check for GNU ac_path_EGREP and select it if it is found. # Check for GNU $ac_path_EGREP case `"$ac_path_EGREP" --version 2>&1` in *GNU*) ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;; *) ac_count=0 $as_echo_n 0123456789 >"conftest.in" while : do cat "conftest.in" "conftest.in" >"conftest.tmp" mv "conftest.tmp" "conftest.in" cp "conftest.in" "conftest.nl" $as_echo 'EGREP' >> "conftest.nl" "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break as_fn_arith $ac_count + 1 && ac_count=$as_val if test $ac_count -gt ${ac_path_EGREP_max-0}; then # Best one so far, save it but keep looking for a better one ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_max=$ac_count fi # 10*(2^10) chars as input seems more than enough test $ac_count -gt 10 && break done rm -f conftest.in conftest.tmp conftest.nl conftest.out;; esac $ac_path_EGREP_found && break 3 done done done IFS=$as_save_IFS if test -z "$ac_cv_path_EGREP"; then as_fn_error $? "no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5 fi else ac_cv_path_EGREP=$EGREP fi fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5 $as_echo "$ac_cv_path_EGREP" >&6; } EGREP="$ac_cv_path_EGREP" { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ANSI C header files" >&5 $as_echo_n "checking for ANSI C header files... " >&6; } if ${ac_cv_header_stdc+:} false; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include #include #include int main () { ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ac_cv_header_stdc=yes else ac_cv_header_stdc=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext if test $ac_cv_header_stdc = yes; then # SunOS 4.x string.h does not declare mem*, contrary to ANSI. cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include _ACEOF if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | $EGREP "memchr" >/dev/null 2>&1; then : else ac_cv_header_stdc=no fi rm -f conftest* fi if test $ac_cv_header_stdc = yes; then # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI. cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include _ACEOF if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | $EGREP "free" >/dev/null 2>&1; then : else ac_cv_header_stdc=no fi rm -f conftest* fi if test $ac_cv_header_stdc = yes; then # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi. if test "$cross_compiling" = yes; then : : else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include #if ((' ' & 0x0FF) == 0x020) # define ISLOWER(c) ('a' <= (c) && (c) <= 'z') # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c)) #else # define ISLOWER(c) \ (('a' <= (c) && (c) <= 'i') \ || ('j' <= (c) && (c) <= 'r') \ || ('s' <= (c) && (c) <= 'z')) # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c)) #endif #define XOR(e, f) (((e) && !(f)) || (!(e) && (f))) int main () { int i; for (i = 0; i < 256; i++) if (XOR (islower (i), ISLOWER (i)) || toupper (i) != TOUPPER (i)) return 2; return 0; } _ACEOF if ac_fn_c_try_run "$LINENO"; then : else ac_cv_header_stdc=no fi rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ conftest.$ac_objext conftest.beam conftest.$ac_ext fi fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_stdc" >&5 $as_echo "$ac_cv_header_stdc" >&6; } if test $ac_cv_header_stdc = yes; then $as_echo "#define STDC_HEADERS 1" >>confdefs.h fi # On IRIX 5.3, sys/types and inttypes.h are conflicting. for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \ inttypes.h stdint.h unistd.h do : as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh` ac_fn_c_check_header_compile "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default " if eval test \"x\$"$as_ac_Header"\" = x"yes"; then : cat >>confdefs.h <<_ACEOF #define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1 _ACEOF fi done ac_fn_c_check_header_mongrel "$LINENO" "minix/config.h" "ac_cv_header_minix_config_h" "$ac_includes_default" if test "x$ac_cv_header_minix_config_h" = xyes; then : MINIX=yes else MINIX= fi if test "$MINIX" = yes; then $as_echo "#define _POSIX_SOURCE 1" >>confdefs.h $as_echo "#define _POSIX_1_SOURCE 2" >>confdefs.h $as_echo "#define _MINIX 1" >>confdefs.h fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether it is safe to define __EXTENSIONS__" >&5 $as_echo_n "checking whether it is safe to define __EXTENSIONS__... " >&6; } if ${ac_cv_safe_to_define___extensions__+:} false; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ # define __EXTENSIONS__ 1 $ac_includes_default int main () { ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ac_cv_safe_to_define___extensions__=yes else ac_cv_safe_to_define___extensions__=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_safe_to_define___extensions__" >&5 $as_echo "$ac_cv_safe_to_define___extensions__" >&6; } test $ac_cv_safe_to_define___extensions__ = yes && $as_echo "#define __EXTENSIONS__ 1" >>confdefs.h $as_echo "#define _ALL_SOURCE 1" >>confdefs.h $as_echo "#define _GNU_SOURCE 1" >>confdefs.h $as_echo "#define _POSIX_PTHREAD_SEMANTICS 1" >>confdefs.h $as_echo "#define _TANDEM_SOURCE 1" >>confdefs.h # Checks for programs. ac_ext=c ac_cpp='$CPP $CPPFLAGS' ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_c_compiler_gnu if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args. set dummy ${ac_tool_prefix}gcc; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_CC+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$CC"; then ac_cv_prog_CC="$CC" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then ac_cv_prog_CC="${ac_tool_prefix}gcc" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi CC=$ac_cv_prog_CC if test -n "$CC"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 $as_echo "$CC" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi fi if test -z "$ac_cv_prog_CC"; then ac_ct_CC=$CC # Extract the first word of "gcc", so it can be a program name with args. set dummy gcc; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_ac_ct_CC+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$ac_ct_CC"; then ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then ac_cv_prog_ac_ct_CC="gcc" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi ac_ct_CC=$ac_cv_prog_ac_ct_CC if test -n "$ac_ct_CC"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5 $as_echo "$ac_ct_CC" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi if test "x$ac_ct_CC" = x; then CC="" else case $cross_compiling:$ac_tool_warned in yes:) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac CC=$ac_ct_CC fi else CC="$ac_cv_prog_CC" fi if test -z "$CC"; then if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args. set dummy ${ac_tool_prefix}cc; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_CC+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$CC"; then ac_cv_prog_CC="$CC" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then ac_cv_prog_CC="${ac_tool_prefix}cc" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi CC=$ac_cv_prog_CC if test -n "$CC"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 $as_echo "$CC" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi fi fi if test -z "$CC"; then # Extract the first word of "cc", so it can be a program name with args. set dummy cc; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_CC+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$CC"; then ac_cv_prog_CC="$CC" # Let the user override the test. else ac_prog_rejected=no as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then ac_prog_rejected=yes continue fi ac_cv_prog_CC="cc" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS if test $ac_prog_rejected = yes; then # We found a bogon in the path, so make sure we never use it. set dummy $ac_cv_prog_CC shift if test $# != 0; then # We chose a different compiler from the bogus one. # However, it has the same basename, so the bogon will be chosen # first if we set CC to just the basename; use the full file name. shift ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@" fi fi fi fi CC=$ac_cv_prog_CC if test -n "$CC"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 $as_echo "$CC" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi fi if test -z "$CC"; then if test -n "$ac_tool_prefix"; then for ac_prog in cl.exe do # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args. set dummy $ac_tool_prefix$ac_prog; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_CC+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$CC"; then ac_cv_prog_CC="$CC" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then ac_cv_prog_CC="$ac_tool_prefix$ac_prog" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi CC=$ac_cv_prog_CC if test -n "$CC"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 $as_echo "$CC" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi test -n "$CC" && break done fi if test -z "$CC"; then ac_ct_CC=$CC for ac_prog in cl.exe do # Extract the first word of "$ac_prog", so it can be a program name with args. set dummy $ac_prog; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_ac_ct_CC+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$ac_ct_CC"; then ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then ac_cv_prog_ac_ct_CC="$ac_prog" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi ac_ct_CC=$ac_cv_prog_ac_ct_CC if test -n "$ac_ct_CC"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5 $as_echo "$ac_ct_CC" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi test -n "$ac_ct_CC" && break done if test "x$ac_ct_CC" = x; then CC="" else case $cross_compiling:$ac_tool_warned in yes:) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac CC=$ac_ct_CC fi fi fi test -z "$CC" && { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error $? "no acceptable C compiler found in \$PATH See \`config.log' for more details" "$LINENO" 5; } # Provide some information about the compiler. $as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5 set X $ac_compile ac_compiler=$2 for ac_option in --version -v -V -qversion; do { { ac_try="$ac_compiler $ac_option >&5" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_compiler $ac_option >&5") 2>conftest.err ac_status=$? if test -s conftest.err; then sed '10a\ ... rest of stderr output deleted ... 10q' conftest.err >conftest.er1 cat conftest.er1 >&5 fi rm -f conftest.er1 conftest.err $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } done { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C compiler" >&5 $as_echo_n "checking whether we are using the GNU C compiler... " >&6; } if ${ac_cv_c_compiler_gnu+:} false; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { #ifndef __GNUC__ choke me #endif ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ac_compiler_gnu=yes else ac_compiler_gnu=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext ac_cv_c_compiler_gnu=$ac_compiler_gnu fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_compiler_gnu" >&5 $as_echo "$ac_cv_c_compiler_gnu" >&6; } if test $ac_compiler_gnu = yes; then GCC=yes else GCC= fi ac_test_CFLAGS=${CFLAGS+set} ac_save_CFLAGS=$CFLAGS { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC accepts -g" >&5 $as_echo_n "checking whether $CC accepts -g... " >&6; } if ${ac_cv_prog_cc_g+:} false; then : $as_echo_n "(cached) " >&6 else ac_save_c_werror_flag=$ac_c_werror_flag ac_c_werror_flag=yes ac_cv_prog_cc_g=no CFLAGS="-g" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ac_cv_prog_cc_g=yes else CFLAGS="" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : else ac_c_werror_flag=$ac_save_c_werror_flag CFLAGS="-g" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ac_cv_prog_cc_g=yes fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext ac_c_werror_flag=$ac_save_c_werror_flag fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_g" >&5 $as_echo "$ac_cv_prog_cc_g" >&6; } if test "$ac_test_CFLAGS" = set; then CFLAGS=$ac_save_CFLAGS elif test $ac_cv_prog_cc_g = yes; then if test "$GCC" = yes; then CFLAGS="-g -O2" else CFLAGS="-g" fi else if test "$GCC" = yes; then CFLAGS="-O2" else CFLAGS= fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO C89" >&5 $as_echo_n "checking for $CC option to accept ISO C89... " >&6; } if ${ac_cv_prog_cc_c89+:} false; then : $as_echo_n "(cached) " >&6 else ac_cv_prog_cc_c89=no ac_save_CC=$CC cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include #include #include /* Most of the following tests are stolen from RCS 5.7's src/conf.sh. */ struct buf { int x; }; FILE * (*rcsopen) (struct buf *, struct stat *, int); static char *e (p, i) char **p; int i; { return p[i]; } static char *f (char * (*g) (char **, int), char **p, ...) { char *s; va_list v; va_start (v,p); s = g (p, va_arg (v,int)); va_end (v); return s; } /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default. It has function prototypes and stuff, but not '\xHH' hex character constants. These don't provoke an error unfortunately, instead are silently treated as 'x'. The following induces an error, until -std is added to get proper ANSI mode. Curiously '\x00'!='x' always comes out true, for an array size at least. It's necessary to write '\x00'==0 to get something that's true only with -std. */ int osf4_cc_array ['\x00' == 0 ? 1 : -1]; /* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters inside strings and character constants. */ #define FOO(x) 'x' int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1]; int test (int i, double x); struct s1 {int (*f) (int a);}; struct s2 {int (*f) (double a);}; int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int); int argc; char **argv; int main () { return f (e, argv, 0) != argv[0] || f (e, argv, 1) != argv[1]; ; return 0; } _ACEOF for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std \ -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__" do CC="$ac_save_CC $ac_arg" if ac_fn_c_try_compile "$LINENO"; then : ac_cv_prog_cc_c89=$ac_arg fi rm -f core conftest.err conftest.$ac_objext test "x$ac_cv_prog_cc_c89" != "xno" && break done rm -f conftest.$ac_ext CC=$ac_save_CC fi # AC_CACHE_VAL case "x$ac_cv_prog_cc_c89" in x) { $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5 $as_echo "none needed" >&6; } ;; xno) { $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5 $as_echo "unsupported" >&6; } ;; *) CC="$CC $ac_cv_prog_cc_c89" { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5 $as_echo "$ac_cv_prog_cc_c89" >&6; } ;; esac if test "x$ac_cv_prog_cc_c89" != xno; then : fi ac_ext=c ac_cpp='$CPP $CPPFLAGS' ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_c_compiler_gnu { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${MAKE-make} sets \$(MAKE)" >&5 $as_echo_n "checking whether ${MAKE-make} sets \$(MAKE)... " >&6; } set x ${MAKE-make} ac_make=`$as_echo "$2" | sed 's/+/p/g; s/[^a-zA-Z0-9_]/_/g'` if eval \${ac_cv_prog_make_${ac_make}_set+:} false; then : $as_echo_n "(cached) " >&6 else cat >conftest.make <<\_ACEOF SHELL = /bin/sh all: @echo '@@@%%%=$(MAKE)=@@@%%%' _ACEOF # GNU make sometimes prints "make[1]: Entering ...", which would confuse us. case `${MAKE-make} -f conftest.make 2>/dev/null` in *@@@%%%=?*=@@@%%%*) eval ac_cv_prog_make_${ac_make}_set=yes;; *) eval ac_cv_prog_make_${ac_make}_set=no;; esac rm -f conftest.make fi if eval test \$ac_cv_prog_make_${ac_make}_set = yes; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 $as_echo "yes" >&6; } SET_MAKE= else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } SET_MAKE="MAKE=${MAKE-make}" fi for ac_prog in glibtool libtool15 libtool do # Extract the first word of "$ac_prog", so it can be a program name with args. set dummy $ac_prog; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_libtool+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$libtool"; then ac_cv_prog_libtool="$libtool" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then ac_cv_prog_libtool="$ac_prog" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi libtool=$ac_cv_prog_libtool if test -n "$libtool"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $libtool" >&5 $as_echo "$libtool" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi test -n "$libtool" && break done test -n "$libtool" || libtool="../libtool" # add option to disable the evil rpath # Check whether --enable-rpath was given. if test "${enable_rpath+set}" = set; then : enableval=$enable_rpath; enable_rpath=$enableval else enable_rpath=yes fi if test "x$enable_rpath" = xyes; then RPATH_VAL="-Wl,-rpath=\${libdir}" fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC supports -std=c99" >&5 $as_echo_n "checking whether $CC supports -std=c99... " >&6; } cache=`echo std=c99 | sed 'y%.=/+-%___p_%'` if eval \${cv_prog_cc_flag_$cache+:} false; then : $as_echo_n "(cached) " >&6 else echo 'void f(void){}' >conftest.c if test -z "`$CC $CPPFLAGS $CFLAGS -std=c99 -c conftest.c 2>&1`"; then eval "cv_prog_cc_flag_$cache=yes" else eval "cv_prog_cc_flag_$cache=no" fi rm -f conftest conftest.o conftest.c fi if eval "test \"`echo '$cv_prog_cc_flag_'$cache`\" = yes"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 $as_echo "yes" >&6; } : C99FLAG="-std=c99" else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } : fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC supports -xc99" >&5 $as_echo_n "checking whether $CC supports -xc99... " >&6; } cache=`echo xc99 | sed 'y%.=/+-%___p_%'` if eval \${cv_prog_cc_flag_$cache+:} false; then : $as_echo_n "(cached) " >&6 else echo 'void f(void){}' >conftest.c if test -z "`$CC $CPPFLAGS $CFLAGS -xc99 -c conftest.c 2>&1`"; then eval "cv_prog_cc_flag_$cache=yes" else eval "cv_prog_cc_flag_$cache=no" fi rm -f conftest conftest.o conftest.c fi if eval "test \"`echo '$cv_prog_cc_flag_'$cache`\" = yes"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 $as_echo "yes" >&6; } : C99FLAG="-xc99" else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } : fi ac_fn_c_check_type "$LINENO" "size_t" "ac_cv_type_size_t" "$ac_includes_default" if test "x$ac_cv_type_size_t" = xyes; then : else cat >>confdefs.h <<_ACEOF #define size_t unsigned int _ACEOF fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC supports -O2" >&5 $as_echo_n "checking whether $CC supports -O2... " >&6; } cache=`echo O2 | sed 'y%.=/+-%___p_%'` if eval \${cv_prog_cc_flag_$cache+:} false; then : $as_echo_n "(cached) " >&6 else echo 'void f(void){}' >conftest.c if test -z "`$CC $CPPFLAGS $CFLAGS -O2 -c conftest.c 2>&1`"; then eval "cv_prog_cc_flag_$cache=yes" else eval "cv_prog_cc_flag_$cache=no" fi rm -f conftest conftest.o conftest.c fi if eval "test \"`echo '$cv_prog_cc_flag_'$cache`\" = yes"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 $as_echo "yes" >&6; } : CFLAGS="$CFLAGS -O2" else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } : fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC supports -Werror" >&5 $as_echo_n "checking whether $CC supports -Werror... " >&6; } cache=`echo Werror | sed 'y%.=/+-%___p_%'` if eval \${cv_prog_cc_flag_$cache+:} false; then : $as_echo_n "(cached) " >&6 else echo 'void f(void){}' >conftest.c if test -z "`$CC $CPPFLAGS $CFLAGS -Werror -c conftest.c 2>&1`"; then eval "cv_prog_cc_flag_$cache=yes" else eval "cv_prog_cc_flag_$cache=no" fi rm -f conftest conftest.o conftest.c fi if eval "test \"`echo '$cv_prog_cc_flag_'$cache`\" = yes"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 $as_echo "yes" >&6; } : ERRFLAG="-Werror" else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } : ERRFLAG="-errwarn" fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC supports -Wall" >&5 $as_echo_n "checking whether $CC supports -Wall... " >&6; } cache=`echo Wall | sed 'y%.=/+-%___p_%'` if eval \${cv_prog_cc_flag_$cache+:} false; then : $as_echo_n "(cached) " >&6 else echo 'void f(void){}' >conftest.c if test -z "`$CC $CPPFLAGS $CFLAGS -Wall -c conftest.c 2>&1`"; then eval "cv_prog_cc_flag_$cache=yes" else eval "cv_prog_cc_flag_$cache=no" fi rm -f conftest conftest.o conftest.c fi if eval "test \"`echo '$cv_prog_cc_flag_'$cache`\" = yes"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 $as_echo "yes" >&6; } : ERRFLAG="$ERRFLAG -Wall" else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } : ERRFLAG="$ERRFLAG -errfmt" fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we need $C99FLAG -D__EXTENSIONS__ -D_BSD_SOURCE -D_POSIX_C_SOURCE=200112 -D_XOPEN_SOURCE=600 as a flag for $CC" >&5 $as_echo_n "checking whether we need $C99FLAG -D__EXTENSIONS__ -D_BSD_SOURCE -D_POSIX_C_SOURCE=200112 -D_XOPEN_SOURCE=600 as a flag for $CC... " >&6; } cache=`$as_echo "$C99FLAG -D__EXTENSIONS__ -D_BSD_SOURCE -D_POSIX_C_SOURCE=200112 -D_XOPEN_SOURCE=600" | $as_tr_sh` if eval \${cv_prog_cc_flag_needed_$cache+:} false; then : $as_echo_n "(cached) " >&6 else echo ' #include "confdefs.h" #include #include #include #ifdef HAVE_TIME_H #include #endif #include #ifdef HAVE_GETOPT_H #include #endif int test() { int a; char **opts = NULL; struct timeval tv; char *t; time_t time = 0; char *buf = NULL; t = ctime_r(&time, buf); tv.tv_usec = 10; srandom(32); a = getopt(2, opts, "a"); a = isascii(32); return a; } ' > conftest.c echo 'void f(){}' >>conftest.c if test -z "`$CC $CPPFLAGS $CFLAGS $ERRFLAG -c conftest.c 2>&1`"; then eval "cv_prog_cc_flag_needed_$cache=no" else if test -z "`$CC $CPPFLAGS $CFLAGS $C99FLAG -D__EXTENSIONS__ -D_BSD_SOURCE -D_POSIX_C_SOURCE=200112 -D_XOPEN_SOURCE=600 $ERRFLAG -c conftest.c 2>&1`"; then eval "cv_prog_cc_flag_needed_$cache=yes" else eval "cv_prog_cc_flag_needed_$cache=fail" #echo 'Test with flag fails too!' #cat conftest.c #echo "$CC $CPPFLAGS $CFLAGS $C99FLAG -D__EXTENSIONS__ -D_BSD_SOURCE -D_POSIX_C_SOURCE=200112 -D_XOPEN_SOURCE=600 $ERRFLAG -c conftest.c 2>&1" #echo `$CC $CPPFLAGS $CFLAGS $C99FLAG -D__EXTENSIONS__ -D_BSD_SOURCE -D_POSIX_C_SOURCE=200112 -D_XOPEN_SOURCE=600 $ERRFLAG -c conftest.c 2>&1` #exit 1 fi fi rm -f conftest conftest.c conftest.o fi if eval "test \"`echo '$cv_prog_cc_flag_needed_'$cache`\" = yes"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 $as_echo "yes" >&6; } : CFLAGS="$CFLAGS $C99FLAG -D__EXTENSIONS__ -D_BSD_SOURCE -D_POSIX_C_SOURCE=200112 -D_XOPEN_SOURCE=600" else if eval "test \"`echo '$cv_prog_cc_flag_needed_'$cache`\" = no"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } #echo 'Test with flag is no!' #cat conftest.c #echo "$CC $CPPFLAGS $CFLAGS $C99FLAG -D__EXTENSIONS__ -D_BSD_SOURCE -D_POSIX_C_SOURCE=200112 -D_XOPEN_SOURCE=600 $ERRFLAG -c conftest.c 2>&1" #echo `$CC $CPPFLAGS $CFLAGS $C99FLAG -D__EXTENSIONS__ -D_BSD_SOURCE -D_POSIX_C_SOURCE=200112 -D_XOPEN_SOURCE=600 $ERRFLAG -c conftest.c 2>&1` #exit 1 : else { $as_echo "$as_me:${as_lineno-$LINENO}: result: failed" >&5 $as_echo "failed" >&6; } : fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we need $C99FLAG as a flag for $CC" >&5 $as_echo_n "checking whether we need $C99FLAG as a flag for $CC... " >&6; } cache=`$as_echo "$C99FLAG" | $as_tr_sh` if eval \${cv_prog_cc_flag_needed_$cache+:} false; then : $as_echo_n "(cached) " >&6 else echo '#include ' > conftest.c echo 'void f(){}' >>conftest.c if test -z "`$CC $CPPFLAGS $CFLAGS $ERRFLAG -c conftest.c 2>&1`"; then eval "cv_prog_cc_flag_needed_$cache=no" else if test -z "`$CC $CPPFLAGS $CFLAGS $C99FLAG $ERRFLAG -c conftest.c 2>&1`"; then eval "cv_prog_cc_flag_needed_$cache=yes" else eval "cv_prog_cc_flag_needed_$cache=fail" #echo 'Test with flag fails too!' #cat conftest.c #echo "$CC $CPPFLAGS $CFLAGS $C99FLAG $ERRFLAG -c conftest.c 2>&1" #echo `$CC $CPPFLAGS $CFLAGS $C99FLAG $ERRFLAG -c conftest.c 2>&1` #exit 1 fi fi rm -f conftest conftest.c conftest.o fi if eval "test \"`echo '$cv_prog_cc_flag_needed_'$cache`\" = yes"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 $as_echo "yes" >&6; } : CFLAGS="$CFLAGS $C99FLAG" else if eval "test \"`echo '$cv_prog_cc_flag_needed_'$cache`\" = no"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } #echo 'Test with flag is no!' #cat conftest.c #echo "$CC $CPPFLAGS $CFLAGS $C99FLAG $ERRFLAG -c conftest.c 2>&1" #echo `$CC $CPPFLAGS $CFLAGS $C99FLAG $ERRFLAG -c conftest.c 2>&1` #exit 1 : else { $as_echo "$as_me:${as_lineno-$LINENO}: result: failed" >&5 $as_echo "failed" >&6; } : fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking for inline" >&5 $as_echo_n "checking for inline... " >&6; } if ${ac_cv_c_inline+:} false; then : $as_echo_n "(cached) " >&6 else ac_cv_c_inline=no for ac_kw in inline __inline__ __inline; do cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #ifndef __cplusplus typedef int foo_t; static $ac_kw foo_t static_foo () {return 0; } $ac_kw foo_t foo () {return 0; } #endif _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ac_cv_c_inline=$ac_kw fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext test "$ac_cv_c_inline" != no && break done fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_inline" >&5 $as_echo "$ac_cv_c_inline" >&6; } case $ac_cv_c_inline in inline | yes) ;; *) case $ac_cv_c_inline in no) ac_val=;; *) ac_val=$ac_cv_c_inline;; esac cat >>confdefs.h <<_ACEOF #ifndef __cplusplus #define inline $ac_val #endif _ACEOF ;; esac ac_fn_c_check_type "$LINENO" "int8_t" "ac_cv_type_int8_t" "$ac_includes_default" if test "x$ac_cv_type_int8_t" = xyes; then : else cat >>confdefs.h <<_ACEOF #define int8_t char _ACEOF fi ac_fn_c_check_type "$LINENO" "int16_t" "ac_cv_type_int16_t" "$ac_includes_default" if test "x$ac_cv_type_int16_t" = xyes; then : else cat >>confdefs.h <<_ACEOF #define int16_t short _ACEOF fi ac_fn_c_check_type "$LINENO" "int32_t" "ac_cv_type_int32_t" "$ac_includes_default" if test "x$ac_cv_type_int32_t" = xyes; then : else cat >>confdefs.h <<_ACEOF #define int32_t int _ACEOF fi ac_fn_c_check_type "$LINENO" "int64_t" "ac_cv_type_int64_t" "$ac_includes_default" if test "x$ac_cv_type_int64_t" = xyes; then : else cat >>confdefs.h <<_ACEOF #define int64_t long long _ACEOF fi ac_fn_c_check_type "$LINENO" "uint8_t" "ac_cv_type_uint8_t" "$ac_includes_default" if test "x$ac_cv_type_uint8_t" = xyes; then : else cat >>confdefs.h <<_ACEOF #define uint8_t unsigned char _ACEOF fi ac_fn_c_check_type "$LINENO" "uint16_t" "ac_cv_type_uint16_t" "$ac_includes_default" if test "x$ac_cv_type_uint16_t" = xyes; then : else cat >>confdefs.h <<_ACEOF #define uint16_t unsigned short _ACEOF fi ac_fn_c_check_type "$LINENO" "uint32_t" "ac_cv_type_uint32_t" "$ac_includes_default" if test "x$ac_cv_type_uint32_t" = xyes; then : else cat >>confdefs.h <<_ACEOF #define uint32_t unsigned int _ACEOF fi ac_fn_c_check_type "$LINENO" "uint64_t" "ac_cv_type_uint64_t" "$ac_includes_default" if test "x$ac_cv_type_uint64_t" = xyes; then : else cat >>confdefs.h <<_ACEOF #define uint64_t unsigned long long _ACEOF fi ac_fn_c_check_type "$LINENO" "ssize_t" "ac_cv_type_ssize_t" "$ac_includes_default" if test "x$ac_cv_type_ssize_t" = xyes; then : else cat >>confdefs.h <<_ACEOF #define ssize_t int _ACEOF fi for ac_header in sys/types.h getopt.h stdlib.h stdio.h assert.h netinet/in.h ctype.h time.h arpa/inet.h sys/time.h sys/socket.h sys/select.h do : as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh` ac_fn_c_check_header_compile "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default " if eval test \"x\$"$as_ac_Header"\" = x"yes"; then : cat >>confdefs.h <<_ACEOF #define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1 _ACEOF fi done for ac_header in netinet/in_systm.h net/if.h netinet/ip.h netinet/udp.h netinet/if_ether.h netinet/ip6.h do : as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh` ac_fn_c_check_header_compile "$LINENO" "$ac_header" "$as_ac_Header" " $ac_includes_default #ifdef HAVE_NETINET_IN_SYSTM_H #include #endif #ifdef HAVE_NETINET_IN_H #include #endif #ifdef HAVE_SYS_SOCKET_H #include #endif #ifdef HAVE_NET_IF_H #include #endif " if eval test \"x\$"$as_ac_Header"\" = x"yes"; then : cat >>confdefs.h <<_ACEOF #define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1 _ACEOF fi done # MinGW32 tests for ac_header in winsock2.h ws2tcpip.h do : as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh` ac_fn_c_check_header_compile "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default " if eval test \"x\$"$as_ac_Header"\" = x"yes"; then : cat >>confdefs.h <<_ACEOF #define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1 _ACEOF fi done ac_fn_c_check_type "$LINENO" "socklen_t" "ac_cv_type_socklen_t" " $ac_includes_default #ifdef HAVE_SYS_SOCKET_H # include #endif #ifdef HAVE_WS2TCPIP_H # include #endif " if test "x$ac_cv_type_socklen_t" = xyes; then : else $as_echo "#define socklen_t int" >>confdefs.h fi for ac_header in sys/param.h sys/mount.h do : as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh` ac_fn_c_check_header_compile "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default #if HAVE_SYS_PARAM_H # include #endif " if eval test \"x\$"$as_ac_Header"\" = x"yes"; then : cat >>confdefs.h <<_ACEOF #define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1 _ACEOF fi done ac_fn_c_check_type "$LINENO" "in_addr_t" "ac_cv_type_in_addr_t" " #if HAVE_SYS_TYPES_H # include #endif #if HAVE_NETINET_IN_H # include #endif " if test "x$ac_cv_type_in_addr_t" = xyes; then : else $as_echo "#define in_addr_t uint32_t" >>confdefs.h fi ac_fn_c_check_type "$LINENO" "in_port_t" "ac_cv_type_in_port_t" " #if HAVE_SYS_TYPES_H # include #endif #if HAVE_NETINET_IN_H # include #endif " if test "x$ac_cv_type_in_port_t" = xyes; then : else $as_echo "#define in_port_t uint16_t" >>confdefs.h fi # check to see if libraries are needed for these functions. { $as_echo "$as_me:${as_lineno-$LINENO}: checking for library containing socket" >&5 $as_echo_n "checking for library containing socket... " >&6; } if ${ac_cv_search_socket+:} false; then : $as_echo_n "(cached) " >&6 else ac_func_search_save_LIBS=$LIBS cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ /* Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC builtin and then its argument prototype would still apply. */ #ifdef __cplusplus extern "C" #endif char socket (); int main () { return socket (); ; return 0; } _ACEOF for ac_lib in '' socket; do if test -z "$ac_lib"; then ac_res="none required" else ac_res=-l$ac_lib LIBS="-l$ac_lib $ac_func_search_save_LIBS" fi if ac_fn_c_try_link "$LINENO"; then : ac_cv_search_socket=$ac_res fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext if ${ac_cv_search_socket+:} false; then : break fi done if ${ac_cv_search_socket+:} false; then : else ac_cv_search_socket=no fi rm conftest.$ac_ext LIBS=$ac_func_search_save_LIBS fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_socket" >&5 $as_echo "$ac_cv_search_socket" >&6; } ac_res=$ac_cv_search_socket if test "$ac_res" != no; then : test "$ac_res" = "none required" || LIBS="$ac_res $LIBS" fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking for library containing inet_pton" >&5 $as_echo_n "checking for library containing inet_pton... " >&6; } if ${ac_cv_search_inet_pton+:} false; then : $as_echo_n "(cached) " >&6 else ac_func_search_save_LIBS=$LIBS cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ /* Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC builtin and then its argument prototype would still apply. */ #ifdef __cplusplus extern "C" #endif char inet_pton (); int main () { return inet_pton (); ; return 0; } _ACEOF for ac_lib in '' nsl; do if test -z "$ac_lib"; then ac_res="none required" else ac_res=-l$ac_lib LIBS="-l$ac_lib $ac_func_search_save_LIBS" fi if ac_fn_c_try_link "$LINENO"; then : ac_cv_search_inet_pton=$ac_res fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext if ${ac_cv_search_inet_pton+:} false; then : break fi done if ${ac_cv_search_inet_pton+:} false; then : else ac_cv_search_inet_pton=no fi rm conftest.$ac_ext LIBS=$ac_func_search_save_LIBS fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_inet_pton" >&5 $as_echo "$ac_cv_search_inet_pton" >&6; } ac_res=$ac_cv_search_inet_pton if test "$ac_res" != no; then : test "$ac_res" = "none required" || LIBS="$ac_res $LIBS" fi # Check whether --with-ssl was given. if test "${with_ssl+set}" = set; then : withval=$with_ssl; else withval="yes" fi withval=$withval if test x_$withval != x_no; then { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SSL" >&5 $as_echo_n "checking for SSL... " >&6; } if test x_$withval = x_ -o x_$withval = x_yes; then withval="/usr/local/ssl /usr/lib/ssl /usr/ssl /usr/pkg /usr/local /opt/local /usr/sfw /usr" fi for dir in $withval; do ssldir="$dir" if test -f "$dir/include/openssl/ssl.h"; then found_ssl="yes" cat >>confdefs.h <<_ACEOF #define HAVE_SSL /**/ _ACEOF if test "$ssldir" != "/usr"; then CPPFLAGS="$CPPFLAGS -I$ssldir/include" LIBSSL_CPPFLAGS="$LIBSSL_CPPFLAGS -I$ssldir/include" fi break; fi done if test x_$found_ssl != x_yes; then as_fn_error $? "Cannot find the SSL libraries in $withval" "$LINENO" 5 else { $as_echo "$as_me:${as_lineno-$LINENO}: result: found in $ssldir" >&5 $as_echo "found in $ssldir" >&6; } HAVE_SSL=yes if test "$ssldir" != "/usr" -a "$ssldir" != ""; then LDFLAGS="$LDFLAGS -L$ssldir/lib" LIBSSL_LDFLAGS="$LIBSSL_LDFLAGS -L$ssldir/lib" if test "x$enable_rpath" = xyes; then if echo "$ssldir/lib" | grep "^/" >/dev/null; then RUNTIME_PATH="$RUNTIME_PATH -R$ssldir/lib" fi fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking for HMAC_CTX_init in -lcrypto" >&5 $as_echo_n "checking for HMAC_CTX_init in -lcrypto... " >&6; } LIBS="$LIBS -lcrypto" LIBSSL_LIBS="$LIBSSL_LIBS -lcrypto" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { int HMAC_CTX_init(void); (void)HMAC_CTX_init(); ; return 0; } _ACEOF if ac_fn_c_try_link "$LINENO"; then : { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 $as_echo "yes" >&6; } $as_echo "#define HAVE_HMAC_CTX_INIT 1" >>confdefs.h else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } # check if -lwsock32 or -lgdi32 are needed. BAKLIBS="$LIBS" BAKSSLLIBS="$LIBSSL_LIBS" LIBS="$LIBS -lgdi32" LIBSSL_LIBS="$LIBSSL_LIBS -lgdi32" { $as_echo "$as_me:${as_lineno-$LINENO}: checking if -lcrypto needs -lgdi32" >&5 $as_echo_n "checking if -lcrypto needs -lgdi32... " >&6; } cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { int HMAC_CTX_init(void); (void)HMAC_CTX_init(); ; return 0; } _ACEOF if ac_fn_c_try_link "$LINENO"; then : $as_echo "#define HAVE_HMAC_CTX_INIT 1" >>confdefs.h { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 $as_echo "yes" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } LIBS="$BAKLIBS" LIBSSL_LIBS="$BAKSSLLIBS" LIBS="$LIBS -ldl" LIBSSL_LIBS="$LIBSSL_LIBS -ldl" { $as_echo "$as_me:${as_lineno-$LINENO}: checking if -lcrypto needs -ldl" >&5 $as_echo_n "checking if -lcrypto needs -ldl... " >&6; } cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { int HMAC_CTX_init(void); (void)HMAC_CTX_init(); ; return 0; } _ACEOF if ac_fn_c_try_link "$LINENO"; then : $as_echo "#define HAVE_HMAC_CTX_INIT 1" >>confdefs.h { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 $as_echo "yes" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } as_fn_error $? "OpenSSL found in $ssldir, but version 0.9.7 or higher is required" "$LINENO" 5 fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext conftest.$ac_ext fi # openssl engine functionality needs dlopen(). BAKLIBS="$LIBS" { $as_echo "$as_me:${as_lineno-$LINENO}: checking for library containing dlopen" >&5 $as_echo_n "checking for library containing dlopen... " >&6; } if ${ac_cv_search_dlopen+:} false; then : $as_echo_n "(cached) " >&6 else ac_func_search_save_LIBS=$LIBS cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ /* Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC builtin and then its argument prototype would still apply. */ #ifdef __cplusplus extern "C" #endif char dlopen (); int main () { return dlopen (); ; return 0; } _ACEOF for ac_lib in '' dl; do if test -z "$ac_lib"; then ac_res="none required" else ac_res=-l$ac_lib LIBS="-l$ac_lib $ac_func_search_save_LIBS" fi if ac_fn_c_try_link "$LINENO"; then : ac_cv_search_dlopen=$ac_res fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext if ${ac_cv_search_dlopen+:} false; then : break fi done if ${ac_cv_search_dlopen+:} false; then : else ac_cv_search_dlopen=no fi rm conftest.$ac_ext LIBS=$ac_func_search_save_LIBS fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_dlopen" >&5 $as_echo "$ac_cv_search_dlopen" >&6; } ac_res=$ac_cv_search_dlopen if test "$ac_res" != no; then : test "$ac_res" = "none required" || LIBS="$ac_res $LIBS" fi if test "$LIBS" != "$BAKLIBS"; then LIBSSL_LIBS="$LIBSSL_LIBS -ldl" fi fi for ac_header in openssl/ssl.h do : ac_fn_c_check_header_compile "$LINENO" "openssl/ssl.h" "ac_cv_header_openssl_ssl_h" "$ac_includes_default " if test "x$ac_cv_header_openssl_ssl_h" = xyes; then : cat >>confdefs.h <<_ACEOF #define HAVE_OPENSSL_SSL_H 1 _ACEOF fi done for ac_header in openssl/err.h do : ac_fn_c_check_header_compile "$LINENO" "openssl/err.h" "ac_cv_header_openssl_err_h" "$ac_includes_default " if test "x$ac_cv_header_openssl_err_h" = xyes; then : cat >>confdefs.h <<_ACEOF #define HAVE_OPENSSL_ERR_H 1 _ACEOF fi done for ac_header in openssl/rand.h do : ac_fn_c_check_header_compile "$LINENO" "openssl/rand.h" "ac_cv_header_openssl_rand_h" "$ac_includes_default " if test "x$ac_cv_header_openssl_rand_h" = xyes; then : cat >>confdefs.h <<_ACEOF #define HAVE_OPENSSL_RAND_H 1 _ACEOF fi done { $as_echo "$as_me:${as_lineno-$LINENO}: checking for getaddrinfo" >&5 $as_echo_n "checking for getaddrinfo... " >&6; } ac_cv_func_getaddrinfo=no cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #ifdef __cplusplus extern "C" { #endif char* getaddrinfo(); char* (*f) () = getaddrinfo; #ifdef __cplusplus } #endif int main() { ; return 0; } _ACEOF if ac_fn_c_try_link "$LINENO"; then : ac_cv_func_getaddrinfo="yes" if test "$ac_cv_header_windows_h" = "yes"; then $as_echo "#define USE_WINSOCK 1" >>confdefs.h USE_WINSOCK="1" LIBS="$LIBS -lws2_32" fi else ORIGLIBS="$LIBS" LIBS="$LIBS -lws2_32" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #ifdef HAVE_WS2TCPIP_H #include #endif int main () { (void)getaddrinfo(NULL, NULL, NULL, NULL); ; return 0; } _ACEOF if ac_fn_c_try_link "$LINENO"; then : ac_cv_func_getaddrinfo="yes" $as_echo "#define USE_WINSOCK 1" >>confdefs.h USE_WINSOCK="1" else ac_cv_func_getaddrinfo="no" LIBS="$ORIGLIBS" fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext conftest.$ac_ext { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_getaddrinfo" >&5 $as_echo "$ac_cv_func_getaddrinfo" >&6; } if test $ac_cv_func_getaddrinfo = yes; then $as_echo "#define HAVE_GETADDRINFO 1" >>confdefs.h fi LIBS_STC="$LIBS" # check for ldns # Check whether --with-ldns was given. if test "${with_ldns+set}" = set; then : withval=$with_ldns; specialldnsdir="$withval" CPPFLAGS="$CPPFLAGS -I$withval/include" LDFLAGS="-L$withval -L$withval/lib $LDFLAGS" LDNSDIR="$withval" LIBS="-lldns $LIBS" LIBS_STC="$withval/lib/libldns.a $LIBS_STC" fi #AC_CHECK_HEADER(ldns/ldns.h,, [ # AC_MSG_ERROR([Can't find ldns headers (make copy-headers in devel source.)]) # ], [AC_INCLUDES_DEFAULT] #) for ac_func in isblank do : ac_fn_c_check_func "$LINENO" "isblank" "ac_cv_func_isblank" if test "x$ac_cv_func_isblank" = xyes; then : cat >>confdefs.h <<_ACEOF #define HAVE_ISBLANK 1 _ACEOF fi done # check for ldns development source tree { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ldns devel source" >&5 $as_echo_n "checking for ldns devel source... " >&6; } ldns_dev_dir=.. if test -f $ldns_dev_dir/ldns/util.h && \ grep LDNS_VERSION $ldns_dev_dir/ldns/util.h >/dev/null; then ldns_version=`grep LDNS_VERSION $ldns_dev_dir/ldns/util.h | sed -e 's/^.*"\(.*\)".*$/\1/'` { $as_echo "$as_me:${as_lineno-$LINENO}: result: using $ldns_dev_dir with $ldns_version" >&5 $as_echo "using $ldns_dev_dir with $ldns_version" >&6; } CPPFLAGS="$CPPFLAGS -I$ldns_dev_dir/include" LDFLAGS="-L$ldns_dev_dir -L$ldns_dev_dir/lib $LDFLAGS" LIBS="-lldns $LIBS" $as_echo "#define HAVE_LIBLDNS 1" >>confdefs.h LDNSDIR="$ldns_dev_dir" LIBS_STC="$ldns_dev_dir/lib/libldns.a $LIBS_STC" else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ldns_rr_new in -lldns" >&5 $as_echo_n "checking for ldns_rr_new in -lldns... " >&6; } if ${ac_cv_lib_ldns_ldns_rr_new+:} false; then : $as_echo_n "(cached) " >&6 else ac_check_lib_save_LIBS=$LIBS LIBS="-lldns $LIBS" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ /* Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC builtin and then its argument prototype would still apply. */ #ifdef __cplusplus extern "C" #endif char ldns_rr_new (); int main () { return ldns_rr_new (); ; return 0; } _ACEOF if ac_fn_c_try_link "$LINENO"; then : ac_cv_lib_ldns_ldns_rr_new=yes else ac_cv_lib_ldns_ldns_rr_new=no fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext conftest.$ac_ext LIBS=$ac_check_lib_save_LIBS fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_ldns_ldns_rr_new" >&5 $as_echo "$ac_cv_lib_ldns_ldns_rr_new" >&6; } if test "x$ac_cv_lib_ldns_ldns_rr_new" = xyes; then : cat >>confdefs.h <<_ACEOF #define HAVE_LIBLDNS 1 _ACEOF LIBS="-lldns $LIBS" else as_fn_error $? "Can't find ldns library" "$LINENO" 5 fi fi # Check whether --with-trust-anchor was given. if test "${with_trust_anchor+set}" = set; then : withval=$with_trust_anchor; LDNS_TRUST_ANCHOR_FILE="$withval" else if test "x$LDNS_TRUST_ANCHOR_FILE" = "x"; then if test "x$sysconfdir" = 'x${prefix}/etc' ; then if test "x$prefix" = 'xNONE' ; then LDNS_TRUST_ANCHOR_FILE="/etc/unbound/root.key" else LDNS_TRUST_ANCHOR_FILE="${prefix}/etc/unbound/root.key" fi else LDNS_TRUST_ANCHOR_FILE="${sysconfdir}/unbound/root.key" fi fi fi cat >>confdefs.h <<_ACEOF #define LDNS_TRUST_ANCHOR_FILE "$LDNS_TRUST_ANCHOR_FILE" _ACEOF { $as_echo "$as_me:${as_lineno-$LINENO}: Default trust anchor: $LDNS_TRUST_ANCHOR_FILE" >&5 $as_echo "$as_me: Default trust anchor: $LDNS_TRUST_ANCHOR_FILE" >&6;} ac_config_files="$ac_config_files Makefile drill.1" ac_config_headers="$ac_config_headers config.h" cat >confcache <<\_ACEOF # This file is a shell script that caches the results of configure # tests run on this system so they can be shared between configure # scripts and configure runs, see configure's option --config-cache. # It is not useful on other systems. If it contains results you don't # want to keep, you may remove or edit it. # # config.status only pays attention to the cache file if you give it # the --recheck option to rerun configure. # # `ac_cv_env_foo' variables (set or unset) will be overridden when # loading this file, other *unset* `ac_cv_foo' will be assigned the # following values. _ACEOF # The following way of writing the cache mishandles newlines in values, # but we know of no workaround that is simple, portable, and efficient. # So, we kill variables containing newlines. # Ultrix sh set writes to stderr and can't be redirected directly, # and sets the high bit in the cache file unless we assign to the vars. ( for ac_var in `(set) 2>&1 | sed -n 's/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'`; do eval ac_val=\$$ac_var case $ac_val in #( *${as_nl}*) case $ac_var in #( *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5 $as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;; esac case $ac_var in #( _ | IFS | as_nl) ;; #( BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #( *) { eval $ac_var=; unset $ac_var;} ;; esac ;; esac done (set) 2>&1 | case $as_nl`(ac_space=' '; set) 2>&1` in #( *${as_nl}ac_space=\ *) # `set' does not quote correctly, so add quotes: double-quote # substitution turns \\\\ into \\, and sed turns \\ into \. sed -n \ "s/'/'\\\\''/g; s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p" ;; #( *) # `set' quotes correctly as required by POSIX, so do not add quotes. sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p" ;; esac | sort ) | sed ' /^ac_cv_env_/b end t clear :clear s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/ t end s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/ :end' >>confcache if diff "$cache_file" confcache >/dev/null 2>&1; then :; else if test -w "$cache_file"; then if test "x$cache_file" != "x/dev/null"; then { $as_echo "$as_me:${as_lineno-$LINENO}: updating cache $cache_file" >&5 $as_echo "$as_me: updating cache $cache_file" >&6;} if test ! -f "$cache_file" || test -h "$cache_file"; then cat confcache >"$cache_file" else case $cache_file in #( */* | ?:*) mv -f confcache "$cache_file"$$ && mv -f "$cache_file"$$ "$cache_file" ;; #( *) mv -f confcache "$cache_file" ;; esac fi fi else { $as_echo "$as_me:${as_lineno-$LINENO}: not updating unwritable cache $cache_file" >&5 $as_echo "$as_me: not updating unwritable cache $cache_file" >&6;} fi fi rm -f confcache test "x$prefix" = xNONE && prefix=$ac_default_prefix # Let make expand exec_prefix. test "x$exec_prefix" = xNONE && exec_prefix='${prefix}' DEFS=-DHAVE_CONFIG_H ac_libobjs= ac_ltlibobjs= U= for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue # 1. Remove the extension, and $U if already installed. ac_script='s/\$U\././;s/\.o$//;s/\.obj$//' ac_i=`$as_echo "$ac_i" | sed "$ac_script"` # 2. Prepend LIBOBJDIR. When used with automake>=1.10 LIBOBJDIR # will be set to the directory where LIBOBJS objects are built. as_fn_append ac_libobjs " \${LIBOBJDIR}$ac_i\$U.$ac_objext" as_fn_append ac_ltlibobjs " \${LIBOBJDIR}$ac_i"'$U.lo' done LIBOBJS=$ac_libobjs LTLIBOBJS=$ac_ltlibobjs : "${CONFIG_STATUS=./config.status}" ac_write_fail=0 ac_clean_files_save=$ac_clean_files ac_clean_files="$ac_clean_files $CONFIG_STATUS" { $as_echo "$as_me:${as_lineno-$LINENO}: creating $CONFIG_STATUS" >&5 $as_echo "$as_me: creating $CONFIG_STATUS" >&6;} as_write_fail=0 cat >$CONFIG_STATUS <<_ASEOF || as_write_fail=1 #! $SHELL # Generated by $as_me. # Run this file to recreate the current configuration. # Compiler output produced by configure, useful for debugging # configure, is in config.log if it exists. debug=false ac_cs_recheck=false ac_cs_silent=false SHELL=\${CONFIG_SHELL-$SHELL} export SHELL _ASEOF cat >>$CONFIG_STATUS <<\_ASEOF || as_write_fail=1 ## -------------------- ## ## M4sh Initialization. ## ## -------------------- ## # Be more Bourne compatible DUALCASE=1; export DUALCASE # for MKS sh if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then : emulate sh NULLCMD=: # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which # is contrary to our usage. Disable this feature. alias -g '${1+"$@"}'='"$@"' setopt NO_GLOB_SUBST else case `(set -o) 2>/dev/null` in #( *posix*) : set -o posix ;; #( *) : ;; esac fi as_nl=' ' export as_nl # Printing a long string crashes Solaris 7 /usr/bin/printf. as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo # Prefer a ksh shell builtin over an external printf program on Solaris, # but without wasting forks for bash or zsh. if test -z "$BASH_VERSION$ZSH_VERSION" \ && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then as_echo='print -r --' as_echo_n='print -rn --' elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then as_echo='printf %s\n' as_echo_n='printf %s' else if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"' as_echo_n='/usr/ucb/echo -n' else as_echo_body='eval expr "X$1" : "X\\(.*\\)"' as_echo_n_body='eval arg=$1; case $arg in #( *"$as_nl"*) expr "X$arg" : "X\\(.*\\)$as_nl"; arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;; esac; expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl" ' export as_echo_n_body as_echo_n='sh -c $as_echo_n_body as_echo' fi export as_echo_body as_echo='sh -c $as_echo_body as_echo' fi # The user is always right. if test "${PATH_SEPARATOR+set}" != set; then PATH_SEPARATOR=: (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && { (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 || PATH_SEPARATOR=';' } fi # IFS # We need space, tab and new line, in precisely that order. Quoting is # there to prevent editors from complaining about space-tab. # (If _AS_PATH_WALK were called with IFS unset, it would disable word # splitting by setting IFS to empty value.) IFS=" "" $as_nl" # Find who we are. Look in the path if we contain no directory separator. as_myself= case $0 in #(( *[\\/]* ) as_myself=$0 ;; *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break done IFS=$as_save_IFS ;; esac # We did not find ourselves, most probably we were run as `sh COMMAND' # in which case we are not to be found in the path. if test "x$as_myself" = x; then as_myself=$0 fi if test ! -f "$as_myself"; then $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2 exit 1 fi # Unset variables that we do not need and which cause bugs (e.g. in # pre-3.0 UWIN ksh). But do not cause bugs in bash 2.01; the "|| exit 1" # suppresses any "Segmentation fault" message there. '((' could # trigger a bug in pdksh 5.2.14. for as_var in BASH_ENV ENV MAIL MAILPATH do eval test x\${$as_var+set} = xset \ && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || : done PS1='$ ' PS2='> ' PS4='+ ' # NLS nuisances. LC_ALL=C export LC_ALL LANGUAGE=C export LANGUAGE # CDPATH. (unset CDPATH) >/dev/null 2>&1 && unset CDPATH # as_fn_error STATUS ERROR [LINENO LOG_FD] # ---------------------------------------- # Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are # provided, also output the error to LOG_FD, referencing LINENO. Then exit the # script with STATUS, using 1 if that was 0. as_fn_error () { as_status=$1; test $as_status -eq 0 && as_status=1 if test "$4"; then as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4 fi $as_echo "$as_me: error: $2" >&2 as_fn_exit $as_status } # as_fn_error # as_fn_set_status STATUS # ----------------------- # Set $? to STATUS, without forking. as_fn_set_status () { return $1 } # as_fn_set_status # as_fn_exit STATUS # ----------------- # Exit the shell with STATUS, even in a "trap 0" or "set -e" context. as_fn_exit () { set +e as_fn_set_status $1 exit $1 } # as_fn_exit # as_fn_unset VAR # --------------- # Portably unset VAR. as_fn_unset () { { eval $1=; unset $1;} } as_unset=as_fn_unset # as_fn_append VAR VALUE # ---------------------- # Append the text in VALUE to the end of the definition contained in VAR. Take # advantage of any shell optimizations that allow amortized linear growth over # repeated appends, instead of the typical quadratic growth present in naive # implementations. if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then : eval 'as_fn_append () { eval $1+=\$2 }' else as_fn_append () { eval $1=\$$1\$2 } fi # as_fn_append # as_fn_arith ARG... # ------------------ # Perform arithmetic evaluation on the ARGs, and store the result in the # global $as_val. Take advantage of shells that can avoid forks. The arguments # must be portable across $(()) and expr. if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then : eval 'as_fn_arith () { as_val=$(( $* )) }' else as_fn_arith () { as_val=`expr "$@" || test $? -eq 1` } fi # as_fn_arith if expr a : '\(a\)' >/dev/null 2>&1 && test "X`expr 00001 : '.*\(...\)'`" = X001; then as_expr=expr else as_expr=false fi if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then as_basename=basename else as_basename=false fi if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then as_dirname=dirname else as_dirname=false fi as_me=`$as_basename -- "$0" || $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \ X"$0" : 'X\(//\)$' \| \ X"$0" : 'X\(/\)' \| . 2>/dev/null || $as_echo X/"$0" | sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/ q } /^X\/\(\/\/\)$/{ s//\1/ q } /^X\/\(\/\).*/{ s//\1/ q } s/.*/./; q'` # Avoid depending upon Character Ranges. as_cr_letters='abcdefghijklmnopqrstuvwxyz' as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ' as_cr_Letters=$as_cr_letters$as_cr_LETTERS as_cr_digits='0123456789' as_cr_alnum=$as_cr_Letters$as_cr_digits ECHO_C= ECHO_N= ECHO_T= case `echo -n x` in #((((( -n*) case `echo 'xy\c'` in *c*) ECHO_T=' ';; # ECHO_T is single tab character. xy) ECHO_C='\c';; *) echo `echo ksh88 bug on AIX 6.1` > /dev/null ECHO_T=' ';; esac;; *) ECHO_N='-n';; esac rm -f conf$$ conf$$.exe conf$$.file if test -d conf$$.dir; then rm -f conf$$.dir/conf$$.file else rm -f conf$$.dir mkdir conf$$.dir 2>/dev/null fi if (echo >conf$$.file) 2>/dev/null; then if ln -s conf$$.file conf$$ 2>/dev/null; then as_ln_s='ln -s' # ... but there are two gotchas: # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail. # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable. # In both cases, we have to default to `cp -p'. ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe || as_ln_s='cp -p' elif ln conf$$.file conf$$ 2>/dev/null; then as_ln_s=ln else as_ln_s='cp -p' fi else as_ln_s='cp -p' fi rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file rmdir conf$$.dir 2>/dev/null # as_fn_mkdir_p # ------------- # Create "$as_dir" as a directory, including parents if necessary. as_fn_mkdir_p () { case $as_dir in #( -*) as_dir=./$as_dir;; esac test -d "$as_dir" || eval $as_mkdir_p || { as_dirs= while :; do case $as_dir in #( *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'( *) as_qdir=$as_dir;; esac as_dirs="'$as_qdir' $as_dirs" as_dir=`$as_dirname -- "$as_dir" || $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$as_dir" : 'X\(//\)[^/]' \| \ X"$as_dir" : 'X\(//\)$' \| \ X"$as_dir" : 'X\(/\)' \| . 2>/dev/null || $as_echo X"$as_dir" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q } /^X\(\/\/\)[^/].*/{ s//\1/ q } /^X\(\/\/\)$/{ s//\1/ q } /^X\(\/\).*/{ s//\1/ q } s/.*/./; q'` test -d "$as_dir" && break done test -z "$as_dirs" || eval "mkdir $as_dirs" } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir" } # as_fn_mkdir_p if mkdir -p . 2>/dev/null; then as_mkdir_p='mkdir -p "$as_dir"' else test -d ./-p && rmdir ./-p as_mkdir_p=false fi if test -x / >/dev/null 2>&1; then as_test_x='test -x' else if ls -dL / >/dev/null 2>&1; then as_ls_L_option=L else as_ls_L_option= fi as_test_x=' eval sh -c '\'' if test -d "$1"; then test -d "$1/."; else case $1 in #( -*)set "./$1";; esac; case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in #(( ???[sx]*):;;*)false;;esac;fi '\'' sh ' fi as_executable_p=$as_test_x # Sed expression to map a string onto a valid CPP name. as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'" # Sed expression to map a string onto a valid variable name. as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'" exec 6>&1 ## ----------------------------------- ## ## Main body of $CONFIG_STATUS script. ## ## ----------------------------------- ## _ASEOF test $as_write_fail = 0 && chmod +x $CONFIG_STATUS || ac_write_fail=1 cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 # Save the log message, to keep $0 and so on meaningful, and to # report actual input values of CONFIG_FILES etc. instead of their # values after options handling. ac_log=" This file was extended by ldns $as_me 1.6.17, which was generated by GNU Autoconf 2.68. Invocation command line was CONFIG_FILES = $CONFIG_FILES CONFIG_HEADERS = $CONFIG_HEADERS CONFIG_LINKS = $CONFIG_LINKS CONFIG_COMMANDS = $CONFIG_COMMANDS $ $0 $@ on `(hostname || uname -n) 2>/dev/null | sed 1q` " _ACEOF case $ac_config_files in *" "*) set x $ac_config_files; shift; ac_config_files=$*;; esac case $ac_config_headers in *" "*) set x $ac_config_headers; shift; ac_config_headers=$*;; esac cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 # Files that config.status was made for. config_files="$ac_config_files" config_headers="$ac_config_headers" _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 ac_cs_usage="\ \`$as_me' instantiates files and other configuration actions from templates according to the current configuration. Unless the files and actions are specified as TAGs, all are instantiated by default. Usage: $0 [OPTION]... [TAG]... -h, --help print this help, then exit -V, --version print version number and configuration settings, then exit --config print configuration, then exit -q, --quiet, --silent do not print progress messages -d, --debug don't remove temporary files --recheck update $as_me by reconfiguring in the same conditions --file=FILE[:TEMPLATE] instantiate the configuration file FILE --header=FILE[:TEMPLATE] instantiate the configuration header FILE Configuration files: $config_files Configuration headers: $config_headers Report bugs to ." _ACEOF cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`" ac_cs_version="\\ ldns config.status 1.6.17 configured by $0, generated by GNU Autoconf 2.68, with options \\"\$ac_cs_config\\" Copyright (C) 2010 Free Software Foundation, Inc. This config.status script is free software; the Free Software Foundation gives unlimited permission to copy, distribute and modify it." ac_pwd='$ac_pwd' srcdir='$srcdir' test -n "\$AWK" || AWK=awk _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 # The default lists apply if the user does not specify any file. ac_need_defaults=: while test $# != 0 do case $1 in --*=?*) ac_option=`expr "X$1" : 'X\([^=]*\)='` ac_optarg=`expr "X$1" : 'X[^=]*=\(.*\)'` ac_shift=: ;; --*=) ac_option=`expr "X$1" : 'X\([^=]*\)='` ac_optarg= ac_shift=: ;; *) ac_option=$1 ac_optarg=$2 ac_shift=shift ;; esac case $ac_option in # Handling of the options. -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r) ac_cs_recheck=: ;; --version | --versio | --versi | --vers | --ver | --ve | --v | -V ) $as_echo "$ac_cs_version"; exit ;; --config | --confi | --conf | --con | --co | --c ) $as_echo "$ac_cs_config"; exit ;; --debug | --debu | --deb | --de | --d | -d ) debug=: ;; --file | --fil | --fi | --f ) $ac_shift case $ac_optarg in *\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;; '') as_fn_error $? "missing file argument" ;; esac as_fn_append CONFIG_FILES " '$ac_optarg'" ac_need_defaults=false;; --header | --heade | --head | --hea ) $ac_shift case $ac_optarg in *\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;; esac as_fn_append CONFIG_HEADERS " '$ac_optarg'" ac_need_defaults=false;; --he | --h) # Conflict between --help and --header as_fn_error $? "ambiguous option: \`$1' Try \`$0 --help' for more information.";; --help | --hel | -h ) $as_echo "$ac_cs_usage"; exit ;; -q | -quiet | --quiet | --quie | --qui | --qu | --q \ | -silent | --silent | --silen | --sile | --sil | --si | --s) ac_cs_silent=: ;; # This is an error. -*) as_fn_error $? "unrecognized option: \`$1' Try \`$0 --help' for more information." ;; *) as_fn_append ac_config_targets " $1" ac_need_defaults=false ;; esac shift done ac_configure_extra_args= if $ac_cs_silent; then exec 6>/dev/null ac_configure_extra_args="$ac_configure_extra_args --silent" fi _ACEOF cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 if \$ac_cs_recheck; then set X '$SHELL' '$0' $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion shift \$as_echo "running CONFIG_SHELL=$SHELL \$*" >&6 CONFIG_SHELL='$SHELL' export CONFIG_SHELL exec "\$@" fi _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 exec 5>>config.log { echo sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX ## Running $as_me. ## _ASBOX $as_echo "$ac_log" } >&5 _ACEOF cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 # Handling of arguments. for ac_config_target in $ac_config_targets do case $ac_config_target in "Makefile") CONFIG_FILES="$CONFIG_FILES Makefile" ;; "drill.1") CONFIG_FILES="$CONFIG_FILES drill.1" ;; "config.h") CONFIG_HEADERS="$CONFIG_HEADERS config.h" ;; *) as_fn_error $? "invalid argument: \`$ac_config_target'" "$LINENO" 5;; esac done # If the user did not use the arguments to specify the items to instantiate, # then the envvar interface is used. Set only those that are not. # We use the long form for the default assignment because of an extremely # bizarre bug on SunOS 4.1.3. if $ac_need_defaults; then test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files test "${CONFIG_HEADERS+set}" = set || CONFIG_HEADERS=$config_headers fi # Have a temporary directory for convenience. Make it in the build tree # simply because there is no reason against having it here, and in addition, # creating and moving files from /tmp can sometimes cause problems. # Hook for its removal unless debugging. # Note that there is a small window in which the directory will not be cleaned: # after its creation but before its name has been assigned to `$tmp'. $debug || { tmp= ac_tmp= trap 'exit_status=$? : "${ac_tmp:=$tmp}" { test ! -d "$ac_tmp" || rm -fr "$ac_tmp"; } && exit $exit_status ' 0 trap 'as_fn_exit 1' 1 2 13 15 } # Create a (secure) tmp directory for tmp files. { tmp=`(umask 077 && mktemp -d "./confXXXXXX") 2>/dev/null` && test -d "$tmp" } || { tmp=./conf$$-$RANDOM (umask 077 && mkdir "$tmp") } || as_fn_error $? "cannot create a temporary directory in ." "$LINENO" 5 ac_tmp=$tmp # Set up the scripts for CONFIG_FILES section. # No need to generate them if there are no CONFIG_FILES. # This happens for instance with `./config.status config.h'. if test -n "$CONFIG_FILES"; then ac_cr=`echo X | tr X '\015'` # On cygwin, bash can eat \r inside `` if the user requested igncr. # But we know of no other shell where ac_cr would be empty at this # point, so we can use a bashism as a fallback. if test "x$ac_cr" = x; then eval ac_cr=\$\'\\r\' fi ac_cs_awk_cr=`$AWK 'BEGIN { print "a\rb" }' /dev/null` if test "$ac_cs_awk_cr" = "a${ac_cr}b"; then ac_cs_awk_cr='\\r' else ac_cs_awk_cr=$ac_cr fi echo 'BEGIN {' >"$ac_tmp/subs1.awk" && _ACEOF { echo "cat >conf$$subs.awk <<_ACEOF" && echo "$ac_subst_vars" | sed 's/.*/&!$&$ac_delim/' && echo "_ACEOF" } >conf$$subs.sh || as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5 ac_delim_num=`echo "$ac_subst_vars" | grep -c '^'` ac_delim='%!_!# ' for ac_last_try in false false false false false :; do . ./conf$$subs.sh || as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5 ac_delim_n=`sed -n "s/.*$ac_delim\$/X/p" conf$$subs.awk | grep -c X` if test $ac_delim_n = $ac_delim_num; then break elif $ac_last_try; then as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5 else ac_delim="$ac_delim!$ac_delim _$ac_delim!! " fi done rm -f conf$$subs.sh cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 cat >>"\$ac_tmp/subs1.awk" <<\\_ACAWK && _ACEOF sed -n ' h s/^/S["/; s/!.*/"]=/ p g s/^[^!]*!// :repl t repl s/'"$ac_delim"'$// t delim :nl h s/\(.\{148\}\)..*/\1/ t more1 s/["\\]/\\&/g; s/^/"/; s/$/\\n"\\/ p n b repl :more1 s/["\\]/\\&/g; s/^/"/; s/$/"\\/ p g s/.\{148\}// t nl :delim h s/\(.\{148\}\)..*/\1/ t more2 s/["\\]/\\&/g; s/^/"/; s/$/"/ p b :more2 s/["\\]/\\&/g; s/^/"/; s/$/"\\/ p g s/.\{148\}// t delim ' >$CONFIG_STATUS || ac_write_fail=1 rm -f conf$$subs.awk cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 _ACAWK cat >>"\$ac_tmp/subs1.awk" <<_ACAWK && for (key in S) S_is_set[key] = 1 FS = "" } { line = $ 0 nfields = split(line, field, "@") substed = 0 len = length(field[1]) for (i = 2; i < nfields; i++) { key = field[i] keylen = length(key) if (S_is_set[key]) { value = S[key] line = substr(line, 1, len) "" value "" substr(line, len + keylen + 3) len += length(value) + length(field[++i]) substed = 1 } else len += 1 + keylen } print line } _ACAWK _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 if sed "s/$ac_cr//" < /dev/null > /dev/null 2>&1; then sed "s/$ac_cr\$//; s/$ac_cr/$ac_cs_awk_cr/g" else cat fi < "$ac_tmp/subs1.awk" > "$ac_tmp/subs.awk" \ || as_fn_error $? "could not setup config files machinery" "$LINENO" 5 _ACEOF # VPATH may cause trouble with some makes, so we remove sole $(srcdir), # ${srcdir} and @srcdir@ entries from VPATH if srcdir is ".", strip leading and # trailing colons and then remove the whole line if VPATH becomes empty # (actually we leave an empty line to preserve line numbers). if test "x$srcdir" = x.; then ac_vpsub='/^[ ]*VPATH[ ]*=[ ]*/{ h s/// s/^/:/ s/[ ]*$/:/ s/:\$(srcdir):/:/g s/:\${srcdir}:/:/g s/:@srcdir@:/:/g s/^:*// s/:*$// x s/\(=[ ]*\).*/\1/ G s/\n// s/^[^=]*=[ ]*$// }' fi cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 fi # test -n "$CONFIG_FILES" # Set up the scripts for CONFIG_HEADERS section. # No need to generate them if there are no CONFIG_HEADERS. # This happens for instance with `./config.status Makefile'. if test -n "$CONFIG_HEADERS"; then cat >"$ac_tmp/defines.awk" <<\_ACAWK || BEGIN { _ACEOF # Transform confdefs.h into an awk script `defines.awk', embedded as # here-document in config.status, that substitutes the proper values into # config.h.in to produce config.h. # Create a delimiter string that does not exist in confdefs.h, to ease # handling of long lines. ac_delim='%!_!# ' for ac_last_try in false false :; do ac_tt=`sed -n "/$ac_delim/p" confdefs.h` if test -z "$ac_tt"; then break elif $ac_last_try; then as_fn_error $? "could not make $CONFIG_HEADERS" "$LINENO" 5 else ac_delim="$ac_delim!$ac_delim _$ac_delim!! " fi done # For the awk script, D is an array of macro values keyed by name, # likewise P contains macro parameters if any. Preserve backslash # newline sequences. ac_word_re=[_$as_cr_Letters][_$as_cr_alnum]* sed -n ' s/.\{148\}/&'"$ac_delim"'/g t rset :rset s/^[ ]*#[ ]*define[ ][ ]*/ / t def d :def s/\\$// t bsnl s/["\\]/\\&/g s/^ \('"$ac_word_re"'\)\(([^()]*)\)[ ]*\(.*\)/P["\1"]="\2"\ D["\1"]=" \3"/p s/^ \('"$ac_word_re"'\)[ ]*\(.*\)/D["\1"]=" \2"/p d :bsnl s/["\\]/\\&/g s/^ \('"$ac_word_re"'\)\(([^()]*)\)[ ]*\(.*\)/P["\1"]="\2"\ D["\1"]=" \3\\\\\\n"\\/p t cont s/^ \('"$ac_word_re"'\)[ ]*\(.*\)/D["\1"]=" \2\\\\\\n"\\/p t cont d :cont n s/.\{148\}/&'"$ac_delim"'/g t clear :clear s/\\$// t bsnlc s/["\\]/\\&/g; s/^/"/; s/$/"/p d :bsnlc s/["\\]/\\&/g; s/^/"/; s/$/\\\\\\n"\\/p b cont ' >$CONFIG_STATUS || ac_write_fail=1 cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 for (key in D) D_is_set[key] = 1 FS = "" } /^[\t ]*#[\t ]*(define|undef)[\t ]+$ac_word_re([\t (]|\$)/ { line = \$ 0 split(line, arg, " ") if (arg[1] == "#") { defundef = arg[2] mac1 = arg[3] } else { defundef = substr(arg[1], 2) mac1 = arg[2] } split(mac1, mac2, "(") #) macro = mac2[1] prefix = substr(line, 1, index(line, defundef) - 1) if (D_is_set[macro]) { # Preserve the white space surrounding the "#". print prefix "define", macro P[macro] D[macro] next } else { # Replace #undef with comments. This is necessary, for example, # in the case of _POSIX_SOURCE, which is predefined and required # on some systems where configure will not decide to define it. if (defundef == "undef") { print "/*", prefix defundef, macro, "*/" next } } } { print } _ACAWK _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 as_fn_error $? "could not setup config headers machinery" "$LINENO" 5 fi # test -n "$CONFIG_HEADERS" eval set X " :F $CONFIG_FILES :H $CONFIG_HEADERS " shift for ac_tag do case $ac_tag in :[FHLC]) ac_mode=$ac_tag; continue;; esac case $ac_mode$ac_tag in :[FHL]*:*);; :L* | :C*:*) as_fn_error $? "invalid tag \`$ac_tag'" "$LINENO" 5;; :[FH]-) ac_tag=-:-;; :[FH]*) ac_tag=$ac_tag:$ac_tag.in;; esac ac_save_IFS=$IFS IFS=: set x $ac_tag IFS=$ac_save_IFS shift ac_file=$1 shift case $ac_mode in :L) ac_source=$1;; :[FH]) ac_file_inputs= for ac_f do case $ac_f in -) ac_f="$ac_tmp/stdin";; *) # Look for the file first in the build tree, then in the source tree # (if the path is not absolute). The absolute path cannot be DOS-style, # because $ac_f cannot contain `:'. test -f "$ac_f" || case $ac_f in [\\/$]*) false;; *) test -f "$srcdir/$ac_f" && ac_f="$srcdir/$ac_f";; esac || as_fn_error 1 "cannot find input file: \`$ac_f'" "$LINENO" 5;; esac case $ac_f in *\'*) ac_f=`$as_echo "$ac_f" | sed "s/'/'\\\\\\\\''/g"`;; esac as_fn_append ac_file_inputs " '$ac_f'" done # Let's still pretend it is `configure' which instantiates (i.e., don't # use $as_me), people would be surprised to read: # /* config.h. Generated by config.status. */ configure_input='Generated from '` $as_echo "$*" | sed 's|^[^:]*/||;s|:[^:]*/|, |g' `' by configure.' if test x"$ac_file" != x-; then configure_input="$ac_file. $configure_input" { $as_echo "$as_me:${as_lineno-$LINENO}: creating $ac_file" >&5 $as_echo "$as_me: creating $ac_file" >&6;} fi # Neutralize special characters interpreted by sed in replacement strings. case $configure_input in #( *\&* | *\|* | *\\* ) ac_sed_conf_input=`$as_echo "$configure_input" | sed 's/[\\\\&|]/\\\\&/g'`;; #( *) ac_sed_conf_input=$configure_input;; esac case $ac_tag in *:-:* | *:-) cat >"$ac_tmp/stdin" \ || as_fn_error $? "could not create $ac_file" "$LINENO" 5 ;; esac ;; esac ac_dir=`$as_dirname -- "$ac_file" || $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$ac_file" : 'X\(//\)[^/]' \| \ X"$ac_file" : 'X\(//\)$' \| \ X"$ac_file" : 'X\(/\)' \| . 2>/dev/null || $as_echo X"$ac_file" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q } /^X\(\/\/\)[^/].*/{ s//\1/ q } /^X\(\/\/\)$/{ s//\1/ q } /^X\(\/\).*/{ s//\1/ q } s/.*/./; q'` as_dir="$ac_dir"; as_fn_mkdir_p ac_builddir=. case "$ac_dir" in .) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;; *) ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'` # A ".." for each directory in $ac_dir_suffix. ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'` case $ac_top_builddir_sub in "") ac_top_builddir_sub=. ac_top_build_prefix= ;; *) ac_top_build_prefix=$ac_top_builddir_sub/ ;; esac ;; esac ac_abs_top_builddir=$ac_pwd ac_abs_builddir=$ac_pwd$ac_dir_suffix # for backward compatibility: ac_top_builddir=$ac_top_build_prefix case $srcdir in .) # We are building in place. ac_srcdir=. ac_top_srcdir=$ac_top_builddir_sub ac_abs_top_srcdir=$ac_pwd ;; [\\/]* | ?:[\\/]* ) # Absolute name. ac_srcdir=$srcdir$ac_dir_suffix; ac_top_srcdir=$srcdir ac_abs_top_srcdir=$srcdir ;; *) # Relative name. ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix ac_top_srcdir=$ac_top_build_prefix$srcdir ac_abs_top_srcdir=$ac_pwd/$srcdir ;; esac ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix case $ac_mode in :F) # # CONFIG_FILE # _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 # If the template does not know about datarootdir, expand it. # FIXME: This hack should be removed a few years after 2.60. ac_datarootdir_hack=; ac_datarootdir_seen= ac_sed_dataroot=' /datarootdir/ { p q } /@datadir@/p /@docdir@/p /@infodir@/p /@localedir@/p /@mandir@/p' case `eval "sed -n \"\$ac_sed_dataroot\" $ac_file_inputs"` in *datarootdir*) ac_datarootdir_seen=yes;; *@datadir@*|*@docdir@*|*@infodir@*|*@localedir@*|*@mandir@*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&5 $as_echo "$as_me: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&2;} _ACEOF cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 ac_datarootdir_hack=' s&@datadir@&$datadir&g s&@docdir@&$docdir&g s&@infodir@&$infodir&g s&@localedir@&$localedir&g s&@mandir@&$mandir&g s&\\\${datarootdir}&$datarootdir&g' ;; esac _ACEOF # Neutralize VPATH when `$srcdir' = `.'. # Shell code in configure.ac might set extrasub. # FIXME: do we really want to maintain this feature? cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 ac_sed_extra="$ac_vpsub $extrasub _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 :t /@[a-zA-Z_][a-zA-Z_0-9]*@/!b s|@configure_input@|$ac_sed_conf_input|;t t s&@top_builddir@&$ac_top_builddir_sub&;t t s&@top_build_prefix@&$ac_top_build_prefix&;t t s&@srcdir@&$ac_srcdir&;t t s&@abs_srcdir@&$ac_abs_srcdir&;t t s&@top_srcdir@&$ac_top_srcdir&;t t s&@abs_top_srcdir@&$ac_abs_top_srcdir&;t t s&@builddir@&$ac_builddir&;t t s&@abs_builddir@&$ac_abs_builddir&;t t s&@abs_top_builddir@&$ac_abs_top_builddir&;t t $ac_datarootdir_hack " eval sed \"\$ac_sed_extra\" "$ac_file_inputs" | $AWK -f "$ac_tmp/subs.awk" \ >$ac_tmp/out || as_fn_error $? "could not create $ac_file" "$LINENO" 5 test -z "$ac_datarootdir_hack$ac_datarootdir_seen" && { ac_out=`sed -n '/\${datarootdir}/p' "$ac_tmp/out"`; test -n "$ac_out"; } && { ac_out=`sed -n '/^[ ]*datarootdir[ ]*:*=/p' \ "$ac_tmp/out"`; test -z "$ac_out"; } && { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file contains a reference to the variable \`datarootdir' which seems to be undefined. Please make sure it is defined" >&5 $as_echo "$as_me: WARNING: $ac_file contains a reference to the variable \`datarootdir' which seems to be undefined. Please make sure it is defined" >&2;} rm -f "$ac_tmp/stdin" case $ac_file in -) cat "$ac_tmp/out" && rm -f "$ac_tmp/out";; *) rm -f "$ac_file" && mv "$ac_tmp/out" "$ac_file";; esac \ || as_fn_error $? "could not create $ac_file" "$LINENO" 5 ;; :H) # # CONFIG_HEADER # if test x"$ac_file" != x-; then { $as_echo "/* $configure_input */" \ && eval '$AWK -f "$ac_tmp/defines.awk"' "$ac_file_inputs" } >"$ac_tmp/config.h" \ || as_fn_error $? "could not create $ac_file" "$LINENO" 5 if diff "$ac_file" "$ac_tmp/config.h" >/dev/null 2>&1; then { $as_echo "$as_me:${as_lineno-$LINENO}: $ac_file is unchanged" >&5 $as_echo "$as_me: $ac_file is unchanged" >&6;} else rm -f "$ac_file" mv "$ac_tmp/config.h" "$ac_file" \ || as_fn_error $? "could not create $ac_file" "$LINENO" 5 fi else $as_echo "/* $configure_input */" \ && eval '$AWK -f "$ac_tmp/defines.awk"' "$ac_file_inputs" \ || as_fn_error $? "could not create -" "$LINENO" 5 fi ;; esac done # for ac_tag as_fn_exit 0 _ACEOF ac_clean_files=$ac_clean_files_save test $ac_write_fail = 0 || as_fn_error $? "write failure creating $CONFIG_STATUS" "$LINENO" 5 # configure is writing to config.log, and then calls config.status. # config.status does its own redirection, appending to config.log. # Unfortunately, on DOS this fails, as config.log is still kept open # by configure, so config.status won't be able to write to it; its # output is simply discarded. So we exec the FD to /dev/null, # effectively closing config.log, so it can be properly (re)opened and # appended to by config.status. When coming back to configure, we # need to make the FD available again. if test "$no_create" != yes; then ac_cs_success=: ac_config_status_args= test "$silent" = yes && ac_config_status_args="$ac_config_status_args --quiet" exec 5>/dev/null $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false exec 5>>config.log # Use ||, not &&, to avoid exiting from the if with $? = 1, which # would make configure fail if this is the last instruction. $ac_cs_success || as_fn_exit 1 fi if test -n "$ac_unrecognized_opts" && test "$enable_option_checking" != no; then { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: unrecognized options: $ac_unrecognized_opts" >&5 $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2;} fi ldns-1.6.17/drill/root.c0000664000175100017510000001143312264060151014352 0ustar willemwillem/* * root.c * Function to handle to the rootservers * and to update and prime them * (c) 2005 NLnet Labs * * See the file LICENSE for the license * */ #include "drill.h" #include #include /* a global list of the root-servers */ ldns_rr_list *global_dns_root = NULL; /* put a hardcoded list in the root and * init the root rrlist structure */ void init_root(void) { ldns_rr *r; global_dns_root = ldns_rr_list_new(); (void)ldns_rr_new_frm_str(&r, "A.ROOT-SERVERS.NET. 3600000 A 198.41.0.4", 0, NULL, NULL); ldns_rr_list_push_rr(global_dns_root, r); (void)ldns_rr_new_frm_str(&r, "A.ROOT-SERVERS.NET. 3600000 AAAA 2001:503:BA3E::2:30", 0, NULL, NULL); ldns_rr_list_push_rr(global_dns_root, r); (void)ldns_rr_new_frm_str(&r, "B.ROOT-SERVERS.NET. 3600000 A 192.228.79.201", 0, NULL, NULL); ldns_rr_list_push_rr(global_dns_root, r); (void)ldns_rr_new_frm_str(&r, "C.ROOT-SERVERS.NET. 3600000 A 192.33.4.12", 0, NULL, NULL); ldns_rr_list_push_rr(global_dns_root, r); (void)ldns_rr_new_frm_str(&r, "D.ROOT-SERVERS.NET. 3600000 A 128.8.10.90", 0, NULL, NULL); ldns_rr_list_push_rr(global_dns_root, r); (void)ldns_rr_new_frm_str(&r, "E.ROOT-SERVERS.NET. 3600000 A 192.203.230.10", 0, NULL, NULL); ldns_rr_list_push_rr(global_dns_root, r); (void)ldns_rr_new_frm_str(&r, "F.ROOT-SERVERS.NET. 3600000 A 192.5.5.241", 0, NULL, NULL); ldns_rr_list_push_rr(global_dns_root, r); (void)ldns_rr_new_frm_str(&r, "F.ROOT-SERVERS.NET. 3600000 AAAA 2001:500:2F::F", 0, NULL, NULL); ldns_rr_list_push_rr(global_dns_root, r); (void)ldns_rr_new_frm_str(&r, "G.ROOT-SERVERS.NET. 3600000 A 192.112.36.4", 0, NULL, NULL); ldns_rr_list_push_rr(global_dns_root, r); (void)ldns_rr_new_frm_str(&r, "H.ROOT-SERVERS.NET. 3600000 A 128.63.2.53", 0, NULL, NULL); ldns_rr_list_push_rr(global_dns_root, r); (void)ldns_rr_new_frm_str(&r, "H.ROOT-SERVERS.NET. 3600000 AAAA 2001:500:1::803F:235", 0, NULL, NULL); ldns_rr_list_push_rr(global_dns_root, r); (void)ldns_rr_new_frm_str(&r, "I.ROOT-SERVERS.NET. 3600000 A 192.36.148.17", 0, NULL, NULL); ldns_rr_list_push_rr(global_dns_root, r); (void)ldns_rr_new_frm_str(&r, "J.ROOT-SERVERS.NET. 3600000 A 192.58.128.30", 0, NULL, NULL); ldns_rr_list_push_rr(global_dns_root, r); (void)ldns_rr_new_frm_str(&r, "J.ROOT-SERVERS.NET. 3600000 AAAA 2001:503:C27::2:30", 0, NULL, NULL); ldns_rr_list_push_rr(global_dns_root, r); (void)ldns_rr_new_frm_str(&r, "K.ROOT-SERVERS.NET. 3600000 A 193.0.14.129 ", 0, NULL, NULL); ldns_rr_list_push_rr(global_dns_root, r); (void)ldns_rr_new_frm_str(&r, "K.ROOT-SERVERS.NET. 3600000 AAAA 2001:7FD::1", 0, NULL, NULL); ldns_rr_list_push_rr(global_dns_root, r); (void)ldns_rr_new_frm_str(&r, "L.ROOT-SERVERS.NET. 3600000 A 199.7.83.42", 0, NULL, NULL); ldns_rr_list_push_rr(global_dns_root, r); (void)ldns_rr_new_frm_str(&r, "L.ROOT-SERVERS.NET. 3600000 AAAA 2001:500:3::42 ", 0, NULL, NULL); ldns_rr_list_push_rr(global_dns_root, r); (void)ldns_rr_new_frm_str(&r, "M.ROOT-SERVERS.NET. 3600000 A 202.12.27.33", 0, NULL, NULL); ldns_rr_list_push_rr(global_dns_root, r); (void)ldns_rr_new_frm_str(&r, "M.ROOT-SERVERS.NET. 3600000 AAAA 2001:DC3::35", 0, NULL, NULL); ldns_rr_list_push_rr(global_dns_root, r); } /* * Read a hints file as root * * The file with the given path should contain a list of NS RRs * for the root zone and A records for those NS RRs. * Read them, check them, and append the a records to the rr list given. */ ldns_rr_list * read_root_hints(const char *filename) { FILE *fp = NULL; int line_nr = 0; ldns_zone *z; ldns_status status; ldns_rr_list *addresses = NULL; ldns_rr *rr; size_t i; fp = fopen(filename, "r"); if (!fp) { fprintf(stderr, "Unable to open %s for reading: %s\n", filename, strerror(errno)); return NULL; } status = ldns_zone_new_frm_fp_l(&z, fp, NULL, 0, 0, &line_nr); fclose(fp); if (status != LDNS_STATUS_OK) { fprintf(stderr, "Error reading root hints file: %s\n", ldns_get_errorstr_by_id(status)); return NULL; } else { addresses = ldns_rr_list_new(); for (i = 0; i < ldns_rr_list_rr_count(ldns_zone_rrs(z)); i++) { rr = ldns_rr_list_rr(ldns_zone_rrs(z), i); /*if ((address_family == 0 || address_family == 1) && */ if ( ldns_rr_get_type(rr) == LDNS_RR_TYPE_A ) { ldns_rr_list_push_rr(addresses, ldns_rr_clone(rr)); } /*if ((address_family == 0 || address_family == 2) &&*/ if ( ldns_rr_get_type(rr) == LDNS_RR_TYPE_AAAA) { ldns_rr_list_push_rr(addresses, ldns_rr_clone(rr)); } } ldns_zone_deep_free(z); return addresses; } } void clear_root(void) { ldns_rr_list_deep_free(global_dns_root); } ldns-1.6.17/drill/README0000664000175100017510000000045612264060151014106 0ustar willemwillemQUICK INSTALL GUIDE drill is a subdirectory in ldns. To compile drill you need: autoreconf && ./configure && make If ldns is installed in a different location, use --with-ldns=directory See also ./configure --help In the first case you must run drill as: LD_LIBRARY_PATH=../.libs ./drill ldns-1.6.17/drill/drill.h0000664000175100017510000000517612264060151014511 0ustar willemwillem/* * drill.h * the main header file of drill * (c) 2005, 2006 NLnet Labs * * See the file LICENSE for the license * */ #ifndef _DRILL_H_ #define _DRILL_H_ #include "config.h" #include "drill_util.h" #define DRILL_VERSION PACKAGE_VERSION /* what kind of stuff do we allow */ #define DRILL_QUERY 0 #define DRILL_TRACE 1 #define DRILL_CHASE 2 #define DRILL_AFROMFILE 3 #define DRILL_QTOFILE 4 #define DRILL_NSEC 5 #define DRILL_REVERSE 6 #define DRILL_SECTRACE 7 #define DRILL_ON(VAR, BIT) \ (VAR) = (VAR) | (BIT) #define DRILL_OFF(VAR, BIT) \ (VAR) = (VAR) & ~(BIT) extern ldns_rr_list *global_dns_root; extern bool qds; extern int verbosity; ldns_pkt *do_trace(ldns_resolver *res, ldns_rdf *name, ldns_rr_type type, ldns_rr_class c); ldns_status do_chase(ldns_resolver *res, ldns_rdf *name, ldns_rr_type type, ldns_rr_class c, ldns_rr_list *trusted_keys, ldns_pkt *pkt_o, uint16_t qflags, ldns_rr_list *prev_key_list, int verbosity); int do_secure_trace(ldns_resolver *res, ldns_rdf *name, ldns_rr_type type, ldns_rr_class c, ldns_rr_list *trusted_keys, ldns_rdf *start_name); ldns_rr_list * get_rr(ldns_resolver *res, ldns_rdf *zname, ldns_rr_type t, ldns_rr_class c); void drill_pkt_print(FILE *fd, ldns_resolver *r, ldns_pkt *p); void drill_pkt_print_footer(FILE *fd, ldns_resolver *r, ldns_pkt *p); ldns_pkt_type get_dnssec_rr(ldns_pkt *p, ldns_rdf *name, ldns_rr_type t, ldns_rr_list **rrlist, ldns_rr_list **sig); ldns_rr *ldns_nsec3_exact_match(ldns_rdf *qname, ldns_rr_type qtype, ldns_rr_list *nsec3s); ldns_rdf *ldns_nsec3_closest_encloser(ldns_rdf *qname, ldns_rr_type qtype, ldns_rr_list *nsec3s); /* verifies denial of existence of *name in *pkt (must contain NSEC or NSEC3 records * if *nsec_rrs and *nsec_rr_sigs are given, pointers to the relevant nsecs and their signatures are * placed there */ ldns_status ldns_verify_denial(ldns_pkt *pkt, ldns_rdf *name, ldns_rr_type type, ldns_rr_list **nsec_rrs, ldns_rr_list **nsec_rr_sigs); ldns_pkt *read_hex_pkt(char *filename); ldns_buffer *read_hex_buffer(char *filename); void init_root(void); ldns_rr_list *read_root_hints(const char *filename); void clear_root(void); void dump_hex(const ldns_pkt *pkt, const char *file); void warning(const char *fmt, ...); void error(const char *fmt, ...); void mesg(const char *fmt, ...); /* screen.c */ void resolver_print_nameservers(ldns_resolver *r); void print_dnskey(ldns_rr_list *key_list); void print_ds(ldns_rr_list *ds_list); #endif /* _DRILL_H_ */ ldns-1.6.17/resolver.c0000664000175100017510000007632612264060151014136 0ustar willemwillem/* * resolver.c * * resolver implementation * * a Net::DNS like library for C * * (c) NLnet Labs, 2004-2006 * * See the file LICENSE for the license */ #include #include #include /* Access function for reading * and setting the different Resolver * options */ /* read */ uint16_t ldns_resolver_port(const ldns_resolver *r) { return r->_port; } ldns_rdf * ldns_resolver_source(const ldns_resolver *r) { return r->_source; } uint16_t ldns_resolver_edns_udp_size(const ldns_resolver *r) { return r->_edns_udp_size; } uint8_t ldns_resolver_retry(const ldns_resolver *r) { return r->_retry; } uint8_t ldns_resolver_retrans(const ldns_resolver *r) { return r->_retrans; } bool ldns_resolver_fallback(const ldns_resolver *r) { return r->_fallback; } uint8_t ldns_resolver_ip6(const ldns_resolver *r) { return r->_ip6; } bool ldns_resolver_recursive(const ldns_resolver *r) { return r->_recursive; } bool ldns_resolver_debug(const ldns_resolver *r) { return r->_debug; } bool ldns_resolver_dnsrch(const ldns_resolver *r) { return r->_dnsrch; } bool ldns_resolver_fail(const ldns_resolver *r) { return r->_fail; } bool ldns_resolver_defnames(const ldns_resolver *r) { return r->_defnames; } ldns_rdf * ldns_resolver_domain(const ldns_resolver *r) { return r->_domain; } ldns_rdf ** ldns_resolver_searchlist(const ldns_resolver *r) { return r->_searchlist; } ldns_rdf ** ldns_resolver_nameservers(const ldns_resolver *r) { return r->_nameservers; } size_t ldns_resolver_nameserver_count(const ldns_resolver *r) { return r->_nameserver_count; } bool ldns_resolver_dnssec(const ldns_resolver *r) { return r->_dnssec; } bool ldns_resolver_dnssec_cd(const ldns_resolver *r) { return r->_dnssec_cd; } ldns_rr_list * ldns_resolver_dnssec_anchors(const ldns_resolver *r) { return r->_dnssec_anchors; } bool ldns_resolver_trusted_key(const ldns_resolver *r, ldns_rr_list * keys, ldns_rr_list * trusted_keys) { size_t i; bool result = false; ldns_rr_list * trust_anchors; ldns_rr * cur_rr; if (!r || !keys) { return false; } trust_anchors = ldns_resolver_dnssec_anchors(r); if (!trust_anchors) { return false; } for (i = 0; i < ldns_rr_list_rr_count(keys); i++) { cur_rr = ldns_rr_list_rr(keys, i); if (ldns_rr_list_contains_rr(trust_anchors, cur_rr)) { if (trusted_keys) { ldns_rr_list_push_rr(trusted_keys, cur_rr); } result = true; } } return result; } bool ldns_resolver_igntc(const ldns_resolver *r) { return r->_igntc; } bool ldns_resolver_usevc(const ldns_resolver *r) { return r->_usevc; } size_t * ldns_resolver_rtt(const ldns_resolver *r) { return r->_rtt; } size_t ldns_resolver_nameserver_rtt(const ldns_resolver *r, size_t pos) { size_t *rtt; assert(r != NULL); rtt = ldns_resolver_rtt(r); if (pos >= ldns_resolver_nameserver_count(r)) { /* error ?*/ return 0; } else { return rtt[pos]; } } struct timeval ldns_resolver_timeout(const ldns_resolver *r) { return r->_timeout; } char * ldns_resolver_tsig_keyname(const ldns_resolver *r) { return r->_tsig_keyname; } char * ldns_resolver_tsig_algorithm(const ldns_resolver *r) { return r->_tsig_algorithm; } char * ldns_resolver_tsig_keydata(const ldns_resolver *r) { return r->_tsig_keydata; } bool ldns_resolver_random(const ldns_resolver *r) { return r->_random; } size_t ldns_resolver_searchlist_count(const ldns_resolver *r) { return r->_searchlist_count; } /* write */ void ldns_resolver_set_port(ldns_resolver *r, uint16_t p) { r->_port = p; } void ldns_resolver_set_source(ldns_resolver *r, ldns_rdf *s) { r->_source = s; } ldns_rdf * ldns_resolver_pop_nameserver(ldns_resolver *r) { ldns_rdf **nameservers; ldns_rdf *pop; size_t ns_count; size_t *rtt; assert(r != NULL); ns_count = ldns_resolver_nameserver_count(r); nameservers = ldns_resolver_nameservers(r); rtt = ldns_resolver_rtt(r); if (ns_count == 0 || !nameservers) { return NULL; } pop = nameservers[ns_count - 1]; if (ns_count == 1) { LDNS_FREE(nameservers); LDNS_FREE(rtt); ldns_resolver_set_nameservers(r, NULL); ldns_resolver_set_rtt(r, NULL); } else { nameservers = LDNS_XREALLOC(nameservers, ldns_rdf *, (ns_count - 1)); rtt = LDNS_XREALLOC(rtt, size_t, (ns_count - 1)); ldns_resolver_set_nameservers(r, nameservers); ldns_resolver_set_rtt(r, rtt); } /* decr the count */ ldns_resolver_dec_nameserver_count(r); return pop; } ldns_status ldns_resolver_push_nameserver(ldns_resolver *r, ldns_rdf *n) { ldns_rdf **nameservers; size_t ns_count; size_t *rtt; if (ldns_rdf_get_type(n) != LDNS_RDF_TYPE_A && ldns_rdf_get_type(n) != LDNS_RDF_TYPE_AAAA) { return LDNS_STATUS_ERR; } ns_count = ldns_resolver_nameserver_count(r); nameservers = ldns_resolver_nameservers(r); rtt = ldns_resolver_rtt(r); /* make room for the next one */ if (ns_count == 0) { nameservers = LDNS_XMALLOC(ldns_rdf *, 1); } else { nameservers = LDNS_XREALLOC(nameservers, ldns_rdf *, (ns_count + 1)); } if(!nameservers) return LDNS_STATUS_MEM_ERR; /* set the new value in the resolver */ ldns_resolver_set_nameservers(r, nameservers); /* don't forget the rtt */ if (ns_count == 0) { rtt = LDNS_XMALLOC(size_t, 1); } else { rtt = LDNS_XREALLOC(rtt, size_t, (ns_count + 1)); } if(!rtt) return LDNS_STATUS_MEM_ERR; /* slide n in its slot. */ /* we clone it here, because then we can free the original * rr's where it stood */ nameservers[ns_count] = ldns_rdf_clone(n); rtt[ns_count] = LDNS_RESOLV_RTT_MIN; ldns_resolver_incr_nameserver_count(r); ldns_resolver_set_rtt(r, rtt); return LDNS_STATUS_OK; } ldns_status ldns_resolver_push_nameserver_rr(ldns_resolver *r, ldns_rr *rr) { ldns_rdf *address; if ((!rr) || (ldns_rr_get_type(rr) != LDNS_RR_TYPE_A && ldns_rr_get_type(rr) != LDNS_RR_TYPE_AAAA)) { return LDNS_STATUS_ERR; } address = ldns_rr_rdf(rr, 0); /* extract the ip number */ if (address) { return ldns_resolver_push_nameserver(r, address); } else { return LDNS_STATUS_ERR; } } ldns_status ldns_resolver_push_nameserver_rr_list(ldns_resolver *r, ldns_rr_list *rrlist) { ldns_rr *rr; ldns_status stat; size_t i; stat = LDNS_STATUS_OK; if (rrlist) { for(i = 0; i < ldns_rr_list_rr_count(rrlist); i++) { rr = ldns_rr_list_rr(rrlist, i); if (ldns_resolver_push_nameserver_rr(r, rr) != LDNS_STATUS_OK) { stat = LDNS_STATUS_ERR; break; } } return stat; } else { return LDNS_STATUS_ERR; } } void ldns_resolver_set_edns_udp_size(ldns_resolver *r, uint16_t s) { r->_edns_udp_size = s; } void ldns_resolver_set_recursive(ldns_resolver *r, bool re) { r->_recursive = re; } void ldns_resolver_set_dnssec(ldns_resolver *r, bool d) { r->_dnssec = d; } void ldns_resolver_set_dnssec_cd(ldns_resolver *r, bool d) { r->_dnssec_cd = d; } void ldns_resolver_set_dnssec_anchors(ldns_resolver *r, ldns_rr_list * l) { r->_dnssec_anchors = l; } ldns_status ldns_resolver_push_dnssec_anchor(ldns_resolver *r, ldns_rr *rr) { ldns_rr_list * trust_anchors; if ((!rr) || (ldns_rr_get_type(rr) != LDNS_RR_TYPE_DNSKEY && ldns_rr_get_type(rr) != LDNS_RR_TYPE_DS)) { return LDNS_STATUS_ERR; } if (!(trust_anchors = ldns_resolver_dnssec_anchors(r))) { /* Initialize */ trust_anchors = ldns_rr_list_new(); ldns_resolver_set_dnssec_anchors(r, trust_anchors); } return (ldns_rr_list_push_rr(trust_anchors, ldns_rr_clone(rr))) ? LDNS_STATUS_OK : LDNS_STATUS_ERR; } void ldns_resolver_set_igntc(ldns_resolver *r, bool i) { r->_igntc = i; } void ldns_resolver_set_usevc(ldns_resolver *r, bool vc) { r->_usevc = vc; } void ldns_resolver_set_debug(ldns_resolver *r, bool d) { r->_debug = d; } void ldns_resolver_set_ip6(ldns_resolver *r, uint8_t ip6) { r->_ip6 = ip6; } void ldns_resolver_set_fail(ldns_resolver *r, bool f) { r->_fail =f; } static void ldns_resolver_set_searchlist_count(ldns_resolver *r, size_t c) { r->_searchlist_count = c; } void ldns_resolver_set_nameserver_count(ldns_resolver *r, size_t c) { r->_nameserver_count = c; } void ldns_resolver_set_dnsrch(ldns_resolver *r, bool d) { r->_dnsrch = d; } void ldns_resolver_set_retry(ldns_resolver *r, uint8_t retry) { r->_retry = retry; } void ldns_resolver_set_retrans(ldns_resolver *r, uint8_t retrans) { r->_retrans = retrans; } void ldns_resolver_set_fallback(ldns_resolver *r, bool fallback) { r->_fallback = fallback; } void ldns_resolver_set_nameservers(ldns_resolver *r, ldns_rdf **n) { r->_nameservers = n; } void ldns_resolver_set_defnames(ldns_resolver *r, bool d) { r->_defnames = d; } void ldns_resolver_set_rtt(ldns_resolver *r, size_t *rtt) { r->_rtt = rtt; } void ldns_resolver_set_nameserver_rtt(ldns_resolver *r, size_t pos, size_t value) { size_t *rtt; assert(r != NULL); rtt = ldns_resolver_rtt(r); if (pos >= ldns_resolver_nameserver_count(r)) { /* error ?*/ } else { rtt[pos] = value; } } void ldns_resolver_incr_nameserver_count(ldns_resolver *r) { size_t c; c = ldns_resolver_nameserver_count(r); ldns_resolver_set_nameserver_count(r, ++c); } void ldns_resolver_dec_nameserver_count(ldns_resolver *r) { size_t c; c = ldns_resolver_nameserver_count(r); if (c == 0) { return; } else { ldns_resolver_set_nameserver_count(r, --c); } } void ldns_resolver_set_domain(ldns_resolver *r, ldns_rdf *d) { r->_domain = d; } void ldns_resolver_set_timeout(ldns_resolver *r, struct timeval timeout) { r->_timeout.tv_sec = timeout.tv_sec; r->_timeout.tv_usec = timeout.tv_usec; } void ldns_resolver_push_searchlist(ldns_resolver *r, ldns_rdf *d) { ldns_rdf **searchlist; size_t list_count; if (ldns_rdf_get_type(d) != LDNS_RDF_TYPE_DNAME) { return; } list_count = ldns_resolver_searchlist_count(r); searchlist = ldns_resolver_searchlist(r); searchlist = LDNS_XREALLOC(searchlist, ldns_rdf *, (list_count + 1)); if (searchlist) { r->_searchlist = searchlist; searchlist[list_count] = ldns_rdf_clone(d); ldns_resolver_set_searchlist_count(r, list_count + 1); } /* no way to report mem err */ } void ldns_resolver_set_tsig_keyname(ldns_resolver *r, char *tsig_keyname) { LDNS_FREE(r->_tsig_keyname); r->_tsig_keyname = strdup(tsig_keyname); } void ldns_resolver_set_tsig_algorithm(ldns_resolver *r, char *tsig_algorithm) { LDNS_FREE(r->_tsig_algorithm); r->_tsig_algorithm = strdup(tsig_algorithm); } void ldns_resolver_set_tsig_keydata(ldns_resolver *r, char *tsig_keydata) { LDNS_FREE(r->_tsig_keydata); r->_tsig_keydata = strdup(tsig_keydata); } void ldns_resolver_set_random(ldns_resolver *r, bool b) { r->_random = b; } /* more sophisticated functions */ ldns_resolver * ldns_resolver_new(void) { ldns_resolver *r; r = LDNS_MALLOC(ldns_resolver); if (!r) { return NULL; } r->_searchlist = NULL; r->_nameservers = NULL; r->_rtt = NULL; /* defaults are filled out */ ldns_resolver_set_searchlist_count(r, 0); ldns_resolver_set_nameserver_count(r, 0); ldns_resolver_set_usevc(r, 0); ldns_resolver_set_port(r, LDNS_PORT); ldns_resolver_set_domain(r, NULL); ldns_resolver_set_defnames(r, false); ldns_resolver_set_retry(r, 3); ldns_resolver_set_retrans(r, 2); ldns_resolver_set_fallback(r, true); ldns_resolver_set_fail(r, false); ldns_resolver_set_edns_udp_size(r, 0); ldns_resolver_set_dnssec(r, false); ldns_resolver_set_dnssec_cd(r, false); ldns_resolver_set_dnssec_anchors(r, NULL); ldns_resolver_set_ip6(r, LDNS_RESOLV_INETANY); ldns_resolver_set_igntc(r, false); ldns_resolver_set_recursive(r, false); ldns_resolver_set_dnsrch(r, true); ldns_resolver_set_source(r, NULL); /* randomize the nameserver to be queried * when there are multiple */ ldns_resolver_set_random(r, true); ldns_resolver_set_debug(r, 0); r->_timeout.tv_sec = LDNS_DEFAULT_TIMEOUT_SEC; r->_timeout.tv_usec = LDNS_DEFAULT_TIMEOUT_USEC; /* TODO: fd=0 is actually a valid socket (stdin), replace with -1 */ r->_socket = 0; r->_axfr_soa_count = 0; r->_axfr_i = 0; r->_cur_axfr_pkt = NULL; r->_tsig_keyname = NULL; r->_tsig_keydata = NULL; r->_tsig_algorithm = NULL; return r; } ldns_status ldns_resolver_new_frm_fp(ldns_resolver **res, FILE *fp) { return ldns_resolver_new_frm_fp_l(res, fp, NULL); } ldns_status ldns_resolver_new_frm_fp_l(ldns_resolver **res, FILE *fp, int *line_nr) { ldns_resolver *r; const char *keyword[LDNS_RESOLV_KEYWORDS]; char word[LDNS_MAX_LINELEN + 1]; int8_t expect; uint8_t i; ldns_rdf *tmp; #ifdef HAVE_SSL ldns_rr *tmp_rr; #endif ssize_t gtr, bgtr; ldns_buffer *b; int lnr = 0, oldline; FILE* myfp = fp; if(!line_nr) line_nr = &lnr; if(!fp) { myfp = fopen("/etc/resolv.conf", "r"); if(!myfp) return LDNS_STATUS_FILE_ERR; } /* do this better * expect = * 0: keyword * 1: default domain dname * 2: NS aaaa or a record */ /* recognized keywords */ keyword[LDNS_RESOLV_NAMESERVER] = "nameserver"; keyword[LDNS_RESOLV_DEFDOMAIN] = "domain"; keyword[LDNS_RESOLV_SEARCH] = "search"; /* these two are read but not used atm TODO */ keyword[LDNS_RESOLV_SORTLIST] = "sortlist"; keyword[LDNS_RESOLV_OPTIONS] = "options"; keyword[LDNS_RESOLV_ANCHOR] = "anchor"; expect = LDNS_RESOLV_KEYWORD; r = ldns_resolver_new(); if (!r) { if(!fp) fclose(myfp); return LDNS_STATUS_MEM_ERR; } gtr = 1; word[0] = 0; oldline = *line_nr; expect = LDNS_RESOLV_KEYWORD; while (gtr > 0) { /* check comments */ if (word[0] == '#') { word[0]='x'; if(oldline == *line_nr) { /* skip until end of line */ int c; do { c = fgetc(myfp); } while(c != EOF && c != '\n'); if(c=='\n') (*line_nr)++; } /* and read next to prepare for further parsing */ oldline = *line_nr; continue; } oldline = *line_nr; switch(expect) { case LDNS_RESOLV_KEYWORD: /* keyword */ gtr = ldns_fget_token_l(myfp, word, LDNS_PARSE_NORMAL, 0, line_nr); if (gtr != 0) { if(word[0] == '#') continue; for(i = 0; i < LDNS_RESOLV_KEYWORDS; i++) { if (strcasecmp(keyword[i], word) == 0) { /* chosen the keyword and * expect values carefully */ expect = i; break; } } /* no keyword recognized */ if (expect == LDNS_RESOLV_KEYWORD) { /* skip line */ /* ldns_resolver_deep_free(r); if(!fp) fclose(myfp); return LDNS_STATUS_SYNTAX_KEYWORD_ERR; */ } } break; case LDNS_RESOLV_DEFDOMAIN: /* default domain dname */ gtr = ldns_fget_token_l(myfp, word, LDNS_PARSE_NORMAL, 0, line_nr); if (gtr == 0) { if(!fp) fclose(myfp); return LDNS_STATUS_SYNTAX_MISSING_VALUE_ERR; } if(word[0] == '#') { expect = LDNS_RESOLV_KEYWORD; continue; } tmp = ldns_rdf_new_frm_str(LDNS_RDF_TYPE_DNAME, word); if (!tmp) { ldns_resolver_deep_free(r); if(!fp) fclose(myfp); return LDNS_STATUS_SYNTAX_DNAME_ERR; } /* DOn't free, because we copy the pointer */ ldns_resolver_set_domain(r, tmp); expect = LDNS_RESOLV_KEYWORD; break; case LDNS_RESOLV_NAMESERVER: /* NS aaaa or a record */ gtr = ldns_fget_token_l(myfp, word, LDNS_PARSE_NORMAL, 0, line_nr); if (gtr == 0) { if(!fp) fclose(myfp); return LDNS_STATUS_SYNTAX_MISSING_VALUE_ERR; } if(word[0] == '#') { expect = LDNS_RESOLV_KEYWORD; continue; } if(strchr(word, '%')) { /* snip off interface labels, * fe80::222:19ff:fe31:4222%eth0 */ strchr(word, '%')[0]=0; } tmp = ldns_rdf_new_frm_str(LDNS_RDF_TYPE_AAAA, word); if (!tmp) { /* try ip4 */ tmp = ldns_rdf_new_frm_str(LDNS_RDF_TYPE_A, word); } /* could not parse it, exit */ if (!tmp) { ldns_resolver_deep_free(r); if(!fp) fclose(myfp); return LDNS_STATUS_SYNTAX_ERR; } (void)ldns_resolver_push_nameserver(r, tmp); ldns_rdf_deep_free(tmp); expect = LDNS_RESOLV_KEYWORD; break; case LDNS_RESOLV_SEARCH: /* search list domain dname */ gtr = ldns_fget_token_l(myfp, word, LDNS_PARSE_SKIP_SPACE, 0, line_nr); b = LDNS_MALLOC(ldns_buffer); if(!b) { ldns_resolver_deep_free(r); if(!fp) fclose(myfp); return LDNS_STATUS_MEM_ERR; } ldns_buffer_new_frm_data(b, word, (size_t) gtr); if(ldns_buffer_status(b) != LDNS_STATUS_OK) { LDNS_FREE(b); ldns_resolver_deep_free(r); if(!fp) fclose(myfp); return LDNS_STATUS_MEM_ERR; } bgtr = ldns_bget_token(b, word, LDNS_PARSE_NORMAL, (size_t) gtr + 1); while (bgtr > 0) { gtr -= bgtr; if(word[0] == '#') { expect = LDNS_RESOLV_KEYWORD; break; } tmp = ldns_rdf_new_frm_str(LDNS_RDF_TYPE_DNAME, word); if (!tmp) { ldns_resolver_deep_free(r); ldns_buffer_free(b); if(!fp) fclose(myfp); return LDNS_STATUS_SYNTAX_DNAME_ERR; } ldns_resolver_push_searchlist(r, tmp); ldns_rdf_deep_free(tmp); bgtr = ldns_bget_token(b, word, LDNS_PARSE_NORMAL, (size_t) gtr + 1); } ldns_buffer_free(b); if (expect != LDNS_RESOLV_KEYWORD) { gtr = 1; expect = LDNS_RESOLV_KEYWORD; } break; case LDNS_RESOLV_SORTLIST: gtr = ldns_fget_token_l(myfp, word, LDNS_PARSE_SKIP_SPACE, 0, line_nr); /* sortlist not implemented atm */ expect = LDNS_RESOLV_KEYWORD; break; case LDNS_RESOLV_OPTIONS: gtr = ldns_fget_token_l(myfp, word, LDNS_PARSE_SKIP_SPACE, 0, line_nr); /* options not implemented atm */ expect = LDNS_RESOLV_KEYWORD; break; case LDNS_RESOLV_ANCHOR: /* a file containing a DNSSEC trust anchor */ gtr = ldns_fget_token_l(myfp, word, LDNS_PARSE_NORMAL, 0, line_nr); if (gtr == 0) { ldns_resolver_deep_free(r); if(!fp) fclose(myfp); return LDNS_STATUS_SYNTAX_MISSING_VALUE_ERR; } if(word[0] == '#') { expect = LDNS_RESOLV_KEYWORD; continue; } #ifdef HAVE_SSL tmp_rr = ldns_read_anchor_file(word); (void) ldns_resolver_push_dnssec_anchor(r, tmp_rr); ldns_rr_free(tmp_rr); #endif expect = LDNS_RESOLV_KEYWORD; break; } } if(!fp) fclose(myfp); if (res) { *res = r; return LDNS_STATUS_OK; } else { ldns_resolver_deep_free(r); return LDNS_STATUS_NULL; } } ldns_status ldns_resolver_new_frm_file(ldns_resolver **res, const char *filename) { ldns_resolver *r; FILE *fp; ldns_status s; if (!filename) { fp = fopen(LDNS_RESOLV_CONF, "r"); } else { fp = fopen(filename, "r"); } if (!fp) { return LDNS_STATUS_FILE_ERR; } s = ldns_resolver_new_frm_fp(&r, fp); fclose(fp); if (s == LDNS_STATUS_OK) { if (res) { *res = r; return LDNS_STATUS_OK; } else { ldns_resolver_free(r); return LDNS_STATUS_NULL; } } return s; } void ldns_resolver_free(ldns_resolver *res) { LDNS_FREE(res); } void ldns_resolver_deep_free(ldns_resolver *res) { size_t i; if (res) { if (res->_searchlist) { for (i = 0; i < ldns_resolver_searchlist_count(res); i++) { ldns_rdf_deep_free(res->_searchlist[i]); } LDNS_FREE(res->_searchlist); } if (res->_nameservers) { for (i = 0; i < res->_nameserver_count; i++) { ldns_rdf_deep_free(res->_nameservers[i]); } LDNS_FREE(res->_nameservers); } if (ldns_resolver_domain(res)) { ldns_rdf_deep_free(ldns_resolver_domain(res)); } if (res->_tsig_keyname) { LDNS_FREE(res->_tsig_keyname); } if (res->_tsig_keydata) { LDNS_FREE(res->_tsig_keydata); } if (res->_tsig_algorithm) { LDNS_FREE(res->_tsig_algorithm); } if (res->_cur_axfr_pkt) { ldns_pkt_free(res->_cur_axfr_pkt); } if (res->_rtt) { LDNS_FREE(res->_rtt); } if (res->_dnssec_anchors) { ldns_rr_list_deep_free(res->_dnssec_anchors); } LDNS_FREE(res); } } ldns_status ldns_resolver_search_status(ldns_pkt** pkt, ldns_resolver *r, const ldns_rdf *name, ldns_rr_type t, ldns_rr_class c, uint16_t flags) { ldns_rdf *new_name; ldns_rdf **search_list; size_t i; ldns_status s = LDNS_STATUS_OK; if (ldns_dname_absolute(name)) { /* query as-is */ return ldns_resolver_query_status(pkt, r, name, t, c, flags); } else if (ldns_resolver_dnsrch(r)) { search_list = ldns_resolver_searchlist(r); for (i = 0; i < ldns_resolver_searchlist_count(r); i++) { new_name = ldns_dname_cat_clone(name, search_list[i]); s = ldns_resolver_query_status(pkt, r, new_name, t, c, flags); ldns_rdf_free(new_name); if (pkt) { if (s == LDNS_STATUS_OK && *pkt && ldns_pkt_get_rcode(*pkt) == LDNS_RCODE_NOERROR) { return LDNS_STATUS_OK; } ldns_pkt_free(*pkt); } } } return s; } ldns_pkt * ldns_resolver_search(const ldns_resolver *r,const ldns_rdf *name, ldns_rr_type t, ldns_rr_class c, uint16_t flags) { ldns_pkt* pkt = NULL; if (ldns_resolver_search_status(&pkt, (ldns_resolver *)r, name, t, c, flags) != LDNS_STATUS_OK) { ldns_pkt_free(pkt); } return pkt; } ldns_status ldns_resolver_query_status(ldns_pkt** pkt, ldns_resolver *r, const ldns_rdf *name, ldns_rr_type t, ldns_rr_class c, uint16_t flags) { ldns_rdf *newname; ldns_status status; if (!ldns_resolver_defnames(r) || !ldns_resolver_domain(r)) { return ldns_resolver_send(pkt, r, name, t, c, flags); } newname = ldns_dname_cat_clone(name, ldns_resolver_domain(r)); if (!newname) { return LDNS_STATUS_MEM_ERR; } status = ldns_resolver_send(pkt, r, newname, t, c, flags); ldns_rdf_free(newname); return status; } ldns_pkt * ldns_resolver_query(const ldns_resolver *r, const ldns_rdf *name, ldns_rr_type t, ldns_rr_class c, uint16_t flags) { ldns_pkt* pkt = NULL; if (ldns_resolver_query_status(&pkt, (ldns_resolver *)r, name, t, c, flags) != LDNS_STATUS_OK) { ldns_pkt_free(pkt); } return pkt; } static size_t * ldns_resolver_backup_rtt(ldns_resolver *r) { size_t *new_rtt; size_t *old_rtt = ldns_resolver_rtt(r); if (old_rtt && ldns_resolver_nameserver_count(r)) { new_rtt = LDNS_XMALLOC(size_t , ldns_resolver_nameserver_count(r)); memcpy(new_rtt, old_rtt, sizeof(size_t) * ldns_resolver_nameserver_count(r)); ldns_resolver_set_rtt(r, new_rtt); return old_rtt; } return NULL; } static void ldns_resolver_restore_rtt(ldns_resolver *r, size_t *old_rtt) { size_t *cur_rtt = ldns_resolver_rtt(r); if (cur_rtt) { LDNS_FREE(cur_rtt); } ldns_resolver_set_rtt(r, old_rtt); } ldns_status ldns_resolver_send_pkt(ldns_pkt **answer, ldns_resolver *r, ldns_pkt *query_pkt) { ldns_pkt *answer_pkt = NULL; ldns_status stat = LDNS_STATUS_OK; size_t *rtt; stat = ldns_send(&answer_pkt, (ldns_resolver *)r, query_pkt); if (stat != LDNS_STATUS_OK) { if(answer_pkt) { ldns_pkt_free(answer_pkt); answer_pkt = NULL; } } else { /* if tc=1 fall back to EDNS and/or TCP */ /* check for tcp first (otherwise we don't care about tc=1) */ if (!ldns_resolver_usevc(r) && ldns_resolver_fallback(r)) { if (ldns_pkt_tc(answer_pkt)) { /* was EDNS0 set? */ if (ldns_pkt_edns_udp_size(query_pkt) == 0) { ldns_pkt_set_edns_udp_size(query_pkt , 4096); ldns_pkt_free(answer_pkt); /* Nameservers should not become * unreachable because fragments are * dropped (network error). We might * still have success with TCP. * Therefore maintain reachability * statuses of the nameservers by * backup and restore the rtt list. */ rtt = ldns_resolver_backup_rtt(r); stat = ldns_send(&answer_pkt, r , query_pkt); ldns_resolver_restore_rtt(r, rtt); } /* either way, if it is still truncated, use TCP */ if (stat != LDNS_STATUS_OK || ldns_pkt_tc(answer_pkt)) { ldns_resolver_set_usevc(r, true); ldns_pkt_free(answer_pkt); stat = ldns_send(&answer_pkt, r, query_pkt); ldns_resolver_set_usevc(r, false); } } } } if (answer) { *answer = answer_pkt; } return stat; } ldns_status ldns_resolver_prepare_query_pkt(ldns_pkt **query_pkt, ldns_resolver *r, const ldns_rdf *name, ldns_rr_type t, ldns_rr_class c, uint16_t flags) { struct timeval now; /* prepare a question pkt from the parameters * and then send this */ if (t == LDNS_RR_TYPE_IXFR) { *query_pkt = ldns_pkt_ixfr_request_new(ldns_rdf_clone(name), c, flags, NULL); } else { *query_pkt = ldns_pkt_query_new(ldns_rdf_clone(name), t, c, flags); } if (!*query_pkt) { return LDNS_STATUS_ERR; } /* set DO bit if necessary */ if (ldns_resolver_dnssec(r)) { if (ldns_resolver_edns_udp_size(r) == 0) { ldns_resolver_set_edns_udp_size(r, 4096); } ldns_pkt_set_edns_do(*query_pkt, true); if (ldns_resolver_dnssec_cd(r) || (flags & LDNS_CD)) { ldns_pkt_set_cd(*query_pkt, true); } } /* transfer the udp_edns_size from the resolver to the packet */ if (ldns_resolver_edns_udp_size(r) != 0) { ldns_pkt_set_edns_udp_size(*query_pkt, ldns_resolver_edns_udp_size(r)); } /* set the timestamp */ now.tv_sec = time(NULL); now.tv_usec = 0; ldns_pkt_set_timestamp(*query_pkt, now); if (ldns_resolver_debug(r)) { ldns_pkt_print(stdout, *query_pkt); } /* only set the id if it is not set yet */ if (ldns_pkt_id(*query_pkt) == 0) { ldns_pkt_set_random_id(*query_pkt); } return LDNS_STATUS_OK; } ldns_status ldns_resolver_send(ldns_pkt **answer, ldns_resolver *r, const ldns_rdf *name, ldns_rr_type t, ldns_rr_class c, uint16_t flags) { ldns_pkt *query_pkt; ldns_pkt *answer_pkt; ldns_status status; assert(r != NULL); assert(name != NULL); answer_pkt = NULL; /* do all the preprocessing here, then fire of an query to * the network */ if (0 == t) { t= LDNS_RR_TYPE_A; } if (0 == c) { c= LDNS_RR_CLASS_IN; } if (0 == ldns_resolver_nameserver_count(r)) { return LDNS_STATUS_RES_NO_NS; } if (ldns_rdf_get_type(name) != LDNS_RDF_TYPE_DNAME) { return LDNS_STATUS_RES_QUERY; } status = ldns_resolver_prepare_query_pkt(&query_pkt, r, name, t, c, flags); if (status != LDNS_STATUS_OK) { return status; } /* if tsig values are set, tsign it */ /* TODO: make last 3 arguments optional too? maybe make complete rr instead of separate values in resolver (and packet) Jelte should this go in pkt_prepare? */ if (ldns_resolver_tsig_keyname(r) && ldns_resolver_tsig_keydata(r)) { #ifdef HAVE_SSL status = ldns_pkt_tsig_sign(query_pkt, ldns_resolver_tsig_keyname(r), ldns_resolver_tsig_keydata(r), 300, ldns_resolver_tsig_algorithm(r), NULL); if (status != LDNS_STATUS_OK) { ldns_pkt_free(query_pkt); return LDNS_STATUS_CRYPTO_TSIG_ERR; } #else ldns_pkt_free(query_pkt); return LDNS_STATUS_CRYPTO_TSIG_ERR; #endif /* HAVE_SSL */ } status = ldns_resolver_send_pkt(&answer_pkt, r, query_pkt); ldns_pkt_free(query_pkt); /* allows answer to be NULL when not interested in return value */ if (answer) { *answer = answer_pkt; } return status; } ldns_rr * ldns_axfr_next(ldns_resolver *resolver) { ldns_rr *cur_rr; uint8_t *packet_wire; size_t packet_wire_size; ldns_lookup_table *rcode; ldns_status status; /* check if start() has been called */ if (!resolver || resolver->_socket == 0) { return NULL; } if (resolver->_cur_axfr_pkt) { if (resolver->_axfr_i == ldns_pkt_ancount(resolver->_cur_axfr_pkt)) { ldns_pkt_free(resolver->_cur_axfr_pkt); resolver->_cur_axfr_pkt = NULL; return ldns_axfr_next(resolver); } cur_rr = ldns_rr_clone(ldns_rr_list_rr( ldns_pkt_answer(resolver->_cur_axfr_pkt), resolver->_axfr_i)); resolver->_axfr_i++; if (ldns_rr_get_type(cur_rr) == LDNS_RR_TYPE_SOA) { resolver->_axfr_soa_count++; if (resolver->_axfr_soa_count >= 2) { #ifndef USE_WINSOCK close(resolver->_socket); #else closesocket(resolver->_socket); #endif resolver->_socket = 0; ldns_pkt_free(resolver->_cur_axfr_pkt); resolver->_cur_axfr_pkt = NULL; } } return cur_rr; } else { packet_wire = ldns_tcp_read_wire(resolver->_socket, &packet_wire_size); if(!packet_wire) return NULL; status = ldns_wire2pkt(&resolver->_cur_axfr_pkt, packet_wire, packet_wire_size); LDNS_FREE(packet_wire); resolver->_axfr_i = 0; if (status != LDNS_STATUS_OK) { /* TODO: make status return type of this function (...api change) */ #ifdef STDERR_MSGS fprintf(stderr, "Error parsing rr during AXFR: %s\n", ldns_get_errorstr_by_id(status)); #endif /* we must now also close the socket, otherwise subsequent uses of the same resolver structure will fail because the link is still open or in an undefined state */ #ifndef USE_WINSOCK close(resolver->_socket); #else closesocket(resolver->_socket); #endif resolver->_socket = 0; return NULL; } else if (ldns_pkt_get_rcode(resolver->_cur_axfr_pkt) != 0) { rcode = ldns_lookup_by_id(ldns_rcodes, (int) ldns_pkt_get_rcode(resolver->_cur_axfr_pkt)); #ifdef STDERR_MSGS if (rcode) { fprintf(stderr, "Error in AXFR: %s\n", rcode->name); } else { fprintf(stderr, "Error in AXFR: %d\n", (int) ldns_pkt_get_rcode( resolver->_cur_axfr_pkt)); } #endif /* we must now also close the socket, otherwise subsequent uses of the same resolver structure will fail because the link is still open or in an undefined state */ #ifndef USE_WINSOCK close(resolver->_socket); #else closesocket(resolver->_socket); #endif resolver->_socket = 0; return NULL; } else { return ldns_axfr_next(resolver); } } } /* this function is needed to abort a transfer that is in progress; * without it an aborted transfer will lead to the AXFR code in the * library staying in an indetermined state because the socket for the * AXFR is never closed */ void ldns_axfr_abort(ldns_resolver *resolver) { /* Only abort if an actual AXFR is in progress */ if (resolver->_socket != 0) { #ifndef USE_WINSOCK close(resolver->_socket); #else closesocket(resolver->_socket); #endif resolver->_socket = 0; } } bool ldns_axfr_complete(const ldns_resolver *res) { /* complete when soa count is 2? */ return res->_axfr_soa_count == 2; } ldns_pkt * ldns_axfr_last_pkt(const ldns_resolver *res) { return res->_cur_axfr_pkt; } /* random isn't really that good */ void ldns_resolver_nameservers_randomize(ldns_resolver *r) { uint16_t i, j; ldns_rdf **ns, *tmpns; size_t *rtt, tmprtt; /* should I check for ldns_resolver_random?? */ assert(r != NULL); ns = ldns_resolver_nameservers(r); rtt = ldns_resolver_rtt(r); for (i = 0; i < ldns_resolver_nameserver_count(r); i++) { j = ldns_get_random() % ldns_resolver_nameserver_count(r); tmpns = ns[i]; ns[i] = ns[j]; ns[j] = tmpns; tmprtt = rtt[i]; rtt[i] = rtt[j]; rtt[j] = tmprtt; } ldns_resolver_set_nameservers(r, ns); } ldns-1.6.17/dane.c0000664000175100017510000004175512264060151013202 0ustar willemwillem/* * Verify or create TLS authentication with DANE (RFC6698) * * (c) NLnetLabs 2012 * * See the file LICENSE for the license. * */ #include #ifdef USE_DANE #include #include #include #include #include #ifdef HAVE_SYS_SOCKET_H #include #endif #ifdef HAVE_NETDB_H #include #endif #ifdef HAVE_SSL #include #include #include #endif ldns_status ldns_dane_create_tlsa_owner(ldns_rdf** tlsa_owner, const ldns_rdf* name, uint16_t port, ldns_dane_transport transport) { char buf[LDNS_MAX_DOMAINLEN]; size_t s; assert(tlsa_owner != NULL); assert(name != NULL); assert(ldns_rdf_get_type(name) == LDNS_RDF_TYPE_DNAME); s = (size_t)snprintf(buf, LDNS_MAX_DOMAINLEN, "X_%d", (int)port); buf[0] = (char)(s - 1); switch(transport) { case LDNS_DANE_TRANSPORT_TCP: s += snprintf(buf + s, LDNS_MAX_DOMAINLEN - s, "\004_tcp"); break; case LDNS_DANE_TRANSPORT_UDP: s += snprintf(buf + s, LDNS_MAX_DOMAINLEN - s, "\004_udp"); break; case LDNS_DANE_TRANSPORT_SCTP: s += snprintf(buf + s, LDNS_MAX_DOMAINLEN - s, "\005_sctp"); break; default: return LDNS_STATUS_DANE_UNKNOWN_TRANSPORT; } if (s + ldns_rdf_size(name) > LDNS_MAX_DOMAINLEN) { return LDNS_STATUS_DOMAINNAME_OVERFLOW; } memcpy(buf + s, ldns_rdf_data(name), ldns_rdf_size(name)); *tlsa_owner = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_DNAME, s + ldns_rdf_size(name), buf); if (*tlsa_owner == NULL) { return LDNS_STATUS_MEM_ERR; } return LDNS_STATUS_OK; } #ifdef HAVE_SSL ldns_status ldns_dane_cert2rdf(ldns_rdf** rdf, X509* cert, ldns_tlsa_selector selector, ldns_tlsa_matching_type matching_type) { unsigned char* buf = NULL; size_t len; X509_PUBKEY* xpubkey; EVP_PKEY* epubkey; unsigned char* digest; assert(rdf != NULL); assert(cert != NULL); switch(selector) { case LDNS_TLSA_SELECTOR_FULL_CERTIFICATE: len = (size_t)i2d_X509(cert, &buf); break; case LDNS_TLSA_SELECTOR_SUBJECTPUBLICKEYINFO: #ifndef S_SPLINT_S xpubkey = X509_get_X509_PUBKEY(cert); #endif if (! xpubkey) { return LDNS_STATUS_SSL_ERR; } epubkey = X509_PUBKEY_get(xpubkey); if (! epubkey) { return LDNS_STATUS_SSL_ERR; } len = (size_t)i2d_PUBKEY(epubkey, &buf); break; default: return LDNS_STATUS_DANE_UNKNOWN_SELECTOR; } switch(matching_type) { case LDNS_TLSA_MATCHING_TYPE_NO_HASH_USED: *rdf = ldns_rdf_new(LDNS_RDF_TYPE_HEX, len, buf); return *rdf ? LDNS_STATUS_OK : LDNS_STATUS_MEM_ERR; break; case LDNS_TLSA_MATCHING_TYPE_SHA256: digest = LDNS_XMALLOC(unsigned char, LDNS_SHA256_DIGEST_LENGTH); if (digest == NULL) { LDNS_FREE(buf); return LDNS_STATUS_MEM_ERR; } (void) ldns_sha256(buf, (unsigned int)len, digest); *rdf = ldns_rdf_new(LDNS_RDF_TYPE_HEX, LDNS_SHA256_DIGEST_LENGTH, digest); LDNS_FREE(buf); return *rdf ? LDNS_STATUS_OK : LDNS_STATUS_MEM_ERR; break; case LDNS_TLSA_MATCHING_TYPE_SHA512: digest = LDNS_XMALLOC(unsigned char, LDNS_SHA512_DIGEST_LENGTH); if (digest == NULL) { LDNS_FREE(buf); return LDNS_STATUS_MEM_ERR; } (void) ldns_sha512(buf, (unsigned int)len, digest); *rdf = ldns_rdf_new(LDNS_RDF_TYPE_HEX, LDNS_SHA512_DIGEST_LENGTH, digest); LDNS_FREE(buf); return *rdf ? LDNS_STATUS_OK : LDNS_STATUS_MEM_ERR; break; default: LDNS_FREE(buf); return LDNS_STATUS_DANE_UNKNOWN_MATCHING_TYPE; } } /* Ordinary PKIX validation of cert (with extra_certs to help) * against the CA's in store */ static ldns_status ldns_dane_pkix_validate(X509* cert, STACK_OF(X509)* extra_certs, X509_STORE* store) { X509_STORE_CTX* vrfy_ctx; ldns_status s; if (! store) { return LDNS_STATUS_DANE_PKIX_DID_NOT_VALIDATE; } vrfy_ctx = X509_STORE_CTX_new(); if (! vrfy_ctx) { return LDNS_STATUS_SSL_ERR; } else if (X509_STORE_CTX_init(vrfy_ctx, store, cert, extra_certs) != 1) { s = LDNS_STATUS_SSL_ERR; } else if (X509_verify_cert(vrfy_ctx) == 1) { s = LDNS_STATUS_OK; } else { s = LDNS_STATUS_DANE_PKIX_DID_NOT_VALIDATE; } X509_STORE_CTX_free(vrfy_ctx); return s; } /* Orinary PKIX validation of cert (with extra_certs to help) * against the CA's in store, but also return the validation chain. */ static ldns_status ldns_dane_pkix_validate_and_get_chain(STACK_OF(X509)** chain, X509* cert, STACK_OF(X509)* extra_certs, X509_STORE* store) { ldns_status s; X509_STORE* empty_store = NULL; X509_STORE_CTX* vrfy_ctx; assert(chain != NULL); if (! store) { store = empty_store = X509_STORE_new(); } s = LDNS_STATUS_SSL_ERR; vrfy_ctx = X509_STORE_CTX_new(); if (! vrfy_ctx) { goto exit_free_empty_store; } else if (X509_STORE_CTX_init(vrfy_ctx, store, cert, extra_certs) != 1) { goto exit_free_vrfy_ctx; } else if (X509_verify_cert(vrfy_ctx) == 1) { s = LDNS_STATUS_OK; } else { s = LDNS_STATUS_DANE_PKIX_DID_NOT_VALIDATE; } *chain = X509_STORE_CTX_get1_chain(vrfy_ctx); if (! *chain) { s = LDNS_STATUS_SSL_ERR; } exit_free_vrfy_ctx: X509_STORE_CTX_free(vrfy_ctx); exit_free_empty_store: if (empty_store) { X509_STORE_free(empty_store); } return s; } /* Return the validation chain that can be build out of cert, with extra_certs. */ static ldns_status ldns_dane_pkix_get_chain(STACK_OF(X509)** chain, X509* cert, STACK_OF(X509)* extra_certs) { ldns_status s; X509_STORE* empty_store = NULL; X509_STORE_CTX* vrfy_ctx; assert(chain != NULL); empty_store = X509_STORE_new(); s = LDNS_STATUS_SSL_ERR; vrfy_ctx = X509_STORE_CTX_new(); if (! vrfy_ctx) { goto exit_free_empty_store; } else if (X509_STORE_CTX_init(vrfy_ctx, empty_store, cert, extra_certs) != 1) { goto exit_free_vrfy_ctx; } (void) X509_verify_cert(vrfy_ctx); *chain = X509_STORE_CTX_get1_chain(vrfy_ctx); if (! *chain) { s = LDNS_STATUS_SSL_ERR; } else { s = LDNS_STATUS_OK; } exit_free_vrfy_ctx: X509_STORE_CTX_free(vrfy_ctx); exit_free_empty_store: X509_STORE_free(empty_store); return s; } /* Pop n+1 certs and return the last popped. */ static ldns_status ldns_dane_get_nth_cert_from_validation_chain( X509** cert, STACK_OF(X509)* chain, int n, bool ca) { if (n >= sk_X509_num(chain) || n < 0) { return LDNS_STATUS_DANE_OFFSET_OUT_OF_RANGE; } *cert = sk_X509_pop(chain); while (n-- > 0) { X509_free(*cert); *cert = sk_X509_pop(chain); } if (ca && ! X509_check_ca(*cert)) { return LDNS_STATUS_DANE_NON_CA_CERTIFICATE; } return LDNS_STATUS_OK; } /* Create validation chain with cert and extra_certs and returns the last * self-signed (if present). */ static ldns_status ldns_dane_pkix_get_last_self_signed(X509** out_cert, X509* cert, STACK_OF(X509)* extra_certs) { ldns_status s; X509_STORE* empty_store = NULL; X509_STORE_CTX* vrfy_ctx; assert(out_cert != NULL); empty_store = X509_STORE_new(); s = LDNS_STATUS_SSL_ERR; vrfy_ctx = X509_STORE_CTX_new(); if (! vrfy_ctx) { goto exit_free_empty_store; } else if (X509_STORE_CTX_init(vrfy_ctx, empty_store, cert, extra_certs) != 1) { goto exit_free_vrfy_ctx; } (void) X509_verify_cert(vrfy_ctx); if (vrfy_ctx->error == X509_V_ERR_SELF_SIGNED_CERT_IN_CHAIN || vrfy_ctx->error == X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT){ *out_cert = X509_STORE_CTX_get_current_cert( vrfy_ctx); s = LDNS_STATUS_OK; } else { s = LDNS_STATUS_DANE_PKIX_NO_SELF_SIGNED_TRUST_ANCHOR; } exit_free_vrfy_ctx: X509_STORE_CTX_free(vrfy_ctx); exit_free_empty_store: X509_STORE_free(empty_store); return s; } ldns_status ldns_dane_select_certificate(X509** selected_cert, X509* cert, STACK_OF(X509)* extra_certs, X509_STORE* pkix_validation_store, ldns_tlsa_certificate_usage cert_usage, int offset) { ldns_status s; STACK_OF(X509)* pkix_validation_chain = NULL; assert(selected_cert != NULL); assert(cert != NULL); /* With PKIX validation explicitely turned off (pkix_validation_store * == NULL), treat the "CA constraint" and "Service certificate * constraint" the same as "Trust anchor assertion" and "Domain issued * certificate" respectively. */ if (pkix_validation_store == NULL) { switch (cert_usage) { case LDNS_TLSA_USAGE_CA_CONSTRAINT: cert_usage = LDNS_TLSA_USAGE_TRUST_ANCHOR_ASSERTION; break; case LDNS_TLSA_USAGE_SERVICE_CERTIFICATE_CONSTRAINT: cert_usage = LDNS_TLSA_USAGE_DOMAIN_ISSUED_CERTIFICATE; break; default: break; } } /* Now what to do with each Certificate usage... */ switch (cert_usage) { case LDNS_TLSA_USAGE_CA_CONSTRAINT: s = ldns_dane_pkix_validate_and_get_chain( &pkix_validation_chain, cert, extra_certs, pkix_validation_store); if (! pkix_validation_chain) { return s; } if (s == LDNS_STATUS_OK) { if (offset == -1) { offset = 0; } s = ldns_dane_get_nth_cert_from_validation_chain( selected_cert, pkix_validation_chain, offset, true); } sk_X509_pop_free(pkix_validation_chain, X509_free); return s; break; case LDNS_TLSA_USAGE_SERVICE_CERTIFICATE_CONSTRAINT: *selected_cert = cert; return ldns_dane_pkix_validate(cert, extra_certs, pkix_validation_store); break; case LDNS_TLSA_USAGE_TRUST_ANCHOR_ASSERTION: if (offset == -1) { s = ldns_dane_pkix_get_last_self_signed( selected_cert, cert, extra_certs); return s; } else { s = ldns_dane_pkix_get_chain( &pkix_validation_chain, cert, extra_certs); if (s == LDNS_STATUS_OK) { s = ldns_dane_get_nth_cert_from_validation_chain( selected_cert, pkix_validation_chain, offset, false); } else if (! pkix_validation_chain) { return s; } sk_X509_pop_free(pkix_validation_chain, X509_free); return s; } break; case LDNS_TLSA_USAGE_DOMAIN_ISSUED_CERTIFICATE: *selected_cert = cert; return LDNS_STATUS_OK; break; default: return LDNS_STATUS_DANE_UNKNOWN_CERTIFICATE_USAGE; break; } } ldns_status ldns_dane_create_tlsa_rr(ldns_rr** tlsa, ldns_tlsa_certificate_usage certificate_usage, ldns_tlsa_selector selector, ldns_tlsa_matching_type matching_type, X509* cert) { ldns_rdf* rdf; ldns_status s; assert(tlsa != NULL); assert(cert != NULL); /* create rr */ *tlsa = ldns_rr_new_frm_type(LDNS_RR_TYPE_TLSA); if (*tlsa == NULL) { return LDNS_STATUS_MEM_ERR; } rdf = ldns_native2rdf_int8(LDNS_RDF_TYPE_INT8, (uint8_t)certificate_usage); if (rdf == NULL) { goto memerror; } (void) ldns_rr_set_rdf(*tlsa, rdf, 0); rdf = ldns_native2rdf_int8(LDNS_RDF_TYPE_INT8, (uint8_t)selector); if (rdf == NULL) { goto memerror; } (void) ldns_rr_set_rdf(*tlsa, rdf, 1); rdf = ldns_native2rdf_int8(LDNS_RDF_TYPE_INT8, (uint8_t)matching_type); if (rdf == NULL) { goto memerror; } (void) ldns_rr_set_rdf(*tlsa, rdf, 2); s = ldns_dane_cert2rdf(&rdf, cert, selector, matching_type); if (s == LDNS_STATUS_OK) { (void) ldns_rr_set_rdf(*tlsa, rdf, 3); return LDNS_STATUS_OK; } ldns_rr_free(*tlsa); *tlsa = NULL; return s; memerror: ldns_rr_free(*tlsa); *tlsa = NULL; return LDNS_STATUS_MEM_ERR; } /* Return tlsas that actually are TLSA resource records with known values * for the Certificate usage, Selector and Matching type rdata fields. */ static ldns_rr_list* ldns_dane_filter_unusable_records(const ldns_rr_list* tlsas) { size_t i; ldns_rr_list* r = ldns_rr_list_new(); ldns_rr* tlsa_rr; if (! r) { return NULL; } for (i = 0; i < ldns_rr_list_rr_count(tlsas); i++) { tlsa_rr = ldns_rr_list_rr(tlsas, i); if (ldns_rr_get_type(tlsa_rr) == LDNS_RR_TYPE_TLSA && ldns_rr_rd_count(tlsa_rr) == 4 && ldns_rdf2native_int8(ldns_rr_rdf(tlsa_rr, 0)) <= 3 && ldns_rdf2native_int8(ldns_rr_rdf(tlsa_rr, 1)) <= 1 && ldns_rdf2native_int8(ldns_rr_rdf(tlsa_rr, 2)) <= 2) { if (! ldns_rr_list_push_rr(r, tlsa_rr)) { ldns_rr_list_free(r); return NULL; } } } return r; } /* Return whether cert/selector/matching_type matches data. */ static ldns_status ldns_dane_match_cert_with_data(X509* cert, ldns_tlsa_selector selector, ldns_tlsa_matching_type matching_type, ldns_rdf* data) { ldns_status s; ldns_rdf* match_data; s = ldns_dane_cert2rdf(&match_data, cert, selector, matching_type); if (s == LDNS_STATUS_OK) { if (ldns_rdf_compare(data, match_data) != 0) { s = LDNS_STATUS_DANE_TLSA_DID_NOT_MATCH; } ldns_rdf_free(match_data); } return s; } /* Return whether any certificate from the chain with selector/matching_type * matches data. * ca should be true if the certificate has to be a CA certificate too. */ static ldns_status ldns_dane_match_any_cert_with_data(STACK_OF(X509)* chain, ldns_tlsa_selector selector, ldns_tlsa_matching_type matching_type, ldns_rdf* data, bool ca) { ldns_status s = LDNS_STATUS_DANE_TLSA_DID_NOT_MATCH; size_t n, i; X509* cert; n = (size_t)sk_X509_num(chain); for (i = 0; i < n; i++) { cert = sk_X509_pop(chain); if (! cert) { s = LDNS_STATUS_SSL_ERR; break; } s = ldns_dane_match_cert_with_data(cert, selector, matching_type, data); if (ca && s == LDNS_STATUS_OK && ! X509_check_ca(cert)) { s = LDNS_STATUS_DANE_NON_CA_CERTIFICATE; } X509_free(cert); if (s != LDNS_STATUS_DANE_TLSA_DID_NOT_MATCH) { break; } /* when s == LDNS_STATUS_DANE_TLSA_DID_NOT_MATCH, * try to match the next certificate */ } return s; } ldns_status ldns_dane_verify_rr(const ldns_rr* tlsa_rr, X509* cert, STACK_OF(X509)* extra_certs, X509_STORE* pkix_validation_store) { ldns_status s; STACK_OF(X509)* pkix_validation_chain = NULL; ldns_tlsa_certificate_usage cert_usage; ldns_tlsa_selector selector; ldns_tlsa_matching_type matching_type; ldns_rdf* data; if (! tlsa_rr) { /* No TLSA, so regular PKIX validation */ return ldns_dane_pkix_validate(cert, extra_certs, pkix_validation_store); } cert_usage = ldns_rdf2native_int8(ldns_rr_rdf(tlsa_rr, 0)); selector = ldns_rdf2native_int8(ldns_rr_rdf(tlsa_rr, 1)); matching_type = ldns_rdf2native_int8(ldns_rr_rdf(tlsa_rr, 2)); data = ldns_rr_rdf(tlsa_rr, 3) ; switch (cert_usage) { case LDNS_TLSA_USAGE_CA_CONSTRAINT: s = ldns_dane_pkix_validate_and_get_chain( &pkix_validation_chain, cert, extra_certs, pkix_validation_store); if (! pkix_validation_chain) { return s; } if (s == LDNS_STATUS_DANE_PKIX_DID_NOT_VALIDATE) { /* * NO PKIX validation. We still try to match *any* * certificate from the chain, so we return * TLSA errors over PKIX errors. * * i.e. When the TLSA matches no certificate, we return * TLSA_DID_NOT_MATCH and not PKIX_DID_NOT_VALIDATE */ s = ldns_dane_match_any_cert_with_data( pkix_validation_chain, selector, matching_type, data, true); if (s == LDNS_STATUS_OK) { /* A TLSA record did match a cert from the * chain, thus the error is failed PKIX * validation. */ s = LDNS_STATUS_DANE_PKIX_DID_NOT_VALIDATE; } } else if (s == LDNS_STATUS_OK) { /* PKIX validated, does the TLSA match too? */ s = ldns_dane_match_any_cert_with_data( pkix_validation_chain, selector, matching_type, data, true); } sk_X509_pop_free(pkix_validation_chain, X509_free); return s; break; case LDNS_TLSA_USAGE_SERVICE_CERTIFICATE_CONSTRAINT: s = ldns_dane_match_cert_with_data(cert, selector, matching_type, data); if (s == LDNS_STATUS_OK) { return ldns_dane_pkix_validate(cert, extra_certs, pkix_validation_store); } return s; break; case LDNS_TLSA_USAGE_TRUST_ANCHOR_ASSERTION: s = ldns_dane_pkix_get_chain(&pkix_validation_chain, cert, extra_certs); if (s == LDNS_STATUS_OK) { s = ldns_dane_match_any_cert_with_data( pkix_validation_chain, selector, matching_type, data, false); } else if (! pkix_validation_chain) { return s; } sk_X509_pop_free(pkix_validation_chain, X509_free); return s; break; case LDNS_TLSA_USAGE_DOMAIN_ISSUED_CERTIFICATE: return ldns_dane_match_cert_with_data(cert, selector, matching_type, data); break; default: break; } return LDNS_STATUS_DANE_UNKNOWN_CERTIFICATE_USAGE; } ldns_status ldns_dane_verify(ldns_rr_list* tlsas, X509* cert, STACK_OF(X509)* extra_certs, X509_STORE* pkix_validation_store) { size_t i; ldns_rr* tlsa_rr; ldns_status s = LDNS_STATUS_OK, ps; assert(cert != NULL); if (tlsas && ldns_rr_list_rr_count(tlsas) > 0) { tlsas = ldns_dane_filter_unusable_records(tlsas); if (! tlsas) { return LDNS_STATUS_MEM_ERR; } } if (! tlsas || ldns_rr_list_rr_count(tlsas) == 0) { /* No TLSA's, so regular PKIX validation */ return ldns_dane_pkix_validate(cert, extra_certs, pkix_validation_store); } else { for (i = 0; i < ldns_rr_list_rr_count(tlsas); i++) { tlsa_rr = ldns_rr_list_rr(tlsas, i); ps = s; s = ldns_dane_verify_rr(tlsa_rr, cert, extra_certs, pkix_validation_store); if (s != LDNS_STATUS_DANE_TLSA_DID_NOT_MATCH && s != LDNS_STATUS_DANE_PKIX_DID_NOT_VALIDATE) { /* which would be LDNS_STATUS_OK (match) * or some fatal error preventing use from * trying the next TLSA record. */ break; } s = (s > ps ? s : ps); /* prefer PKIX_DID_NOT_VALIDATE * over TLSA_DID_NOT_MATCH */ } ldns_rr_list_free(tlsas); } return s; } #endif /* HAVE_SSL */ #endif /* USE_DANE */ ldns-1.6.17/libdns.vim0000664000175100017510000004621512264060151014113 0ustar willemwillem" Vim syntax file " Language: C libdns " Maintainer: miekg " Last change: 2011-09-15 " ldns/util.h syn keyword ldnsMacro LDNS_MALLOC syn keyword ldnsMacro LDNS_XMALLOC syn keyword ldnsMacro LDNS_CALLOC syn keyword ldnsMacro LDNS_REALLOC syn keyword ldnsMacro LDNS_XREALLOC syn keyword ldnsMacro LDNS_FREE syn keyword ldnsMacro LDNS_DEP syn keyword ldnsMacro LDNS_VERSION syn keyword ldnsMacro LDNS_REVISION " ldns/dname.h syn keyword ldnsMacro LDNS_DNAME_NORMALIZE " ldns/tsig.h syn keyword ldnsType ldns_tsig_credentials " ldns/update.h " -- " ldns/rdata.h syn keyword ldnsType ldns_rdf syn keyword ldnsType ldns_rdf_type syn keyword ldnsType ldns_cert_algorithm syn keyword ldnsConstant LDNS_RDF_TYPE_NONE syn keyword ldnsConstant LDNS_RDF_TYPE_DNAME syn keyword ldnsConstant LDNS_RDF_TYPE_INT8 syn keyword ldnsConstant LDNS_RDF_TYPE_INT16 syn keyword ldnsConstant LDNS_RDF_TYPE_INT16_DATA syn keyword ldnsConstant LDNS_RDF_TYPE_INT32 syn keyword ldnsConstant LDNS_RDF_TYPE_A syn keyword ldnsConstant LDNS_RDF_TYPE_AAAA syn keyword ldnsConstant LDNS_RDF_TYPE_STR syn keyword ldnsConstant LDNS_RDF_TYPE_APL syn keyword ldnsConstant LDNS_RDF_TYPE_B32_EXT syn keyword ldnsConstant LDNS_RDF_TYPE_B64 syn keyword ldnsConstant LDNS_RDF_TYPE_HEX syn keyword ldnsConstant LDNS_RDF_TYPE_NSEC syn keyword ldnsConstant LDNS_RDF_TYPE_TYPE syn keyword ldnsConstant LDNS_RDF_TYPE_CLASS syn keyword ldnsConstant LDNS_RDF_TYPE_CERT syn keyword ldnsConstant LDNS_RDF_TYPE_CERT_ALG syn keyword ldnsConstant LDNS_RDF_TYPE_ALG syn keyword ldnsConstant LDNS_RDF_TYPE_UNKNOWN syn keyword ldnsConstant LDNS_RDF_TYPE_TIME syn keyword ldnsConstant LDNS_RDF_TYPE_PERIOD syn keyword ldnsConstant LDNS_RDF_TYPE_TSIGTIME syn keyword ldnsConstant LDNS_RDF_TYPE_SERVICE syn keyword ldnsConstant LDNS_RDF_TYPE_LOC syn keyword ldnsConstant LDNS_RDF_TYPE_WKS syn keyword ldnsConstant LDNS_RDF_TYPE_NSAP syn keyword ldnsConstant LDNS_RDF_TYPE_ATMA syn keyword ldnsConstant LDNS_RDF_TYPE_NSEC3_SALT syn keyword ldnsConstant LDNS_RDF_TYPE_NSEC3_NEXT_OWNER syn keyword ldnsConstant LDNS_RDF_TYPE_IPSECKEY syn keyword ldnsConstant LDNS_RDF_TYPE_TSIG syn keyword ldnsConstant LDNS_MAX_RDFLEN syn keyword ldnsConstant LDNS_RDF_SIZE_BYTE syn keyword ldnsConstant LDNS_RDF_SIZE_WORD syn keyword ldnsConstant LDNS_RDF_SIZE_DOUBLEWORD syn keyword ldnsConstant LDNS_RDF_SIZE_6BYTES syn keyword ldnsConstant LDNS_RDF_SIZE_16BYTES syn keyword ldnsConstant LDNS_NSEC3_VARS_OPTOUT_MASK syn keyword ldnsConstant LDNS_CERT_PKIX syn keyword ldnsConstant LDNS_CERT_SPKI syn keyword ldnsConstant LDNS_CERT_PGP syn keyword ldnsConstant LDNS_CERT_IPKIX syn keyword ldnsConstant LDNS_CERT_ISPKI syn keyword ldnsConstant LDNS_CERT_IPGP syn keyword ldnsConstant LDNS_CERT_ACPKIX syn keyword ldnsConstant LDNS_CERT_IACPKIX syn keyword ldnsConstant LDNS_CERT_URI syn keyword ldnsConstant LDNS_CERT_OID " ldns/ldns.h syn keyword ldnsConstant LDNS_PORT syn keyword ldnsConstant LDNS_IP4ADDRLEN syn keyword ldnsConstant LDNS_IP6ADDRLEN syn keyword ldnsConstant LDNS_ROOT_LABEL_STR syn keyword ldnsConstant LDNS_DEFAULT_TTL " ldns/packet.h syn keyword ldnsType ldns_pkt syn keyword ldnsType ldns_pkt_section syn keyword ldnsType ldns_pkt_type syn keyword ldnsType ldns_pkt_opcode syn keyword ldnsType ldns_pkt_rcode syn keyword ldnsType ldns_hdr syn keyword ldnsConstant LDNS_QR syn keyword ldnsConstant LDNS_AA syn keyword ldnsConstant LDNS_TC syn keyword ldnsConstant LDNS_RD syn keyword ldnsConstant LDNS_CD syn keyword ldnsConstant LDNS_RA syn keyword ldnsConstant LDNS_AD syn keyword ldnsConstant LDNS_MAX_PACKETLEN syn keyword ldnsConstant LDNS_PACKET_QUESTION syn keyword ldnsConstant LDNS_PACKET_REFERRAL syn keyword ldnsConstant LDNS_PACKET_ANSWER syn keyword ldnsConstant LDNS_PACKET_NXDOMAIN syn keyword ldnsConstant LDNS_PACKET_NODATA syn keyword ldnsConstant LDNS_PACKET_UNKNOWN syn keyword ldnsConstant LDNS_SECTION_QUESTION syn keyword ldnsConstant LDNS_SECTION_ANSWER syn keyword ldnsConstant LDNS_SECTION_AUTHORITY syn keyword ldnsConstant LDNS_SECTION_ADDITIONAL syn keyword ldnsConstant LDNS_SECTION_ANY syn keyword ldnsConstant LDNS_SECTION_ANY_NOQUESTION syn keyword ldnsConstant LDNS_PACKET_QUERY syn keyword ldnsConstant LDNS_PACKET_IQUERY syn keyword ldnsConstant LDNS_PACKET_STATUS syn keyword ldnsConstant LDNS_PACKET_NOTIFY syn keyword ldnsConstant LDNS_PACKET_UPDATE syn keyword ldnsConstant LDNS_RCODE_NOERROR syn keyword ldnsConstant LDNS_RCODE_FORMERR syn keyword ldnsConstant LDNS_RCODE_SERVFAIL syn keyword ldnsConstant LDNS_RCODE_NXDOMAIN syn keyword ldnsConstant LDNS_RCODE_NOTIMPL syn keyword ldnsConstant LDNS_RCODE_REFUSED syn keyword ldnsConstant LDNS_RCODE_YXDOMAIN syn keyword ldnsConstant LDNS_RCODE_YXRRSET syn keyword ldnsConstant LDNS_RCODE_NXRRSET syn keyword ldnsConstant LDNS_RCODE_NOTAUTH syn keyword ldnsConstant LDNS_RCODE_NOTZONE " dns/error.h syn keyword ldnsConstant LDNS_STATUS_OK syn keyword ldnsConstant LDNS_STATUS_EMPTY_LABEL syn keyword ldnsConstant LDNS_STATUS_LABEL_OVERFLOW syn keyword ldnsConstant LDNS_STATUS_DOMAINNAME_OVERFLOW syn keyword ldnsConstant LDNS_STATUS_DOMAINNAME_UNDERFLOW syn keyword ldnsConstant LDNS_STATUS_DDD_OVERFLOW syn keyword ldnsConstant LDNS_STATUS_PACKET_OVERFLOW syn keyword ldnsConstant LDNS_STATUS_INVALID_POINTER syn keyword ldnsConstant LDNS_STATUS_MEM_ERR syn keyword ldnsConstant LDNS_STATUS_INTERNAL_ERR syn keyword ldnsConstant LDNS_STATUS_SSL_ERR syn keyword ldnsConstant LDNS_STATUS_ERR syn keyword ldnsConstant LDNS_STATUS_INVALID_INT syn keyword ldnsConstant LDNS_STATUS_INVALID_IP4 syn keyword ldnsConstant LDNS_STATUS_INVALID_IP6 syn keyword ldnsConstant LDNS_STATUS_INVALID_STR syn keyword ldnsConstant LDNS_STATUS_INVALID_B32_EXT syn keyword ldnsConstant LDNS_STATUS_INVALID_B64 syn keyword ldnsConstant LDNS_STATUS_INVALID_HEX syn keyword ldnsConstant LDNS_STATUS_INVALID_TIME syn keyword ldnsConstant LDNS_STATUS_NETWORK_ERR syn keyword ldnsConstant LDNS_STATUS_ADDRESS_ERR syn keyword ldnsConstant LDNS_STATUS_FILE_ERR syn keyword ldnsConstant LDNS_STATUS_UNKNOWN_INET syn keyword ldnsConstant LDNS_STATUS_NOT_IMPL syn keyword ldnsConstant LDNS_STATUS_NULL syn keyword ldnsConstant LDNS_STATUS_CRYPTO_UNKNOWN_ALGO syn keyword ldnsConstant LDNS_STATUS_CRYPTO_ALGO_NOT_IMPL syn keyword ldnsConstant LDNS_STATUS_CRYPTO_NO_RRSIG syn keyword ldnsConstant LDNS_STATUS_CRYPTO_NO_DNSKEY syn keyword ldnsConstant LDNS_STATUS_CRYPTO_NO_TRUSTED_DNSKEY syn keyword ldnsConstant LDNS_STATUS_CRYPTO_NO_DS syn keyword ldnsConstant LDNS_STATUS_CRYPTO_NO_TRUSTED_DS syn keyword ldnsConstant LDNS_STATUS_CRYPTO_NO_MATCHING_KEYTAG_DNSKEY syn keyword ldnsConstant LDNS_STATUS_CRYPTO_VALIDATED syn keyword ldnsConstant LDNS_STATUS_CRYPTO_BOGUS syn keyword ldnsConstant LDNS_STATUS_CRYPTO_SIG_EXPIRED syn keyword ldnsConstant LDNS_STATUS_CRYPTO_SIG_NOT_INCEPTED syn keyword ldnsConstant LDNS_STATUS_CRYPTO_TSIG_BOGUS syn keyword ldnsConstant LDNS_STATUS_CRYPTO_TSIG_ERR syn keyword ldnsConstant LDNS_STATUS_CRYPTO_EXPIRATION_BEFORE_INCEPTION syn keyword ldnsConstant LDNS_STATUS_CRYPTO_TYPE_COVERED_ERR syn keyword ldnsConstant LDNS_STATUS_ENGINE_KEY_NOT_LOADED syn keyword ldnsConstant LDNS_STATUS_NSEC3_ERR syn keyword ldnsConstant LDNS_STATUS_RES_NO_NS syn keyword ldnsConstant LDNS_STATUS_RES_QUERY syn keyword ldnsConstant LDNS_STATUS_WIRE_INCOMPLETE_HEADER syn keyword ldnsConstant LDNS_STATUS_WIRE_INCOMPLETE_QUESTION syn keyword ldnsConstant LDNS_STATUS_WIRE_INCOMPLETE_ANSWER syn keyword ldnsConstant LDNS_STATUS_WIRE_INCOMPLETE_AUTHORITY syn keyword ldnsConstant LDNS_STATUS_WIRE_INCOMPLETE_ADDITIONAL syn keyword ldnsConstant LDNS_STATUS_NO_DATA syn keyword ldnsConstant LDNS_STATUS_CERT_BAD_ALGORITHM syn keyword ldnsConstant LDNS_STATUS_SYNTAX_TYPE_ERR syn keyword ldnsConstant LDNS_STATUS_SYNTAX_CLASS_ERR syn keyword ldnsConstant LDNS_STATUS_SYNTAX_TTL_ERR syn keyword ldnsConstant LDNS_STATUS_SYNTAX_INCLUDE_ERR_NOTIMPL syn keyword ldnsConstant LDNS_STATUS_SYNTAX_RDATA_ERR syn keyword ldnsConstant LDNS_STATUS_SYNTAX_DNAME_ERR syn keyword ldnsConstant LDNS_STATUS_SYNTAX_VERSION_ERR syn keyword ldnsConstant LDNS_STATUS_SYNTAX_ALG_ERR syn keyword ldnsConstant LDNS_STATUS_SYNTAX_KEYWORD_ERR syn keyword ldnsConstant LDNS_STATUS_SYNTAX_TTL syn keyword ldnsConstant LDNS_STATUS_SYNTAX_ORIGIN syn keyword ldnsConstant LDNS_STATUS_SYNTAX_INCLUDE syn keyword ldnsConstant LDNS_STATUS_SYNTAX_EMPTY syn keyword ldnsConstant LDNS_STATUS_SYNTAX_ITERATIONS_OVERFLOW syn keyword ldnsConstant LDNS_STATUS_SYNTAX_MISSING_VALUE_ERR syn keyword ldnsConstant LDNS_STATUS_SYNTAX_INTEGER_OVERFLOW syn keyword ldnsConstant LDNS_STATUS_SYNTAX_BAD_ESCAPE syn keyword ldnsConstant LDNS_STATUS_SOCKET_ERROR syn keyword ldnsConstant LDNS_STATUS_SYNTAX_ERR syn keyword ldnsConstant LDNS_STATUS_DNSSEC_EXISTENCE_DENIED syn keyword ldnsConstant LDNS_STATUS_DNSSEC_NSEC_RR_NOT_COVERED syn keyword ldnsConstant LDNS_STATUS_DNSSEC_NSEC_WILDCARD_NOT_COVERED syn keyword ldnsConstant LDNS_STATUS_DNSSEC_NSEC3_ORIGINAL_NOT_FOUND syn keyword ldnsConstant LDNS_STATUS_MISSING_RDATA_FIELDS_RRSIG syn keyword ldnsConstant LDNS_STATUS_MISSING_RDATA_FIELDS_KEY " ldns/resolver.h syn keyword ldnsType ldns_resolver syn keyword ldnsConstant LDNS_RESOLV_CONF syn keyword ldnsConstant LDNS_RESOLV_HOSTS syn keyword ldnsConstant LDNS_RESOLV_KEYWORD syn keyword ldnsConstant LDNS_RESOLV_DEFDOMAIN syn keyword ldnsConstant LDNS_RESOLV_NAMESERVER syn keyword ldnsConstant LDNS_RESOLV_SEARCH syn keyword ldnsConstant LDNS_RESOLV_SORTLIST syn keyword ldnsConstant LDNS_RESOLV_OPTIONS syn keyword ldnsConstant LDNS_RESOLV_ANCHOR syn keyword ldnsConstant LDNS_RESOLV_KEYWORDS syn keyword ldnsConstant LDNS_RESOLV_INETANY syn keyword ldnsConstant LDNS_RESOLV_INET syn keyword ldnsConstant LDNS_RESOLV_INET6 syn keyword ldnsConstant LDNS_RESOLV_RTT_INF syn keyword ldnsConstant LDNS_RESOLV_RTT_MIN " ldns/zone.h syn keyword ldnsType ldns_zone " ldns/dnssec.h syn keyword ldnsConstant LDNS_NSEC3_MAX_ITERATIONS syn keyword ldnsConstant LDNS_DEFAULT_EXP_TIME syn keyword ldnsConstant LDNS_DNSSEC_KEYPROTO syn keyword ldnsConstant LDNS_MAX_KEYLEN " ldns/dnssec_sign.h " -- " ldns/dnssec_zone.h syn keyword ldnsType ldns_dnssec_rrs syn keyword ldnsType ldns_dnssec_rrsets syn keyword ldnsType ldns_dnssec_name syn keyword ldnsType ldns_dnssec_zone " ldns/dnssec_verify.h syn keyword ldnsType ldns_dnssec_data_chain syn keyword ldnsType ldns_dnssec_trust_tree " ldns/rr.h syn keyword ldnsType ldns_rr_list syn keyword ldnsType ldns_rr_descriptor syn keyword ldnsType ldns_rr syn keyword ldnsType ldns_rr_type syn keyword ldnsType ldns_rr_class syn keyword ldnsType ldns_rr_compress syn keyword ldnsConstant LDNS_MAX_LABELLEN syn keyword ldnsConstant LDNS_MAX_DOMAINLEN syn keyword ldnsConstant LDNS_RR_COMPRESS syn keyword ldnsConstant LDNS_RR_NO_COMPRESS syn keyword ldnsConstant LDNS_RR_CLASS_IN syn keyword ldnsConstant LDNS_RR_CLASS_CH syn keyword ldnsConstant LDNS_RR_CLASS_HS syn keyword ldnsConstant LDNS_RR_CLASS_NONE syn keyword ldnsConstant LDNS_RR_CLASS_ANY syn keyword ldnsConstant LDNS_RR_TYPE_A syn keyword ldnsConstant LDNS_RR_TYPE_A6 syn keyword ldnsConstant LDNS_RR_TYPE_AAAA syn keyword ldnsConstant LDNS_RR_TYPE_AFSDB syn keyword ldnsConstant LDNS_RR_TYPE_ANY syn keyword ldnsConstant LDNS_RR_TYPE_APL syn keyword ldnsConstant LDNS_RR_TYPE_ATMA syn keyword ldnsConstant LDNS_RR_TYPE_AXFR syn keyword ldnsConstant LDNS_RR_TYPE_CERT syn keyword ldnsConstant LDNS_RR_TYPE_CNAME syn keyword ldnsConstant LDNS_RR_TYPE_COUNT syn keyword ldnsConstant LDNS_RR_TYPE_DHCID syn keyword ldnsConstant LDNS_RR_TYPE_DLV syn keyword ldnsConstant LDNS_RR_TYPE_DNAME syn keyword ldnsConstant LDNS_RR_TYPE_DNSKEY syn keyword ldnsConstant LDNS_RR_TYPE_DS syn keyword ldnsConstant LDNS_RR_TYPE_EID syn keyword ldnsConstant LDNS_RR_TYPE_FIRST syn keyword ldnsConstant LDNS_RR_TYPE_GID syn keyword ldnsConstant LDNS_RR_TYPE_GPOS syn keyword ldnsConstant LDNS_RR_TYPE_HINFO syn keyword ldnsConstant LDNS_RR_TYPE_IPSECKEY syn keyword ldnsConstant LDNS_RR_TYPE_ISDN syn keyword ldnsConstant LDNS_RR_TYPE_IXFR syn keyword ldnsConstant LDNS_RR_TYPE_KEY syn keyword ldnsConstant LDNS_RR_TYPE_KX syn keyword ldnsConstant LDNS_RR_TYPE_LAST syn keyword ldnsConstant LDNS_RR_TYPE_LOC syn keyword ldnsConstant LDNS_RR_TYPE_MAILA syn keyword ldnsConstant LDNS_RR_TYPE_MAILB syn keyword ldnsConstant LDNS_RR_TYPE_MB syn keyword ldnsConstant LDNS_RR_TYPE_MD syn keyword ldnsConstant LDNS_RR_TYPE_MF syn keyword ldnsConstant LDNS_RR_TYPE_MG syn keyword ldnsConstant LDNS_RR_TYPE_MINFO syn keyword ldnsConstant LDNS_RR_TYPE_MR syn keyword ldnsConstant LDNS_RR_TYPE_MX syn keyword ldnsConstant LDNS_RR_TYPE_NAPTR syn keyword ldnsConstant LDNS_RR_TYPE_NIMLOC syn keyword ldnsConstant LDNS_RR_TYPE_NS syn keyword ldnsConstant LDNS_RR_TYPE_NSAP syn keyword ldnsConstant LDNS_RR_TYPE_NSAP_PTR syn keyword ldnsConstant LDNS_RR_TYPE_NSEC syn keyword ldnsConstant LDNS_RR_TYPE_NSEC3 syn keyword ldnsConstant LDNS_RR_TYPE_NSEC3 syn keyword ldnsConstant LDNS_RR_TYPE_NSEC3PARAM syn keyword ldnsConstant LDNS_RR_TYPE_NSEC3PARAMS syn keyword ldnsConstant LDNS_RR_TYPE_NSEC3PARAMS syn keyword ldnsConstant LDNS_RR_TYPE_NULL syn keyword ldnsConstant LDNS_RR_TYPE_NXT syn keyword ldnsConstant LDNS_RR_TYPE_OPT syn keyword ldnsConstant LDNS_RR_TYPE_PTR syn keyword ldnsConstant LDNS_RR_TYPE_PX syn keyword ldnsConstant LDNS_RR_TYPE_RP syn keyword ldnsConstant LDNS_RR_TYPE_RRSIG syn keyword ldnsConstant LDNS_RR_TYPE_RT syn keyword ldnsConstant LDNS_RR_TYPE_SIG syn keyword ldnsConstant LDNS_RR_TYPE_SINK syn keyword ldnsConstant LDNS_RR_TYPE_SOA syn keyword ldnsConstant LDNS_RR_TYPE_SPF syn keyword ldnsConstant LDNS_RR_TYPE_SRV syn keyword ldnsConstant LDNS_RR_TYPE_SSHFP syn keyword ldnsConstant LDNS_RR_TYPE_TALINK syn keyword ldnsConstant LDNS_RR_TYPE_TSIG syn keyword ldnsConstant LDNS_RR_TYPE_TXT syn keyword ldnsConstant LDNS_RR_TYPE_UID syn keyword ldnsConstant LDNS_RR_TYPE_UINFO syn keyword ldnsConstant LDNS_RR_TYPE_UNSPEC syn keyword ldnsConstant LDNS_RR_TYPE_WKS syn keyword ldnsConstant LDNS_RR_TYPE_X25 " ldns/buffer.h syn keyword ldnsType ldns_buffer syn keyword ldnsConstant LDNS_MIN_BUFLEN " ldns/host2str.h syn keyword ldnsConstant LDNS_APL_IP4 syn keyword ldnsConstant LDNS_APL_IP6 syn keyword ldnsConstant LDNS_APL_MASK syn keyword ldnsConstant LDNS_APL_NEGATION " ldns/keys.h syn keyword ldnsType ldns_key syn keyword ldnsType ldns_key_list syn keyword ldnsType ldns_signing_algorithm syn keyword ldnsType ldns_hash syn keyword ldnsType ldns_algorithm syn keyword ldnsConstant LDNS_KEY_ZONE_KEY syn keyword ldnsConstant LDNS_KEY_SEP_KEY syn keyword ldnsConstant LDNS_KEY_REVOKE_KEY syn keyword ldnsConstant LDNS_SHA1 syn keyword ldnsConstant LDNS_SHA256 syn keyword ldnsConstant LDNS_HASH_GOST syn keyword ldnsConstant LDNS_SHA384 syn keyword ldnsConstant LDNS_SIGN_RSAMD5 syn keyword ldnsConstant LDNS_SIGN_RSASHA1 syn keyword ldnsConstant LDNS_SIGN_DSA syn keyword ldnsConstant LDNS_SIGN_RSASHA1_NSEC3 syn keyword ldnsConstant LDNS_SIGN_RSASHA256 syn keyword ldnsConstant LDNS_SIGN_RSASHA512 syn keyword ldnsConstant LDNS_SIGN_DSA_NSEC3 syn keyword ldnsConstant LDNS_SIGN_ECC_GOST syn keyword ldnsConstant LDNS_SIGN_ECDSAP256SHA256 syn keyword ldnsConstant LDNS_SIGN_ECDSAP384SHA384 syn keyword ldnsConstant LDNS_SIGN_HMACMD5 syn keyword ldnsConstant LDNS_SIGN_HMACSHA1 syn keyword ldnsConstant LDNS_SIGN_HMACSHA256 " ldns/wire2host.h syn keyword ldnsMacro LDNS_WIRE2HOST_H syn keyword ldnsMacro LDNS_HEADER_SIZE syn keyword ldnsMacro LDNS_RD_MASK syn keyword ldnsMacro LDNS_RD_SHIFT syn keyword ldnsMacro LDNS_RD_WIRE syn keyword ldnsMacro LDNS_RD_SET syn keyword ldnsMacro LDNS_RD_CLR syn keyword ldnsMacro LDNS_TC_MASK syn keyword ldnsMacro LDNS_TC_SHIFT syn keyword ldnsMacro LDNS_TC_WIRE syn keyword ldnsMacro LDNS_TC_SET syn keyword ldnsMacro LDNS_TC_CLR syn keyword ldnsMacro LDNS_AA_MASK syn keyword ldnsMacro LDNS_AA_SHIFT syn keyword ldnsMacro LDNS_AA_WIRE syn keyword ldnsMacro LDNS_AA_SET syn keyword ldnsMacro LDNS_AA_CLR syn keyword ldnsMacro LDNS_OPCODE_MASK syn keyword ldnsMacro LDNS_OPCODE_SHIFT syn keyword ldnsMacro LDNS_OPCODE_WIRE syn keyword ldnsMacro LDNS_OPCODE_SET syn keyword ldnsMacro LDNS_QR_MASK syn keyword ldnsMacro LDNS_QR_SHIFT syn keyword ldnsMacro LDNS_QR_WIRE syn keyword ldnsMacro LDNS_QR_SET syn keyword ldnsMacro LDNS_QR_CLR syn keyword ldnsMacro LDNS_RCODE_MASK syn keyword ldnsMacro LDNS_RCODE_SHIFT syn keyword ldnsMacro LDNS_RCODE_WIRE syn keyword ldnsMacro LDNS_RCODE_SET syn keyword ldnsMacro LDNS_CD_MASK syn keyword ldnsMacro LDNS_CD_SHIFT syn keyword ldnsMacro LDNS_CD_WIRE syn keyword ldnsMacro LDNS_CD_SET syn keyword ldnsMacro LDNS_CD_CLR syn keyword ldnsMacro LDNS_AD_MASK syn keyword ldnsMacro LDNS_AD_SHIFT syn keyword ldnsMacro LDNS_AD_WIRE syn keyword ldnsMacro LDNS_AD_SET syn keyword ldnsMacro LDNS_AD_CLR syn keyword ldnsMacro LDNS_Z_MASK syn keyword ldnsMacro LDNS_Z_SHIFT syn keyword ldnsMacro LDNS_Z_WIRE syn keyword ldnsMacro LDNS_Z_SET syn keyword ldnsMacro LDNS_Z_CLR syn keyword ldnsMacro LDNS_RA_MASK syn keyword ldnsMacro LDNS_RA_SHIFT syn keyword ldnsMacro LDNS_RA_WIRE syn keyword ldnsMacro LDNS_RA_SET syn keyword ldnsMacro LDNS_RA_CLR syn keyword ldnsMacro LDNS_ID_WIRE syn keyword ldnsMacro LDNS_ID_SET syn keyword ldnsMacro LDNS_QDCOUNT_OFF syn keyword ldnsMacro QDCOUNT syn keyword ldnsMacro LDNS_QDCOUNT syn keyword ldnsMacro LDNS_ANCOUNT_OFF syn keyword ldnsMacro LDNS_ANCOUNT syn keyword ldnsMacro LDNS_NSCOUNT_OFF syn keyword ldnsMacro LDNS_NSCOUNT syn keyword ldnsMacro LDNS_ARCOUNT_OFF syn keyword ldnsMacro LDNS_ARCOUNT " ldns/host2wire.h " -- " ldns/* -- All functions " Created with: " Get all the functions that start with 'ldns_' " egrep '^[a-z_]+ [*a-z_0-9]+\(' *.h | sed -e 's/(.*$//' | awk '{print $2}' | \ " sed 's/^\*//' | grep '^ldns' | sort " Not included, but could be added...? " Default highlighting command -nargs=+ HiLink hi def link HiLink ldnsType Type " Currently no functions are defined HiLink ldnsFunction Function HiLink ldnsMacro Macro HiLink ldnsConstant Constant delcommand HiLink ldns-1.6.17/ax_python_devel.m40000664000175100017510000002557712264060151015565 0ustar willemwillem# =========================================================================== # http://www.gnu.org/software/autoconf-archive/ax_python_devel.html # =========================================================================== # # SYNOPSIS # # AX_PYTHON_DEVEL([version]) # # DESCRIPTION # # Note: Defines as a precious variable "PYTHON_VERSION". Don't override it # in your configure.ac. # # This macro checks for Python and tries to get the include path to # 'Python.h'. It provides the $(PYTHON_CPPFLAGS) and $(PYTHON_LDFLAGS) # output variables. It also exports $(PYTHON_EXTRA_LIBS) and # $(PYTHON_EXTRA_LDFLAGS) for embedding Python in your code. # # You can search for some particular version of Python by passing a # parameter to this macro, for example ">= '2.3.1'", or "== '2.4'". Please # note that you *have* to pass also an operator along with the version to # match, and pay special attention to the single quotes surrounding the # version number. Don't use "PYTHON_VERSION" for this: that environment # variable is declared as precious and thus reserved for the end-user. # # This macro should work for all versions of Python >= 2.1.0. As an end # user, you can disable the check for the python version by setting the # PYTHON_NOVERSIONCHECK environment variable to something else than the # empty string. # # If you need to use this macro for an older Python version, please # contact the authors. We're always open for feedback. # # LICENSE # # Copyright (c) 2009 Sebastian Huber # Copyright (c) 2009 Alan W. Irwin # Copyright (c) 2009 Rafael Laboissiere # Copyright (c) 2009 Andrew Collier # Copyright (c) 2009 Matteo Settenvini # Copyright (c) 2009 Horst Knorr # Copyright (c) 2013 Daniel Mullner # # This program is free software: you can redistribute it and/or modify it # under the terms of the GNU General Public License as published by the # Free Software Foundation, either version 3 of the License, or (at your # option) any later version. # # This program is distributed in the hope that it will be useful, but # WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General # Public License for more details. # # You should have received a copy of the GNU General Public License along # with this program. If not, see . # # As a special exception, the respective Autoconf Macro's copyright owner # gives unlimited permission to copy, distribute and modify the configure # scripts that are the output of Autoconf when processing the Macro. You # need not follow the terms of the GNU General Public License when using # or distributing such scripts, even though portions of the text of the # Macro appear in them. The GNU General Public License (GPL) does govern # all other use of the material that constitutes the Autoconf Macro. # # This special exception to the GPL applies to versions of the Autoconf # Macro released by the Autoconf Archive. When you make and distribute a # modified version of the Autoconf Macro, you may extend this special # exception to the GPL to apply to your modified version as well. #serial 16 AU_ALIAS([AC_PYTHON_DEVEL], [AX_PYTHON_DEVEL]) AC_DEFUN([AX_PYTHON_DEVEL],[ # # Allow the use of a (user set) custom python version # AC_ARG_VAR([PYTHON_VERSION],[The installed Python version to use, for example '2.3'. This string will be appended to the Python interpreter canonical name.]) AC_PATH_PROG([PYTHON],[python[$PYTHON_VERSION]]) if test -z "$PYTHON"; then AC_MSG_ERROR([Cannot find python$PYTHON_VERSION in your system path]) PYTHON_VERSION="" fi # # Check for a version of Python >= 2.1.0 # AC_MSG_CHECKING([for a version of Python >= '2.1.0']) ac_supports_python_ver=`$PYTHON -c "import sys; \ ver = sys.version.split ()[[0]]; \ print (ver >= '2.1.0')"` if test "$ac_supports_python_ver" != "True"; then if test -z "$PYTHON_NOVERSIONCHECK"; then AC_MSG_RESULT([no]) AC_MSG_FAILURE([ This version of the AC@&t@_PYTHON_DEVEL macro doesn't work properly with versions of Python before 2.1.0. You may need to re-run configure, setting the variables PYTHON_CPPFLAGS, PYTHON_LDFLAGS, PYTHON_SITE_PKG, PYTHON_EXTRA_LIBS and PYTHON_EXTRA_LDFLAGS by hand. Moreover, to disable this check, set PYTHON_NOVERSIONCHECK to something else than an empty string. ]) else AC_MSG_RESULT([skip at user request]) fi else AC_MSG_RESULT([yes]) fi # # if the macro parameter ``version'' is set, honour it # if test -n "$1"; then AC_MSG_CHECKING([for a version of Python $1]) ac_supports_python_ver=`$PYTHON -c "import sys; \ ver = sys.version.split ()[[0]]; \ print (ver $1)"` if test "$ac_supports_python_ver" = "True"; then AC_MSG_RESULT([yes]) else AC_MSG_RESULT([no]) AC_MSG_ERROR([this package requires Python $1. If you have it installed, but it isn't the default Python interpreter in your system path, please pass the PYTHON_VERSION variable to configure. See ``configure --help'' for reference. ]) PYTHON_VERSION="" fi fi # # Check if you have distutils, else fail # AC_MSG_CHECKING([for the distutils Python package]) ac_distutils_result=`$PYTHON -c "import distutils" 2>&1` if test -z "$ac_distutils_result"; then AC_MSG_RESULT([yes]) else AC_MSG_RESULT([no]) AC_MSG_ERROR([cannot import Python module "distutils". Please check your Python installation. The error was: $ac_distutils_result]) PYTHON_VERSION="" fi # # Check for Python include path # AC_MSG_CHECKING([for Python include path]) if test -z "$PYTHON_CPPFLAGS"; then python_path=`$PYTHON -c "import distutils.sysconfig; \ print (distutils.sysconfig.get_python_inc ());"` plat_python_path=`$PYTHON -c "import distutils.sysconfig; \ print (distutils.sysconfig.get_python_inc (plat_specific=1));"` if test -n "${python_path}"; then if test "${plat_python_path}" != "${python_path}"; then python_path="-I$python_path -I$plat_python_path" else python_path="-I$python_path" fi fi PYTHON_CPPFLAGS=$python_path fi AC_MSG_RESULT([$PYTHON_CPPFLAGS]) AC_SUBST([PYTHON_CPPFLAGS]) # # Check for Python library path # AC_MSG_CHECKING([for Python library path]) if test -z "$PYTHON_LDFLAGS"; then # (makes two attempts to ensure we've got a version number # from the interpreter) ac_python_version=`cat<]], [[Py_Initialize();]]) ],[pythonexists=yes],[pythonexists=no]) AC_LANG_POP([C]) # turn back to default flags CPPFLAGS="$ac_save_CPPFLAGS" LIBS="$ac_save_LIBS" AC_MSG_RESULT([$pythonexists]) if test ! "x$pythonexists" = "xyes"; then AC_MSG_FAILURE([ Could not link test program to Python. Maybe the main Python library has been installed in some non-standard library path. If so, pass it to configure, via the LDFLAGS environment variable. Example: ./configure LDFLAGS="-L/usr/non-standard-path/python/lib" ============================================================================ ERROR! You probably have to install the development version of the Python package for your distribution. The exact name of this package varies among them. ============================================================================ ]) PYTHON_VERSION="" fi # # all done! # ]) ldns-1.6.17/tsig.c0000664000175100017510000002714712264060151013240 0ustar willemwillem/* * tsig.c * * contains the functions needed for TSIG [RFC2845] * * (c) 2005-2006 NLnet Labs * See the file LICENSE for the license */ #include #include #include #ifdef HAVE_SSL #include #include #endif /* HAVE_SSL */ char * ldns_tsig_algorithm(ldns_tsig_credentials *tc) { return tc->algorithm; } char * ldns_tsig_keyname(ldns_tsig_credentials *tc) { return tc->keyname; } char * ldns_tsig_keydata(ldns_tsig_credentials *tc) { return tc->keydata; } char * ldns_tsig_keyname_clone(ldns_tsig_credentials *tc) { return strdup(tc->keyname); } char * ldns_tsig_keydata_clone(ldns_tsig_credentials *tc) { return strdup(tc->keydata); } /* * Makes an exact copy of the wire, but with the tsig rr removed */ static uint8_t * ldns_tsig_prepare_pkt_wire(uint8_t *wire, size_t wire_len, size_t *result_len) { uint8_t *wire2 = NULL; uint16_t qd_count; uint16_t an_count; uint16_t ns_count; uint16_t ar_count; ldns_rr *rr; size_t pos; uint16_t i; ldns_status status; if(wire_len < LDNS_HEADER_SIZE) { return NULL; } /* fake parse the wire */ qd_count = LDNS_QDCOUNT(wire); an_count = LDNS_ANCOUNT(wire); ns_count = LDNS_NSCOUNT(wire); ar_count = LDNS_ARCOUNT(wire); if (ar_count > 0) { ar_count--; } else { return NULL; } pos = LDNS_HEADER_SIZE; for (i = 0; i < qd_count; i++) { status = ldns_wire2rr(&rr, wire, wire_len, &pos, LDNS_SECTION_QUESTION); if (status != LDNS_STATUS_OK) { return NULL; } ldns_rr_free(rr); } for (i = 0; i < an_count; i++) { status = ldns_wire2rr(&rr, wire, wire_len, &pos, LDNS_SECTION_ANSWER); if (status != LDNS_STATUS_OK) { return NULL; } ldns_rr_free(rr); } for (i = 0; i < ns_count; i++) { status = ldns_wire2rr(&rr, wire, wire_len, &pos, LDNS_SECTION_AUTHORITY); if (status != LDNS_STATUS_OK) { return NULL; } ldns_rr_free(rr); } for (i = 0; i < ar_count; i++) { status = ldns_wire2rr(&rr, wire, wire_len, &pos, LDNS_SECTION_ADDITIONAL); if (status != LDNS_STATUS_OK) { return NULL; } ldns_rr_free(rr); } *result_len = pos; wire2 = LDNS_XMALLOC(uint8_t, *result_len); if(!wire2) { return NULL; } memcpy(wire2, wire, *result_len); ldns_write_uint16(wire2 + LDNS_ARCOUNT_OFF, ar_count); return wire2; } #ifdef HAVE_SSL static const EVP_MD * ldns_digest_function(char *name) { /* these are the mandatory algorithms from RFC4635 */ /* The optional algorithms are not yet implemented */ if (strcasecmp(name, "hmac-sha256.") == 0) { #ifdef HAVE_EVP_SHA256 return EVP_sha256(); #else return NULL; #endif } else if (strcasecmp(name, "hmac-sha1.") == 0) { return EVP_sha1(); } else if (strcasecmp(name, "hmac-md5.sig-alg.reg.int.") == 0) { return EVP_md5(); } else { return NULL; } } #endif #ifdef HAVE_SSL static ldns_status ldns_tsig_mac_new(ldns_rdf **tsig_mac, uint8_t *pkt_wire, size_t pkt_wire_size, const char *key_data, ldns_rdf *key_name_rdf, ldns_rdf *fudge_rdf, ldns_rdf *algorithm_rdf, ldns_rdf *time_signed_rdf, ldns_rdf *error_rdf, ldns_rdf *other_data_rdf, ldns_rdf *orig_mac_rdf, int tsig_timers_only) { ldns_status status; char *wireformat; int wiresize; unsigned char *mac_bytes = NULL; unsigned char *key_bytes = NULL; int key_size; const EVP_MD *digester; char *algorithm_name = NULL; unsigned int md_len = EVP_MAX_MD_SIZE; ldns_rdf *result = NULL; ldns_buffer *data_buffer = NULL; ldns_rdf *canonical_key_name_rdf = NULL; ldns_rdf *canonical_algorithm_rdf = NULL; if (key_name_rdf == NULL || algorithm_rdf == NULL) { return LDNS_STATUS_NULL; } canonical_key_name_rdf = ldns_rdf_clone(key_name_rdf); if (canonical_key_name_rdf == NULL) { return LDNS_STATUS_MEM_ERR; } canonical_algorithm_rdf = ldns_rdf_clone(algorithm_rdf); if (canonical_algorithm_rdf == NULL) { ldns_rdf_deep_free(canonical_key_name_rdf); return LDNS_STATUS_MEM_ERR; } /* * prepare the digestable information */ data_buffer = ldns_buffer_new(LDNS_MAX_PACKETLEN); if (!data_buffer) { status = LDNS_STATUS_MEM_ERR; goto clean; } /* if orig_mac is not NULL, add it too */ if (orig_mac_rdf) { (void) ldns_rdf2buffer_wire(data_buffer, orig_mac_rdf); } ldns_buffer_write(data_buffer, pkt_wire, pkt_wire_size); if (!tsig_timers_only) { ldns_dname2canonical(canonical_key_name_rdf); (void)ldns_rdf2buffer_wire(data_buffer, canonical_key_name_rdf); ldns_buffer_write_u16(data_buffer, LDNS_RR_CLASS_ANY); ldns_buffer_write_u32(data_buffer, 0); ldns_dname2canonical(canonical_algorithm_rdf); (void)ldns_rdf2buffer_wire(data_buffer, canonical_algorithm_rdf); } (void)ldns_rdf2buffer_wire(data_buffer, time_signed_rdf); (void)ldns_rdf2buffer_wire(data_buffer, fudge_rdf); if (!tsig_timers_only) { (void)ldns_rdf2buffer_wire(data_buffer, error_rdf); (void)ldns_rdf2buffer_wire(data_buffer, other_data_rdf); } wireformat = (char *) data_buffer->_data; wiresize = (int) ldns_buffer_position(data_buffer); algorithm_name = ldns_rdf2str(algorithm_rdf); if(!algorithm_name) { status = LDNS_STATUS_MEM_ERR; goto clean; } /* prepare the key */ key_bytes = LDNS_XMALLOC(unsigned char, ldns_b64_pton_calculate_size(strlen(key_data))); if(!key_bytes) { status = LDNS_STATUS_MEM_ERR; goto clean; } key_size = ldns_b64_pton(key_data, key_bytes, ldns_b64_pton_calculate_size(strlen(key_data))); if (key_size < 0) { status = LDNS_STATUS_INVALID_B64; goto clean; } /* hmac it */ /* 2 spare bytes for the length */ mac_bytes = LDNS_XMALLOC(unsigned char, md_len+2); if(!mac_bytes) { status = LDNS_STATUS_MEM_ERR; goto clean; } memset(mac_bytes, 0, md_len+2); digester = ldns_digest_function(algorithm_name); if (digester) { (void) HMAC(digester, key_bytes, key_size, (void *)wireformat, (size_t) wiresize, mac_bytes + 2, &md_len); ldns_write_uint16(mac_bytes, md_len); result = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_INT16_DATA, md_len + 2, mac_bytes); } else { status = LDNS_STATUS_CRYPTO_UNKNOWN_ALGO; goto clean; } *tsig_mac = result; status = LDNS_STATUS_OK; clean: LDNS_FREE(mac_bytes); LDNS_FREE(key_bytes); LDNS_FREE(algorithm_name); ldns_buffer_free(data_buffer); ldns_rdf_deep_free(canonical_algorithm_rdf); ldns_rdf_deep_free(canonical_key_name_rdf); return status; } #endif /* HAVE_SSL */ #ifdef HAVE_SSL bool ldns_pkt_tsig_verify(ldns_pkt *pkt, uint8_t *wire, size_t wirelen, const char *key_name, const char *key_data, ldns_rdf *orig_mac_rdf) { return ldns_pkt_tsig_verify_next(pkt, wire, wirelen, key_name, key_data, orig_mac_rdf, 0); } bool ldns_pkt_tsig_verify_next(ldns_pkt *pkt, uint8_t *wire, size_t wirelen, const char* key_name, const char *key_data, ldns_rdf *orig_mac_rdf, int tsig_timers_only) { ldns_rdf *fudge_rdf; ldns_rdf *algorithm_rdf; ldns_rdf *time_signed_rdf; ldns_rdf *orig_id_rdf; ldns_rdf *error_rdf; ldns_rdf *other_data_rdf; ldns_rdf *pkt_mac_rdf; ldns_rdf *my_mac_rdf; ldns_rdf *key_name_rdf = ldns_rdf_new_frm_str(LDNS_RDF_TYPE_DNAME, key_name); uint16_t pkt_id, orig_pkt_id; ldns_status status; uint8_t *prepared_wire = NULL; size_t prepared_wire_size = 0; ldns_rr *orig_tsig = ldns_pkt_tsig(pkt); if (!orig_tsig || ldns_rr_rd_count(orig_tsig) <= 6) { ldns_rdf_deep_free(key_name_rdf); return false; } algorithm_rdf = ldns_rr_rdf(orig_tsig, 0); time_signed_rdf = ldns_rr_rdf(orig_tsig, 1); fudge_rdf = ldns_rr_rdf(orig_tsig, 2); pkt_mac_rdf = ldns_rr_rdf(orig_tsig, 3); orig_id_rdf = ldns_rr_rdf(orig_tsig, 4); error_rdf = ldns_rr_rdf(orig_tsig, 5); other_data_rdf = ldns_rr_rdf(orig_tsig, 6); /* remove temporarily */ ldns_pkt_set_tsig(pkt, NULL); /* temporarily change the id to the original id */ pkt_id = ldns_pkt_id(pkt); orig_pkt_id = ldns_rdf2native_int16(orig_id_rdf); ldns_pkt_set_id(pkt, orig_pkt_id); prepared_wire = ldns_tsig_prepare_pkt_wire(wire, wirelen, &prepared_wire_size); status = ldns_tsig_mac_new(&my_mac_rdf, prepared_wire, prepared_wire_size, key_data, key_name_rdf, fudge_rdf, algorithm_rdf, time_signed_rdf, error_rdf, other_data_rdf, orig_mac_rdf, tsig_timers_only); LDNS_FREE(prepared_wire); if (status != LDNS_STATUS_OK) { ldns_rdf_deep_free(key_name_rdf); return false; } /* Put back the values */ ldns_pkt_set_tsig(pkt, orig_tsig); ldns_pkt_set_id(pkt, pkt_id); ldns_rdf_deep_free(key_name_rdf); if (ldns_rdf_compare(pkt_mac_rdf, my_mac_rdf) == 0) { ldns_rdf_deep_free(my_mac_rdf); return true; } else { ldns_rdf_deep_free(my_mac_rdf); return false; } } #endif /* HAVE_SSL */ #ifdef HAVE_SSL ldns_status ldns_pkt_tsig_sign(ldns_pkt *pkt, const char *key_name, const char *key_data, uint16_t fudge, const char *algorithm_name, ldns_rdf *query_mac) { return ldns_pkt_tsig_sign_next(pkt, key_name, key_data, fudge, algorithm_name, query_mac, 0); } ldns_status ldns_pkt_tsig_sign_next(ldns_pkt *pkt, const char *key_name, const char *key_data, uint16_t fudge, const char *algorithm_name, ldns_rdf *query_mac, int tsig_timers_only) { ldns_rr *tsig_rr; ldns_rdf *key_name_rdf = ldns_rdf_new_frm_str(LDNS_RDF_TYPE_DNAME, key_name); ldns_rdf *fudge_rdf = NULL; ldns_rdf *orig_id_rdf = NULL; ldns_rdf *algorithm_rdf; ldns_rdf *error_rdf = NULL; ldns_rdf *mac_rdf = NULL; ldns_rdf *other_data_rdf = NULL; ldns_status status = LDNS_STATUS_OK; uint8_t *pkt_wire = NULL; size_t pkt_wire_len; struct timeval tv_time_signed; uint8_t *time_signed = NULL; ldns_rdf *time_signed_rdf = NULL; algorithm_rdf = ldns_rdf_new_frm_str(LDNS_RDF_TYPE_DNAME, algorithm_name); if(!key_name_rdf || !algorithm_rdf) { status = LDNS_STATUS_MEM_ERR; goto clean; } /* eww don't have create tsigtime rdf yet :( */ /* bleh :p */ if (gettimeofday(&tv_time_signed, NULL) == 0) { time_signed = LDNS_XMALLOC(uint8_t, 6); if(!time_signed) { status = LDNS_STATUS_MEM_ERR; goto clean; } ldns_write_uint64_as_uint48(time_signed, (uint64_t)tv_time_signed.tv_sec); } else { status = LDNS_STATUS_INTERNAL_ERR; goto clean; } time_signed_rdf = ldns_rdf_new(LDNS_RDF_TYPE_TSIGTIME, 6, time_signed); if(!time_signed_rdf) { LDNS_FREE(time_signed); status = LDNS_STATUS_MEM_ERR; goto clean; } fudge_rdf = ldns_native2rdf_int16(LDNS_RDF_TYPE_INT16, fudge); orig_id_rdf = ldns_native2rdf_int16(LDNS_RDF_TYPE_INT16, ldns_pkt_id(pkt)); error_rdf = ldns_native2rdf_int16(LDNS_RDF_TYPE_INT16, 0); other_data_rdf = ldns_native2rdf_int16_data(0, NULL); if(!fudge_rdf || !orig_id_rdf || !error_rdf || !other_data_rdf) { status = LDNS_STATUS_MEM_ERR; goto clean; } if (ldns_pkt2wire(&pkt_wire, pkt, &pkt_wire_len) != LDNS_STATUS_OK) { status = LDNS_STATUS_ERR; goto clean; } status = ldns_tsig_mac_new(&mac_rdf, pkt_wire, pkt_wire_len, key_data, key_name_rdf, fudge_rdf, algorithm_rdf, time_signed_rdf, error_rdf, other_data_rdf, query_mac, tsig_timers_only); if (!mac_rdf) { goto clean; } LDNS_FREE(pkt_wire); /* Create the TSIG RR */ tsig_rr = ldns_rr_new(); if(!tsig_rr) { status = LDNS_STATUS_MEM_ERR; goto clean; } ldns_rr_set_owner(tsig_rr, key_name_rdf); ldns_rr_set_class(tsig_rr, LDNS_RR_CLASS_ANY); ldns_rr_set_type(tsig_rr, LDNS_RR_TYPE_TSIG); ldns_rr_set_ttl(tsig_rr, 0); ldns_rr_push_rdf(tsig_rr, algorithm_rdf); ldns_rr_push_rdf(tsig_rr, time_signed_rdf); ldns_rr_push_rdf(tsig_rr, fudge_rdf); ldns_rr_push_rdf(tsig_rr, mac_rdf); ldns_rr_push_rdf(tsig_rr, orig_id_rdf); ldns_rr_push_rdf(tsig_rr, error_rdf); ldns_rr_push_rdf(tsig_rr, other_data_rdf); ldns_pkt_set_tsig(pkt, tsig_rr); return status; clean: LDNS_FREE(pkt_wire); ldns_rdf_free(key_name_rdf); ldns_rdf_free(algorithm_rdf); ldns_rdf_free(time_signed_rdf); ldns_rdf_free(fudge_rdf); ldns_rdf_free(orig_id_rdf); ldns_rdf_free(error_rdf); ldns_rdf_free(other_data_rdf); return status; } #endif /* HAVE_SSL */ ldns-1.6.17/host2str.c0000664000175100017510000021275112264060151014057 0ustar willemwillem/* * host2str.c * * conversion routines from the host format * to the presentation format (strings) * * a Net::DNS like library for C * * (c) NLnet Labs, 2004-2006 * * See the file LICENSE for the license */ #include #include #include #ifdef HAVE_SYS_SOCKET_H #include #endif #ifdef HAVE_ARPA_INET_H #include #endif #ifdef HAVE_NETDB_H #include #endif #include #include #ifndef INET_ADDRSTRLEN #define INET_ADDRSTRLEN 16 #endif #ifndef INET6_ADDRSTRLEN #define INET6_ADDRSTRLEN 46 #endif /* lookup tables for standard DNS stuff */ /* Taken from RFC 2535, section 7. */ ldns_lookup_table ldns_algorithms[] = { { LDNS_RSAMD5, "RSAMD5" }, { LDNS_DH, "DH" }, { LDNS_DSA, "DSA" }, { LDNS_ECC, "ECC" }, { LDNS_RSASHA1, "RSASHA1" }, { LDNS_DSA_NSEC3, "DSA-NSEC3-SHA1" }, { LDNS_RSASHA1_NSEC3, "RSASHA1-NSEC3-SHA1" }, #ifdef USE_SHA2 { LDNS_RSASHA256, "RSASHA256"}, { LDNS_RSASHA512, "RSASHA512"}, #endif #ifdef USE_GOST { LDNS_ECC_GOST, "ECC-GOST"}, #endif #ifdef USE_ECDSA { LDNS_ECDSAP256SHA256, "ECDSAP256SHA256"}, { LDNS_ECDSAP384SHA384, "ECDSAP384SHA384"}, #endif { LDNS_INDIRECT, "INDIRECT" }, { LDNS_PRIVATEDNS, "PRIVATEDNS" }, { LDNS_PRIVATEOID, "PRIVATEOID" }, { 0, NULL } }; /* Taken from RFC 4398 */ ldns_lookup_table ldns_cert_algorithms[] = { { LDNS_CERT_PKIX, "PKIX" }, { LDNS_CERT_SPKI, "SPKI" }, { LDNS_CERT_PGP, "PGP" }, { LDNS_CERT_IPKIX, "IPKIX" }, { LDNS_CERT_ISPKI, "ISPKI" }, { LDNS_CERT_IPGP, "IPGP" }, { LDNS_CERT_ACPKIX, "ACPKIX" }, { LDNS_CERT_IACPKIX, "IACPKIX" }, { LDNS_CERT_URI, "URI" }, { LDNS_CERT_OID, "OID" }, { 0, NULL } }; /* classes */ ldns_lookup_table ldns_rr_classes[] = { { LDNS_RR_CLASS_IN, "IN" }, { LDNS_RR_CLASS_CH, "CH" }, { LDNS_RR_CLASS_HS, "HS" }, { LDNS_RR_CLASS_NONE, "NONE" }, { LDNS_RR_CLASS_ANY, "ANY" }, { 0, NULL } }; /* if these are used elsewhere */ ldns_lookup_table ldns_rcodes[] = { { LDNS_RCODE_NOERROR, "NOERROR" }, { LDNS_RCODE_FORMERR, "FORMERR" }, { LDNS_RCODE_SERVFAIL, "SERVFAIL" }, { LDNS_RCODE_NXDOMAIN, "NXDOMAIN" }, { LDNS_RCODE_NOTIMPL, "NOTIMPL" }, { LDNS_RCODE_REFUSED, "REFUSED" }, { LDNS_RCODE_YXDOMAIN, "YXDOMAIN" }, { LDNS_RCODE_YXRRSET, "YXRRSET" }, { LDNS_RCODE_NXRRSET, "NXRRSET" }, { LDNS_RCODE_NOTAUTH, "NOTAUTH" }, { LDNS_RCODE_NOTZONE, "NOTZONE" }, { 0, NULL } }; ldns_lookup_table ldns_opcodes[] = { { LDNS_PACKET_QUERY, "QUERY" }, { LDNS_PACKET_IQUERY, "IQUERY" }, { LDNS_PACKET_STATUS, "STATUS" }, { LDNS_PACKET_NOTIFY, "NOTIFY" }, { LDNS_PACKET_UPDATE, "UPDATE" }, { 0, NULL } }; const ldns_output_format ldns_output_format_nocomments_record = { 0, NULL }; const ldns_output_format *ldns_output_format_nocomments = &ldns_output_format_nocomments_record; const ldns_output_format ldns_output_format_onlykeyids_record = { LDNS_COMMENT_KEY, NULL }; const ldns_output_format *ldns_output_format_onlykeyids = &ldns_output_format_onlykeyids_record; const ldns_output_format *ldns_output_format_default = &ldns_output_format_onlykeyids_record; const ldns_output_format ldns_output_format_bubblebabble_record = { LDNS_COMMENT_KEY | LDNS_COMMENT_BUBBLEBABBLE | LDNS_COMMENT_FLAGS, NULL }; const ldns_output_format *ldns_output_format_bubblebabble = &ldns_output_format_bubblebabble_record; static bool ldns_output_format_covers_type(const ldns_output_format* fmt, ldns_rr_type t) { return fmt && (fmt->flags & LDNS_FMT_RFC3597) && ((ldns_output_format_storage*)fmt)->bitmap && ldns_nsec_bitmap_covers_type( ((ldns_output_format_storage*)fmt)->bitmap, t); } ldns_status ldns_output_format_set_type(ldns_output_format* fmt, ldns_rr_type t) { ldns_output_format_storage* fmt_st = (ldns_output_format_storage*)fmt; ldns_status s; assert(fmt != NULL); if (!(fmt_st->flags & LDNS_FMT_RFC3597)) { ldns_output_format_set(fmt, LDNS_FMT_RFC3597); } if (! fmt_st->bitmap) { s = ldns_rdf_bitmap_known_rr_types_space(&fmt_st->bitmap); if (s != LDNS_STATUS_OK) { return s; } } return ldns_nsec_bitmap_set_type(fmt_st->bitmap, t); } ldns_status ldns_output_format_clear_type(ldns_output_format* fmt, ldns_rr_type t) { ldns_output_format_storage* fmt_st = (ldns_output_format_storage*)fmt; ldns_status s; assert(fmt != NULL); if (!(fmt_st->flags & LDNS_FMT_RFC3597)) { ldns_output_format_set(fmt, LDNS_FMT_RFC3597); } if (! fmt_st->bitmap) { s = ldns_rdf_bitmap_known_rr_types(&fmt_st->bitmap); if (s != LDNS_STATUS_OK) { return s; } } return ldns_nsec_bitmap_clear_type(fmt_st->bitmap, t); } ldns_status ldns_pkt_opcode2buffer_str(ldns_buffer *output, ldns_pkt_opcode opcode) { ldns_lookup_table *lt = ldns_lookup_by_id(ldns_opcodes, opcode); if (lt && lt->name) { ldns_buffer_printf(output, "%s", lt->name); } else { ldns_buffer_printf(output, "OPCODE%u", opcode); } return ldns_buffer_status(output); } ldns_status ldns_pkt_rcode2buffer_str(ldns_buffer *output, ldns_pkt_rcode rcode) { ldns_lookup_table *lt = ldns_lookup_by_id(ldns_rcodes, rcode); if (lt && lt->name) { ldns_buffer_printf(output, "%s", lt->name); } else { ldns_buffer_printf(output, "RCODE%u", rcode); } return ldns_buffer_status(output); } ldns_status ldns_algorithm2buffer_str(ldns_buffer *output, ldns_algorithm algorithm) { ldns_lookup_table *lt = ldns_lookup_by_id(ldns_algorithms, algorithm); if (lt && lt->name) { ldns_buffer_printf(output, "%s", lt->name); } else { ldns_buffer_printf(output, "ALG%u", algorithm); } return ldns_buffer_status(output); } ldns_status ldns_cert_algorithm2buffer_str(ldns_buffer *output, ldns_cert_algorithm cert_algorithm) { ldns_lookup_table *lt = ldns_lookup_by_id(ldns_cert_algorithms, cert_algorithm); if (lt && lt->name) { ldns_buffer_printf(output, "%s", lt->name); } else { ldns_buffer_printf(output, "CERT_ALG%u", cert_algorithm); } return ldns_buffer_status(output); } char * ldns_pkt_opcode2str(ldns_pkt_opcode opcode) { char *str; ldns_buffer *buf; buf = ldns_buffer_new(12); if (!buf) { return NULL; } str = NULL; if (ldns_pkt_opcode2buffer_str(buf, opcode) == LDNS_STATUS_OK) { str = ldns_buffer_export2str(buf); } ldns_buffer_free(buf); return str; } char * ldns_pkt_rcode2str(ldns_pkt_rcode rcode) { char *str; ldns_buffer *buf; buf = ldns_buffer_new(10); if (!buf) { return NULL; } str = NULL; if (ldns_pkt_rcode2buffer_str(buf, rcode) == LDNS_STATUS_OK) { str = ldns_buffer_export2str(buf); } ldns_buffer_free(buf); return str; } char * ldns_pkt_algorithm2str(ldns_algorithm algorithm) { char *str; ldns_buffer *buf; buf = ldns_buffer_new(10); if (!buf) { return NULL; } str = NULL; if (ldns_algorithm2buffer_str(buf, algorithm) == LDNS_STATUS_OK) { str = ldns_buffer_export2str(buf); } ldns_buffer_free(buf); return str; } char * ldns_pkt_cert_algorithm2str(ldns_cert_algorithm cert_algorithm) { char *str; ldns_buffer *buf; buf = ldns_buffer_new(10); if (!buf) { return NULL; } str = NULL; if (ldns_cert_algorithm2buffer_str(buf, cert_algorithm) == LDNS_STATUS_OK) { str = ldns_buffer_export2str(buf); } ldns_buffer_free(buf); return str; } /* do NOT pass compressed data here :p */ ldns_status ldns_rdf2buffer_str_dname(ldns_buffer *output, const ldns_rdf *dname) { /* can we do with 1 pos var? or without at all? */ uint8_t src_pos = 0; uint8_t len; uint8_t *data; uint8_t i; unsigned char c; data = (uint8_t*)ldns_rdf_data(dname); len = data[src_pos]; if (ldns_rdf_size(dname) > LDNS_MAX_DOMAINLEN) { /* too large, return */ return LDNS_STATUS_DOMAINNAME_OVERFLOW; } /* special case: root label */ if (1 == ldns_rdf_size(dname)) { ldns_buffer_printf(output, "."); } else { while ((len > 0) && src_pos < ldns_rdf_size(dname)) { src_pos++; for(i = 0; i < len; i++) { /* paranoia check for various 'strange' characters in dnames */ c = (unsigned char) data[src_pos]; if(c == '.' || c == ';' || c == '(' || c == ')' || c == '\\') { ldns_buffer_printf(output, "\\%c", data[src_pos]); } else if (!(isascii(c) && isgraph(c))) { ldns_buffer_printf(output, "\\%03u", data[src_pos]); } else { ldns_buffer_printf(output, "%c", data[src_pos]); } src_pos++; } if (src_pos < ldns_rdf_size(dname)) { ldns_buffer_printf(output, "."); } len = data[src_pos]; } } return ldns_buffer_status(output); } ldns_status ldns_rdf2buffer_str_int8(ldns_buffer *output, const ldns_rdf *rdf) { uint8_t data = ldns_rdf_data(rdf)[0]; ldns_buffer_printf(output, "%lu", (unsigned long) data); return ldns_buffer_status(output); } ldns_status ldns_rdf2buffer_str_int16(ldns_buffer *output, const ldns_rdf *rdf) { uint16_t data = ldns_read_uint16(ldns_rdf_data(rdf)); ldns_buffer_printf(output, "%lu", (unsigned long) data); return ldns_buffer_status(output); } ldns_status ldns_rdf2buffer_str_int32(ldns_buffer *output, const ldns_rdf *rdf) { uint32_t data = ldns_read_uint32(ldns_rdf_data(rdf)); ldns_buffer_printf(output, "%lu", (unsigned long) data); return ldns_buffer_status(output); } ldns_status ldns_rdf2buffer_str_time(ldns_buffer *output, const ldns_rdf *rdf) { /* create a YYYYMMDDHHMMSS string if possible */ struct tm tm; char date_buf[16]; memset(&tm, 0, sizeof(tm)); if (ldns_serial_arithmitics_gmtime_r(ldns_rdf2native_int32(rdf), time(NULL), &tm) && strftime(date_buf, 15, "%Y%m%d%H%M%S", &tm)) { ldns_buffer_printf(output, "%s", date_buf); } return ldns_buffer_status(output); } ldns_status ldns_rdf2buffer_str_a(ldns_buffer *output, const ldns_rdf *rdf) { char str[INET_ADDRSTRLEN]; if (inet_ntop(AF_INET, ldns_rdf_data(rdf), str, INET_ADDRSTRLEN)) { ldns_buffer_printf(output, "%s", str); } return ldns_buffer_status(output); } ldns_status ldns_rdf2buffer_str_aaaa(ldns_buffer *output, const ldns_rdf *rdf) { char str[INET6_ADDRSTRLEN]; if (inet_ntop(AF_INET6, ldns_rdf_data(rdf), str, INET6_ADDRSTRLEN)) { ldns_buffer_printf(output, "%s", str); } return ldns_buffer_status(output); } static void ldns_characters2buffer_str(ldns_buffer* output, size_t amount, const uint8_t* characters) { uint8_t ch; while (amount > 0) { ch = *characters++; if (isprint((int)ch) || ch == '\t') { if (ch == '\"' || ch == '\\') ldns_buffer_printf(output, "\\%c", ch); else ldns_buffer_printf(output, "%c", ch); } else { ldns_buffer_printf(output, "\\%03u", (unsigned)(uint8_t) ch); } amount--; } } ldns_status ldns_rdf2buffer_str_str(ldns_buffer *output, const ldns_rdf *rdf) { if(ldns_rdf_size(rdf) < 1) { return LDNS_STATUS_WIRE_RDATA_ERR; } if((int)ldns_rdf_size(rdf) < (int)ldns_rdf_data(rdf)[0] + 1) { return LDNS_STATUS_WIRE_RDATA_ERR; } ldns_buffer_printf(output, "\""); ldns_characters2buffer_str(output, ldns_rdf_data(rdf)[0], ldns_rdf_data(rdf) + 1); ldns_buffer_printf(output, "\""); return ldns_buffer_status(output); } ldns_status ldns_rdf2buffer_str_b64(ldns_buffer *output, const ldns_rdf *rdf) { size_t size = ldns_b64_ntop_calculate_size(ldns_rdf_size(rdf)); char *b64 = LDNS_XMALLOC(char, size); if(!b64) return LDNS_STATUS_MEM_ERR; if (ldns_b64_ntop(ldns_rdf_data(rdf), ldns_rdf_size(rdf), b64, size)) { ldns_buffer_printf(output, "%s", b64); } LDNS_FREE(b64); return ldns_buffer_status(output); } ldns_status ldns_rdf2buffer_str_b32_ext(ldns_buffer *output, const ldns_rdf *rdf) { size_t size; char *b32; if(ldns_rdf_size(rdf) == 0) return LDNS_STATUS_OK; /* remove -1 for the b32-hash-len octet */ size = ldns_b32_ntop_calculate_size(ldns_rdf_size(rdf) - 1); /* add one for the end nul for the string */ b32 = LDNS_XMALLOC(char, size + 1); if(!b32) return LDNS_STATUS_MEM_ERR; size = (size_t) ldns_b32_ntop_extended_hex(ldns_rdf_data(rdf) + 1, ldns_rdf_size(rdf) - 1, b32, size+1); if (size > 0) { ldns_buffer_printf(output, "%s", b32); } LDNS_FREE(b32); return ldns_buffer_status(output); } ldns_status ldns_rdf2buffer_str_hex(ldns_buffer *output, const ldns_rdf *rdf) { size_t i; for (i = 0; i < ldns_rdf_size(rdf); i++) { ldns_buffer_printf(output, "%02x", ldns_rdf_data(rdf)[i]); } return ldns_buffer_status(output); } ldns_status ldns_rdf2buffer_str_type_fmt(ldns_buffer *output, const ldns_output_format* fmt, const ldns_rdf *rdf) { uint16_t data = ldns_read_uint16(ldns_rdf_data(rdf)); if (! ldns_output_format_covers_type(fmt, data) && ldns_rr_descript(data) && ldns_rr_descript(data)->_name) { ldns_buffer_printf(output, "%s",ldns_rr_descript(data)->_name); } else { ldns_buffer_printf(output, "TYPE%u", data); } return ldns_buffer_status(output); } ldns_status ldns_rdf2buffer_str_type(ldns_buffer *output, const ldns_rdf *rdf) { return ldns_rdf2buffer_str_type_fmt(output, ldns_output_format_default, rdf); } ldns_status ldns_rdf2buffer_str_class(ldns_buffer *output, const ldns_rdf *rdf) { uint16_t data = ldns_read_uint16(ldns_rdf_data(rdf)); ldns_lookup_table *lt; lt = ldns_lookup_by_id(ldns_rr_classes, (int) data); if (lt) { ldns_buffer_printf(output, "\t%s", lt->name); } else { ldns_buffer_printf(output, "\tCLASS%d", data); } return ldns_buffer_status(output); } ldns_status ldns_rdf2buffer_str_cert_alg(ldns_buffer *output, const ldns_rdf *rdf) { uint16_t data = ldns_read_uint16(ldns_rdf_data(rdf)); ldns_lookup_table *lt; lt = ldns_lookup_by_id(ldns_cert_algorithms, (int) data); if (lt) { ldns_buffer_printf(output, "%s", lt->name); } else { ldns_buffer_printf(output, "%d", data); } return ldns_buffer_status(output); } ldns_status ldns_rdf2buffer_str_alg(ldns_buffer *output, const ldns_rdf *rdf) { /* don't use algorithm mnemonics in the presentation format this kind of got sneaked into the rfc's */ uint8_t data = ldns_rdf_data(rdf)[0]; ldns_buffer_printf(output, "%d", data); return ldns_buffer_status(output); } static void loc_cm_print(ldns_buffer *output, uint8_t mantissa, uint8_t exponent) { uint8_t i; /* is it 0. ? */ if(exponent < 2) { if(exponent == 1) mantissa *= 10; ldns_buffer_printf(output, "0.%02ld", (long)mantissa); return; } /* always */ ldns_buffer_printf(output, "%d", (int)mantissa); for(i=0; i_name) { ldns_buffer_printf(output, "%s", descriptor->_name); } else { /* exceptions for pseudotypes */ switch (type) { case LDNS_RR_TYPE_IXFR: ldns_buffer_printf(output, "IXFR"); break; case LDNS_RR_TYPE_AXFR: ldns_buffer_printf(output, "AXFR"); break; case LDNS_RR_TYPE_MAILA: ldns_buffer_printf(output, "MAILA"); break; case LDNS_RR_TYPE_MAILB: ldns_buffer_printf(output, "MAILB"); break; case LDNS_RR_TYPE_ANY: ldns_buffer_printf(output, "ANY"); break; default: ldns_buffer_printf(output, "TYPE%u", type); } } return ldns_buffer_status(output); } char * ldns_rr_type2str(const ldns_rr_type type) { char *str; ldns_buffer *buf; buf = ldns_buffer_new(10); if (!buf) { return NULL; } str = NULL; if (ldns_rr_type2buffer_str(buf, type) == LDNS_STATUS_OK) { str = ldns_buffer_export2str(buf); } ldns_buffer_free(buf); return str; } ldns_status ldns_rr_class2buffer_str(ldns_buffer *output, const ldns_rr_class klass) { ldns_lookup_table *lt; lt = ldns_lookup_by_id(ldns_rr_classes, klass); if (lt) { ldns_buffer_printf(output, "%s", lt->name); } else { ldns_buffer_printf(output, "CLASS%d", klass); } return ldns_buffer_status(output); } char * ldns_rr_class2str(const ldns_rr_class klass) { ldns_buffer *buf; char *str; buf = ldns_buffer_new(10); if (!buf) { return NULL; } str = NULL; if (ldns_rr_class2buffer_str(buf, klass) == LDNS_STATUS_OK) { str = ldns_buffer_export2str(buf); } ldns_buffer_free(buf); return str; } ldns_status ldns_rdf2buffer_str_loc(ldns_buffer *output, const ldns_rdf *rdf) { /* we could do checking (ie degrees < 90 etc)? */ uint8_t version; uint8_t size; uint8_t horizontal_precision; uint8_t vertical_precision; uint32_t longitude; uint32_t latitude; uint32_t altitude; char northerness; char easterness; uint32_t h; uint32_t m; double s; uint32_t equator = (uint32_t) ldns_power(2, 31); if(ldns_rdf_size(rdf) < 1) { return LDNS_STATUS_WIRE_RDATA_ERR; } version = ldns_rdf_data(rdf)[0]; if (version == 0) { if(ldns_rdf_size(rdf) < 16) { return LDNS_STATUS_WIRE_RDATA_ERR; } size = ldns_rdf_data(rdf)[1]; horizontal_precision = ldns_rdf_data(rdf)[2]; vertical_precision = ldns_rdf_data(rdf)[3]; latitude = ldns_read_uint32(&ldns_rdf_data(rdf)[4]); longitude = ldns_read_uint32(&ldns_rdf_data(rdf)[8]); altitude = ldns_read_uint32(&ldns_rdf_data(rdf)[12]); if (latitude > equator) { northerness = 'N'; latitude = latitude - equator; } else { northerness = 'S'; latitude = equator - latitude; } h = latitude / (1000 * 60 * 60); latitude = latitude % (1000 * 60 * 60); m = latitude / (1000 * 60); latitude = latitude % (1000 * 60); s = (double) latitude / 1000.0; ldns_buffer_printf(output, "%02u %02u %0.3f %c ", h, m, s, northerness); if (longitude > equator) { easterness = 'E'; longitude = longitude - equator; } else { easterness = 'W'; longitude = equator - longitude; } h = longitude / (1000 * 60 * 60); longitude = longitude % (1000 * 60 * 60); m = longitude / (1000 * 60); longitude = longitude % (1000 * 60); s = (double) longitude / (1000.0); ldns_buffer_printf(output, "%02u %02u %0.3f %c ", h, m, s, easterness); s = ((double) altitude) / 100; s -= 100000; if(altitude%100 != 0) ldns_buffer_printf(output, "%.2f", s); else ldns_buffer_printf(output, "%.0f", s); ldns_buffer_printf(output, "m "); loc_cm_print(output, (size & 0xf0) >> 4, size & 0x0f); ldns_buffer_printf(output, "m "); loc_cm_print(output, (horizontal_precision & 0xf0) >> 4, horizontal_precision & 0x0f); ldns_buffer_printf(output, "m "); loc_cm_print(output, (vertical_precision & 0xf0) >> 4, vertical_precision & 0x0f); ldns_buffer_printf(output, "m"); return ldns_buffer_status(output); } else { return ldns_rdf2buffer_str_hex(output, rdf); } } ldns_status ldns_rdf2buffer_str_unknown(ldns_buffer *output, const ldns_rdf *rdf) { ldns_buffer_printf(output, "\\# %u ", ldns_rdf_size(rdf)); return ldns_rdf2buffer_str_hex(output, rdf); } ldns_status ldns_rdf2buffer_str_nsap(ldns_buffer *output, const ldns_rdf *rdf) { ldns_buffer_printf(output, "0x"); return ldns_rdf2buffer_str_hex(output, rdf); } ldns_status ldns_rdf2buffer_str_atma(ldns_buffer *output, const ldns_rdf *rdf) { return ldns_rdf2buffer_str_hex(output, rdf); } ldns_status ldns_rdf2buffer_str_wks(ldns_buffer *output, const ldns_rdf *rdf) { /* protocol, followed by bitmap of services */ struct protoent *protocol; char *proto_name = NULL; uint8_t protocol_nr; struct servent *service; uint16_t current_service; if(ldns_rdf_size(rdf) < 1) { return LDNS_STATUS_WIRE_RDATA_ERR; } protocol_nr = ldns_rdf_data(rdf)[0]; protocol = getprotobynumber((int) protocol_nr); if (protocol && (protocol->p_name != NULL)) { proto_name = protocol->p_name; ldns_buffer_printf(output, "%s ", protocol->p_name); } else { ldns_buffer_printf(output, "%u ", protocol_nr); } #ifdef HAVE_ENDPROTOENT endprotoent(); #endif for (current_service = 0; current_service < ldns_rdf_size(rdf) * 7; current_service++) { if (ldns_get_bit(&(ldns_rdf_data(rdf)[1]), current_service)) { service = getservbyport((int) htons(current_service), proto_name); if (service && service->s_name) { ldns_buffer_printf(output, "%s ", service->s_name); } else { ldns_buffer_printf(output, "%u ", current_service); } #ifdef HAVE_ENDSERVENT endservent(); #endif } } return ldns_buffer_status(output); } ldns_status ldns_rdf2buffer_str_nsec_fmt(ldns_buffer *output, const ldns_output_format* fmt, const ldns_rdf *rdf) { /* Note: this code is duplicated in higher.c in * ldns_nsec_type_check() function */ uint8_t window_block_nr; uint8_t bitmap_length; uint16_t type; uint16_t pos = 0; uint16_t bit_pos; uint8_t *data = ldns_rdf_data(rdf); while((size_t)(pos + 2) < ldns_rdf_size(rdf)) { window_block_nr = data[pos]; bitmap_length = data[pos + 1]; pos += 2; if (ldns_rdf_size(rdf) < pos + bitmap_length) { return LDNS_STATUS_WIRE_RDATA_ERR; } for (bit_pos = 0; bit_pos < (bitmap_length) * 8; bit_pos++) { if (! ldns_get_bit(&data[pos], bit_pos)) { continue; } type = 256 * (uint16_t) window_block_nr + bit_pos; if (! ldns_output_format_covers_type(fmt, type) && ldns_rr_descript(type) && ldns_rr_descript(type)->_name){ ldns_buffer_printf(output, "%s ", ldns_rr_descript(type)->_name); } else { ldns_buffer_printf(output, "TYPE%u ", type); } } pos += (uint16_t) bitmap_length; } return ldns_buffer_status(output); } ldns_status ldns_rdf2buffer_str_nsec(ldns_buffer *output, const ldns_rdf *rdf) { return ldns_rdf2buffer_str_nsec_fmt(output, ldns_output_format_default, rdf); } ldns_status ldns_rdf2buffer_str_nsec3_salt(ldns_buffer *output, const ldns_rdf *rdf) { uint8_t salt_length; uint8_t salt_pos; uint8_t *data = ldns_rdf_data(rdf); if(ldns_rdf_size(rdf) < 1) { return LDNS_STATUS_WIRE_RDATA_ERR; } salt_length = data[0]; /* from now there are variable length entries so remember pos */ if (salt_length == 0 || ((size_t)salt_length)+1 > ldns_rdf_size(rdf)) { ldns_buffer_printf(output, "- "); } else { for (salt_pos = 0; salt_pos < salt_length; salt_pos++) { ldns_buffer_printf(output, "%02x", data[1 + salt_pos]); } ldns_buffer_printf(output, " "); } return ldns_buffer_status(output); } ldns_status ldns_rdf2buffer_str_period(ldns_buffer *output, const ldns_rdf *rdf) { /* period is the number of seconds */ if (ldns_rdf_size(rdf) != 4) { return LDNS_STATUS_WIRE_RDATA_ERR; } ldns_buffer_printf(output, "%u", ldns_read_uint32(ldns_rdf_data(rdf))); return ldns_buffer_status(output); } ldns_status ldns_rdf2buffer_str_tsigtime(ldns_buffer *output,const ldns_rdf *rdf) { /* tsigtime is 48 bits network order unsigned integer */ uint64_t tsigtime = 0; uint8_t *data = ldns_rdf_data(rdf); uint64_t d0, d1, d2, d3, d4, d5; if (ldns_rdf_size(rdf) < 6) { return LDNS_STATUS_WIRE_RDATA_ERR; } d0 = data[0]; /* cast to uint64 for shift operations */ d1 = data[1]; d2 = data[2]; d3 = data[3]; d4 = data[4]; d5 = data[5]; tsigtime = (d0<<40) | (d1<<32) | (d2<<24) | (d3<<16) | (d4<<8) | d5; ldns_buffer_printf(output, "%llu ", (long long)tsigtime); return ldns_buffer_status(output); } ldns_status ldns_rdf2buffer_str_apl(ldns_buffer *output, const ldns_rdf *rdf) { uint8_t *data = ldns_rdf_data(rdf); uint16_t address_family; uint8_t prefix; bool negation; uint8_t adf_length; size_t i; size_t pos = 0; while (pos < (unsigned int) ldns_rdf_size(rdf)) { if(pos + 3 >= (unsigned)ldns_rdf_size(rdf)) return LDNS_STATUS_WIRE_RDATA_ERR; address_family = ldns_read_uint16(&data[pos]); prefix = data[pos + 2]; negation = data[pos + 3] & LDNS_APL_NEGATION; adf_length = data[pos + 3] & LDNS_APL_MASK; if (address_family == LDNS_APL_IP4) { /* check if prefix < 32? */ if (negation) { ldns_buffer_printf(output, "!"); } ldns_buffer_printf(output, "%u:", address_family); /* address is variable length 0 - 4 */ for (i = 0; i < 4; i++) { if (i > 0) { ldns_buffer_printf(output, "."); } if (i < (unsigned short) adf_length) { if(pos+i+4 >= ldns_rdf_size(rdf)) return LDNS_STATUS_WIRE_RDATA_ERR; ldns_buffer_printf(output, "%d", data[pos + i + 4]); } else { ldns_buffer_printf(output, "0"); } } ldns_buffer_printf(output, "/%u ", prefix); } else if (address_family == LDNS_APL_IP6) { /* check if prefix < 128? */ if (negation) { ldns_buffer_printf(output, "!"); } ldns_buffer_printf(output, "%u:", address_family); /* address is variable length 0 - 16 */ for (i = 0; i < 16; i++) { if (i % 2 == 0 && i > 0) { ldns_buffer_printf(output, ":"); } if (i < (unsigned short) adf_length) { if(pos+i+4 >= ldns_rdf_size(rdf)) return LDNS_STATUS_WIRE_RDATA_ERR; ldns_buffer_printf(output, "%02x", data[pos + i + 4]); } else { ldns_buffer_printf(output, "00"); } } ldns_buffer_printf(output, "/%u ", prefix); } else { /* unknown address family */ ldns_buffer_printf(output, "Unknown address family: %u data: ", address_family); for (i = 1; i < (unsigned short) (4 + adf_length); i++) { if(pos+i >= ldns_rdf_size(rdf)) return LDNS_STATUS_WIRE_RDATA_ERR; ldns_buffer_printf(output, "%02x", data[i]); } } pos += 4 + adf_length; } return ldns_buffer_status(output); } ldns_status ldns_rdf2buffer_str_int16_data(ldns_buffer *output, const ldns_rdf *rdf) { size_t size; char *b64; if (ldns_rdf_size(rdf) < 2) { return LDNS_STATUS_WIRE_RDATA_ERR; } /* Subtract the size (2) of the number that specifies the length */ size = ldns_b64_ntop_calculate_size(ldns_rdf_size(rdf) - 2); ldns_buffer_printf(output, "%u ", ldns_rdf_size(rdf) - 2); if (ldns_rdf_size(rdf) > 2) { b64 = LDNS_XMALLOC(char, size); if(!b64) return LDNS_STATUS_MEM_ERR; if (ldns_rdf_size(rdf) > 2 && ldns_b64_ntop(ldns_rdf_data(rdf) + 2, ldns_rdf_size(rdf) - 2, b64, size)) { ldns_buffer_printf(output, "%s", b64); } LDNS_FREE(b64); } return ldns_buffer_status(output); } ldns_status ldns_rdf2buffer_str_ipseckey(ldns_buffer *output, const ldns_rdf *rdf) { /* wire format from http://www.ietf.org/internet-drafts/draft-ietf-ipseckey-rr-12.txt */ uint8_t *data = ldns_rdf_data(rdf); uint8_t precedence; uint8_t gateway_type; uint8_t algorithm; ldns_rdf *gateway = NULL; uint8_t *gateway_data; size_t public_key_size; uint8_t *public_key_data; ldns_rdf *public_key; size_t offset = 0; ldns_status status; if (ldns_rdf_size(rdf) < 3) { return LDNS_STATUS_WIRE_RDATA_ERR; } precedence = data[0]; gateway_type = data[1]; algorithm = data[2]; offset = 3; switch (gateway_type) { case 0: /* no gateway */ break; case 1: gateway_data = LDNS_XMALLOC(uint8_t, LDNS_IP4ADDRLEN); if(!gateway_data) return LDNS_STATUS_MEM_ERR; if (ldns_rdf_size(rdf) < offset + LDNS_IP4ADDRLEN) { return LDNS_STATUS_ERR; } memcpy(gateway_data, &data[offset], LDNS_IP4ADDRLEN); gateway = ldns_rdf_new(LDNS_RDF_TYPE_A, LDNS_IP4ADDRLEN , gateway_data); offset += LDNS_IP4ADDRLEN; if(!gateway) { LDNS_FREE(gateway_data); return LDNS_STATUS_MEM_ERR; } break; case 2: gateway_data = LDNS_XMALLOC(uint8_t, LDNS_IP6ADDRLEN); if(!gateway_data) return LDNS_STATUS_MEM_ERR; if (ldns_rdf_size(rdf) < offset + LDNS_IP6ADDRLEN) { return LDNS_STATUS_ERR; } memcpy(gateway_data, &data[offset], LDNS_IP6ADDRLEN); offset += LDNS_IP6ADDRLEN; gateway = ldns_rdf_new(LDNS_RDF_TYPE_AAAA, LDNS_IP6ADDRLEN, gateway_data); if(!gateway) { LDNS_FREE(gateway_data); return LDNS_STATUS_MEM_ERR; } break; case 3: status = ldns_wire2dname(&gateway, data, ldns_rdf_size(rdf), &offset); if(status != LDNS_STATUS_OK) return status; break; default: /* error? */ break; } if (ldns_rdf_size(rdf) <= offset) { return LDNS_STATUS_ERR; } public_key_size = ldns_rdf_size(rdf) - offset; public_key_data = LDNS_XMALLOC(uint8_t, public_key_size); if(!public_key_data) { ldns_rdf_free(gateway); return LDNS_STATUS_MEM_ERR; } memcpy(public_key_data, &data[offset], public_key_size); public_key = ldns_rdf_new(LDNS_RDF_TYPE_B64, public_key_size, public_key_data); if(!public_key) { LDNS_FREE(public_key_data); ldns_rdf_free(gateway); return LDNS_STATUS_MEM_ERR; } ldns_buffer_printf(output, "%u %u %u ", precedence, gateway_type, algorithm); if (gateway) (void) ldns_rdf2buffer_str(output, gateway); else ldns_buffer_printf(output, "."); ldns_buffer_printf(output, " "); (void) ldns_rdf2buffer_str(output, public_key); ldns_rdf_free(gateway); ldns_rdf_free(public_key); return ldns_buffer_status(output); } ldns_status ldns_rdf2buffer_str_ilnp64(ldns_buffer *output, const ldns_rdf *rdf) { if (ldns_rdf_size(rdf) != 8) { return LDNS_STATUS_WIRE_RDATA_ERR; } ldns_buffer_printf(output,"%.4x:%.4x:%.4x:%.4x", ldns_read_uint16(ldns_rdf_data(rdf)), ldns_read_uint16(ldns_rdf_data(rdf)+2), ldns_read_uint16(ldns_rdf_data(rdf)+4), ldns_read_uint16(ldns_rdf_data(rdf)+6)); return ldns_buffer_status(output); } ldns_status ldns_rdf2buffer_str_eui48(ldns_buffer *output, const ldns_rdf *rdf) { if (ldns_rdf_size(rdf) != 6) { return LDNS_STATUS_WIRE_RDATA_ERR; } ldns_buffer_printf(output,"%.2x-%.2x-%.2x-%.2x-%.2x-%.2x", ldns_rdf_data(rdf)[0], ldns_rdf_data(rdf)[1], ldns_rdf_data(rdf)[2], ldns_rdf_data(rdf)[3], ldns_rdf_data(rdf)[4], ldns_rdf_data(rdf)[5]); return ldns_buffer_status(output); } ldns_status ldns_rdf2buffer_str_eui64(ldns_buffer *output, const ldns_rdf *rdf) { if (ldns_rdf_size(rdf) != 8) { return LDNS_STATUS_WIRE_RDATA_ERR; } ldns_buffer_printf(output,"%.2x-%.2x-%.2x-%.2x-%.2x-%.2x-%.2x-%.2x", ldns_rdf_data(rdf)[0], ldns_rdf_data(rdf)[1], ldns_rdf_data(rdf)[2], ldns_rdf_data(rdf)[3], ldns_rdf_data(rdf)[4], ldns_rdf_data(rdf)[5], ldns_rdf_data(rdf)[6], ldns_rdf_data(rdf)[7]); return ldns_buffer_status(output); } ldns_status ldns_rdf2buffer_str_tag(ldns_buffer *output, const ldns_rdf *rdf) { size_t nchars; const uint8_t* chars; char ch; if (ldns_rdf_size(rdf) < 2) { return LDNS_STATUS_WIRE_RDATA_ERR; } nchars = ldns_rdf_data(rdf)[0]; if (nchars >= ldns_rdf_size(rdf) || /* should be rdf_size - 1 */ nchars < 1) { return LDNS_STATUS_WIRE_RDATA_ERR; } chars = ldns_rdf_data(rdf) + 1; while (nchars > 0) { ch = (char)*chars++; if (! isalnum(ch)) { return LDNS_STATUS_WIRE_RDATA_ERR; } ldns_buffer_printf(output, "%c", ch); nchars--; } return ldns_buffer_status(output); } ldns_status ldns_rdf2buffer_str_long_str(ldns_buffer *output, const ldns_rdf *rdf) { ldns_buffer_printf(output, "\""); ldns_characters2buffer_str(output, ldns_rdf_size(rdf), ldns_rdf_data(rdf)); ldns_buffer_printf(output, "\""); return ldns_buffer_status(output); } ldns_status ldns_rdf2buffer_str_hip(ldns_buffer *output, const ldns_rdf *rdf) { uint8_t *data = ldns_rdf_data(rdf); size_t rdf_size = ldns_rdf_size(rdf); uint8_t hit_size; uint16_t pk_size; int written; if (rdf_size < 6) { return LDNS_STATUS_WIRE_RDATA_ERR; } if ((hit_size = data[0]) == 0 || (pk_size = ldns_read_uint16(data + 2)) == 0 || rdf_size < (size_t) hit_size + pk_size + 4) { return LDNS_STATUS_WIRE_RDATA_ERR; } ldns_buffer_printf(output, "%d ", (int) data[1]); for (data += 4; hit_size > 0; hit_size--, data++) { ldns_buffer_printf(output, "%02x", (int) *data); } ldns_buffer_write_u8(output, (uint8_t) ' '); if (ldns_buffer_reserve(output, ldns_b64_ntop_calculate_size(pk_size))) { written = ldns_b64_ntop(data, pk_size, (char *) ldns_buffer_current(output), ldns_buffer_remaining(output)); if (written > 0 && written < (int) ldns_buffer_remaining(output)) { output->_position += written; } } return ldns_buffer_status(output); } ldns_status ldns_rdf2buffer_str_fmt(ldns_buffer *buffer, const ldns_output_format* fmt, const ldns_rdf *rdf) { ldns_status res = LDNS_STATUS_OK; /*ldns_buffer_printf(buffer, "%u:", ldns_rdf_get_type(rdf));*/ if (rdf) { switch(ldns_rdf_get_type(rdf)) { case LDNS_RDF_TYPE_NONE: break; case LDNS_RDF_TYPE_DNAME: res = ldns_rdf2buffer_str_dname(buffer, rdf); break; case LDNS_RDF_TYPE_INT8: res = ldns_rdf2buffer_str_int8(buffer, rdf); break; case LDNS_RDF_TYPE_INT16: res = ldns_rdf2buffer_str_int16(buffer, rdf); break; case LDNS_RDF_TYPE_INT32: res = ldns_rdf2buffer_str_int32(buffer, rdf); break; case LDNS_RDF_TYPE_PERIOD: res = ldns_rdf2buffer_str_period(buffer, rdf); break; case LDNS_RDF_TYPE_TSIGTIME: res = ldns_rdf2buffer_str_tsigtime(buffer, rdf); break; case LDNS_RDF_TYPE_A: res = ldns_rdf2buffer_str_a(buffer, rdf); break; case LDNS_RDF_TYPE_AAAA: res = ldns_rdf2buffer_str_aaaa(buffer, rdf); break; case LDNS_RDF_TYPE_STR: res = ldns_rdf2buffer_str_str(buffer, rdf); break; case LDNS_RDF_TYPE_APL: res = ldns_rdf2buffer_str_apl(buffer, rdf); break; case LDNS_RDF_TYPE_B32_EXT: res = ldns_rdf2buffer_str_b32_ext(buffer, rdf); break; case LDNS_RDF_TYPE_B64: res = ldns_rdf2buffer_str_b64(buffer, rdf); break; case LDNS_RDF_TYPE_HEX: res = ldns_rdf2buffer_str_hex(buffer, rdf); break; case LDNS_RDF_TYPE_NSEC: res = ldns_rdf2buffer_str_nsec_fmt(buffer, fmt, rdf); break; case LDNS_RDF_TYPE_NSEC3_SALT: res = ldns_rdf2buffer_str_nsec3_salt(buffer, rdf); break; case LDNS_RDF_TYPE_TYPE: res = ldns_rdf2buffer_str_type_fmt(buffer, fmt, rdf); break; case LDNS_RDF_TYPE_CLASS: res = ldns_rdf2buffer_str_class(buffer, rdf); break; case LDNS_RDF_TYPE_CERT_ALG: res = ldns_rdf2buffer_str_cert_alg(buffer, rdf); break; case LDNS_RDF_TYPE_ALG: res = ldns_rdf2buffer_str_alg(buffer, rdf); break; case LDNS_RDF_TYPE_UNKNOWN: res = ldns_rdf2buffer_str_unknown(buffer, rdf); break; case LDNS_RDF_TYPE_TIME: res = ldns_rdf2buffer_str_time(buffer, rdf); break; case LDNS_RDF_TYPE_HIP: res = ldns_rdf2buffer_str_hip(buffer, rdf); break; case LDNS_RDF_TYPE_LOC: res = ldns_rdf2buffer_str_loc(buffer, rdf); break; case LDNS_RDF_TYPE_WKS: case LDNS_RDF_TYPE_SERVICE: res = ldns_rdf2buffer_str_wks(buffer, rdf); break; case LDNS_RDF_TYPE_NSAP: res = ldns_rdf2buffer_str_nsap(buffer, rdf); break; case LDNS_RDF_TYPE_ATMA: res = ldns_rdf2buffer_str_atma(buffer, rdf); break; case LDNS_RDF_TYPE_IPSECKEY: res = ldns_rdf2buffer_str_ipseckey(buffer, rdf); break; case LDNS_RDF_TYPE_INT16_DATA: res = ldns_rdf2buffer_str_int16_data(buffer, rdf); break; case LDNS_RDF_TYPE_NSEC3_NEXT_OWNER: res = ldns_rdf2buffer_str_b32_ext(buffer, rdf); break; case LDNS_RDF_TYPE_ILNP64: res = ldns_rdf2buffer_str_ilnp64(buffer, rdf); break; case LDNS_RDF_TYPE_EUI48: res = ldns_rdf2buffer_str_eui48(buffer, rdf); break; case LDNS_RDF_TYPE_EUI64: res = ldns_rdf2buffer_str_eui64(buffer, rdf); break; case LDNS_RDF_TYPE_TAG: res = ldns_rdf2buffer_str_tag(buffer, rdf); break; case LDNS_RDF_TYPE_LONG_STR: res = ldns_rdf2buffer_str_long_str(buffer, rdf); break; } } else { /** This will write mangled RRs */ ldns_buffer_printf(buffer, "(null) "); res = LDNS_STATUS_ERR; } return res; } ldns_status ldns_rdf2buffer_str(ldns_buffer *buffer, const ldns_rdf *rdf) { return ldns_rdf2buffer_str_fmt(buffer,ldns_output_format_default,rdf); } static ldns_rdf * ldns_b32_ext2dname(const ldns_rdf *rdf) { size_t size; char *b32; ldns_rdf *out; if(ldns_rdf_size(rdf) == 0) return NULL; /* remove -1 for the b32-hash-len octet */ size = ldns_b32_ntop_calculate_size(ldns_rdf_size(rdf) - 1); /* add one for the end nul for the string */ b32 = LDNS_XMALLOC(char, size + 2); if (b32) { if (ldns_b32_ntop_extended_hex(ldns_rdf_data(rdf) + 1, ldns_rdf_size(rdf) - 1, b32, size+1) > 0) { b32[size] = '.'; b32[size+1] = '\0'; if (ldns_str2rdf_dname(&out, b32) == LDNS_STATUS_OK) { LDNS_FREE(b32); return out; } } LDNS_FREE(b32); } return NULL; } static ldns_status ldns_rr2buffer_str_rfc3597(ldns_buffer *output, const ldns_rr *rr) { size_t total_rdfsize = 0; size_t i, j; ldns_buffer_printf(output, "TYPE%u\t", ldns_rr_get_type(rr)); for (i = 0; i < ldns_rr_rd_count(rr); i++) { total_rdfsize += ldns_rdf_size(ldns_rr_rdf(rr, i)); } if (total_rdfsize == 0) { ldns_buffer_printf(output, "\\# 0\n"); return ldns_buffer_status(output); } ldns_buffer_printf(output, "\\# %d ", total_rdfsize); for (i = 0; i < ldns_rr_rd_count(rr); i++) { for (j = 0; j < ldns_rdf_size(ldns_rr_rdf(rr, i)); j++) { ldns_buffer_printf(output, "%.2x", ldns_rdf_data(ldns_rr_rdf(rr, i))[j]); } } ldns_buffer_printf(output, "\n"); return ldns_buffer_status(output); } ldns_status ldns_rr2buffer_str_fmt(ldns_buffer *output, const ldns_output_format *fmt, const ldns_rr *rr) { uint16_t i, flags; ldns_status status = LDNS_STATUS_OK; ldns_output_format_storage* fmt_st = (ldns_output_format_storage*)fmt; if (fmt_st == NULL) { fmt_st = (ldns_output_format_storage*) ldns_output_format_default; } if (!rr) { if (LDNS_COMMENT_NULLS & fmt_st->flags) { ldns_buffer_printf(output, "; (null)\n"); } return ldns_buffer_status(output); } if (ldns_rr_owner(rr)) { status = ldns_rdf2buffer_str_dname(output, ldns_rr_owner(rr)); } if (status != LDNS_STATUS_OK) { return status; } /* TTL should NOT be printed if it is a question */ if (!ldns_rr_is_question(rr)) { ldns_buffer_printf(output, "\t%d", ldns_rr_ttl(rr)); } ldns_buffer_printf(output, "\t"); status = ldns_rr_class2buffer_str(output, ldns_rr_get_class(rr)); if (status != LDNS_STATUS_OK) { return status; } ldns_buffer_printf(output, "\t"); if (ldns_output_format_covers_type(fmt, ldns_rr_get_type(rr))) { return ldns_rr2buffer_str_rfc3597(output, rr); } status = ldns_rr_type2buffer_str(output, ldns_rr_get_type(rr)); if (status != LDNS_STATUS_OK) { return status; } if (ldns_rr_rd_count(rr) > 0) { ldns_buffer_printf(output, "\t"); } else if (!ldns_rr_is_question(rr)) { ldns_buffer_printf(output, "\t\\# 0"); } for (i = 0; i < ldns_rr_rd_count(rr); i++) { /* ldns_rdf2buffer_str handles NULL input fine! */ if ((fmt_st->flags & LDNS_FMT_ZEROIZE_RRSIGS) && (ldns_rr_get_type(rr) == LDNS_RR_TYPE_RRSIG) && ((/* inception */ i == 4 && ldns_rdf_get_type(ldns_rr_rdf(rr, 4)) == LDNS_RDF_TYPE_TIME) || (/* expiration */ i == 5 && ldns_rdf_get_type(ldns_rr_rdf(rr, 5)) == LDNS_RDF_TYPE_TIME) || (/* signature */ i == 8 && ldns_rdf_get_type(ldns_rr_rdf(rr, 8)) == LDNS_RDF_TYPE_B64))) { ldns_buffer_printf(output, "(null)"); status = ldns_buffer_status(output); } else if ((fmt_st->flags & LDNS_FMT_PAD_SOA_SERIAL) && (ldns_rr_get_type(rr) == LDNS_RR_TYPE_SOA) && /* serial */ i == 2 && ldns_rdf_get_type(ldns_rr_rdf(rr, 2)) == LDNS_RDF_TYPE_INT32) { ldns_buffer_printf(output, "%10lu", (unsigned long) ldns_read_uint32( ldns_rdf_data(ldns_rr_rdf(rr, 2)))); status = ldns_buffer_status(output); } else { status = ldns_rdf2buffer_str_fmt(output, fmt, ldns_rr_rdf(rr, i)); } if(status != LDNS_STATUS_OK) return status; if (i < ldns_rr_rd_count(rr) - 1) { ldns_buffer_printf(output, " "); } } /* per RR special comments - handy for DNSSEC types */ /* check to prevent question sec. rr from * getting here */ if (ldns_rr_rd_count(rr) > 0) { switch (ldns_rr_get_type(rr)) { case LDNS_RR_TYPE_DNSKEY: /* if ldns_rr_rd_count(rr) > 0 then ldns_rr_rdf(rr, 0) exists! */ if (! (fmt_st->flags & LDNS_COMMENT_KEY)) { break; } flags = ldns_rdf2native_int16(ldns_rr_rdf(rr, 0)); ldns_buffer_printf(output, " ;{"); if (fmt_st->flags & LDNS_COMMENT_KEY_ID) { ldns_buffer_printf(output, "id = %u", (unsigned int) ldns_calc_keytag(rr)); } if ((fmt_st->flags & LDNS_COMMENT_KEY_TYPE) && (flags & LDNS_KEY_ZONE_KEY)){ if (flags & LDNS_KEY_SEP_KEY) { ldns_buffer_printf(output, " (ksk)"); } else { ldns_buffer_printf(output, " (zsk)"); } if (fmt_st->flags & LDNS_COMMENT_KEY_SIZE){ ldns_buffer_printf(output, ", "); } } else if (fmt_st->flags & (LDNS_COMMENT_KEY_ID |LDNS_COMMENT_KEY_SIZE)) { ldns_buffer_printf( output, ", "); } if (fmt_st->flags & LDNS_COMMENT_KEY_SIZE) { ldns_buffer_printf(output, "size = %db", ldns_rr_dnskey_key_size(rr)); } ldns_buffer_printf(output, "}"); break; case LDNS_RR_TYPE_RRSIG: if ((fmt_st->flags & LDNS_COMMENT_KEY) && (fmt_st->flags& LDNS_COMMENT_RRSIGS) && ldns_rr_rdf(rr, 6) != NULL) { ldns_buffer_printf(output, " ;{id = %d}", ldns_rdf2native_int16( ldns_rr_rdf(rr, 6))); } break; case LDNS_RR_TYPE_DS: if ((fmt_st->flags & LDNS_COMMENT_BUBBLEBABBLE) && ldns_rr_rdf(rr, 3) != NULL) { uint8_t *data = ldns_rdf_data( ldns_rr_rdf(rr, 3)); size_t len = ldns_rdf_size(ldns_rr_rdf(rr, 3)); char *babble = ldns_bubblebabble(data, len); if(babble) { ldns_buffer_printf(output, " ;{%s}", babble); } LDNS_FREE(babble); } break; case LDNS_RR_TYPE_NSEC3: if (! (fmt_st->flags & LDNS_COMMENT_FLAGS) && ! (fmt_st->flags & LDNS_COMMENT_NSEC3_CHAIN)) { break; } ldns_buffer_printf(output, " ;{"); if ((fmt_st->flags & LDNS_COMMENT_FLAGS)) { if (ldns_nsec3_optout(rr)) { ldns_buffer_printf(output, " flags: optout"); } else { ldns_buffer_printf(output," flags: -"); } if (fmt_st->flags & LDNS_COMMENT_NSEC3_CHAIN && fmt_st->hashmap != NULL) { ldns_buffer_printf(output, ", "); } } if (fmt_st->flags & LDNS_COMMENT_NSEC3_CHAIN && fmt_st->hashmap != NULL) { ldns_rbnode_t *node; ldns_rdf *key = ldns_dname_label( ldns_rr_owner(rr), 0); if (key) { node = ldns_rbtree_search( fmt_st->hashmap, (void *) key); if (node->data) { ldns_buffer_printf(output, "from: "); (void) ldns_rdf2buffer_str( output, ldns_dnssec_name_name( (ldns_dnssec_name*) node->data )); } ldns_rdf_free(key); } key = ldns_b32_ext2dname( ldns_nsec3_next_owner(rr)); if (key) { node = ldns_rbtree_search( fmt_st->hashmap, (void *) key); if (node->data) { ldns_buffer_printf(output, " to: "); (void) ldns_rdf2buffer_str( output, ldns_dnssec_name_name( (ldns_dnssec_name*) node->data )); } ldns_rdf_free(key); } } ldns_buffer_printf(output, "}"); break; default: break; } } /* last */ ldns_buffer_printf(output, "\n"); return ldns_buffer_status(output); } ldns_status ldns_rr2buffer_str(ldns_buffer *output, const ldns_rr *rr) { return ldns_rr2buffer_str_fmt(output, ldns_output_format_default, rr); } ldns_status ldns_rr_list2buffer_str_fmt(ldns_buffer *output, const ldns_output_format *fmt, const ldns_rr_list *list) { uint16_t i; for(i = 0; i < ldns_rr_list_rr_count(list); i++) { (void) ldns_rr2buffer_str_fmt(output, fmt, ldns_rr_list_rr(list, i)); } return ldns_buffer_status(output); } ldns_status ldns_rr_list2buffer_str(ldns_buffer *output, const ldns_rr_list *list) { return ldns_rr_list2buffer_str_fmt( output, ldns_output_format_default, list); } ldns_status ldns_pktheader2buffer_str(ldns_buffer *output, const ldns_pkt *pkt) { ldns_lookup_table *opcode = ldns_lookup_by_id(ldns_opcodes, (int) ldns_pkt_get_opcode(pkt)); ldns_lookup_table *rcode = ldns_lookup_by_id(ldns_rcodes, (int) ldns_pkt_get_rcode(pkt)); ldns_buffer_printf(output, ";; ->>HEADER<<- "); if (opcode) { ldns_buffer_printf(output, "opcode: %s, ", opcode->name); } else { ldns_buffer_printf(output, "opcode: ?? (%u), ", ldns_pkt_get_opcode(pkt)); } if (rcode) { ldns_buffer_printf(output, "rcode: %s, ", rcode->name); } else { ldns_buffer_printf(output, "rcode: ?? (%u), ", ldns_pkt_get_rcode(pkt)); } ldns_buffer_printf(output, "id: %d\n", ldns_pkt_id(pkt)); ldns_buffer_printf(output, ";; flags: "); if (ldns_pkt_qr(pkt)) { ldns_buffer_printf(output, "qr "); } if (ldns_pkt_aa(pkt)) { ldns_buffer_printf(output, "aa "); } if (ldns_pkt_tc(pkt)) { ldns_buffer_printf(output, "tc "); } if (ldns_pkt_rd(pkt)) { ldns_buffer_printf(output, "rd "); } if (ldns_pkt_cd(pkt)) { ldns_buffer_printf(output, "cd "); } if (ldns_pkt_ra(pkt)) { ldns_buffer_printf(output, "ra "); } if (ldns_pkt_ad(pkt)) { ldns_buffer_printf(output, "ad "); } ldns_buffer_printf(output, "; "); ldns_buffer_printf(output, "QUERY: %u, ", ldns_pkt_qdcount(pkt)); ldns_buffer_printf(output, "ANSWER: %u, ", ldns_pkt_ancount(pkt)); ldns_buffer_printf(output, "AUTHORITY: %u, ", ldns_pkt_nscount(pkt)); ldns_buffer_printf(output, "ADDITIONAL: %u ", ldns_pkt_arcount(pkt)); return ldns_buffer_status(output); } ldns_status ldns_pkt2buffer_str_fmt(ldns_buffer *output, const ldns_output_format *fmt, const ldns_pkt *pkt) { uint16_t i; ldns_status status = LDNS_STATUS_OK; char *tmp; struct timeval time; time_t time_tt; if (!pkt) { ldns_buffer_printf(output, "null"); return LDNS_STATUS_OK; } if (ldns_buffer_status_ok(output)) { status = ldns_pktheader2buffer_str(output, pkt); if (status != LDNS_STATUS_OK) { return status; } ldns_buffer_printf(output, "\n"); ldns_buffer_printf(output, ";; QUESTION SECTION:\n;; "); for (i = 0; i < ldns_pkt_qdcount(pkt); i++) { status = ldns_rr2buffer_str_fmt(output, fmt, ldns_rr_list_rr( ldns_pkt_question(pkt), i)); if (status != LDNS_STATUS_OK) { return status; } } ldns_buffer_printf(output, "\n"); ldns_buffer_printf(output, ";; ANSWER SECTION:\n"); for (i = 0; i < ldns_pkt_ancount(pkt); i++) { status = ldns_rr2buffer_str_fmt(output, fmt, ldns_rr_list_rr( ldns_pkt_answer(pkt), i)); if (status != LDNS_STATUS_OK) { return status; } } ldns_buffer_printf(output, "\n"); ldns_buffer_printf(output, ";; AUTHORITY SECTION:\n"); for (i = 0; i < ldns_pkt_nscount(pkt); i++) { status = ldns_rr2buffer_str_fmt(output, fmt, ldns_rr_list_rr( ldns_pkt_authority(pkt), i)); if (status != LDNS_STATUS_OK) { return status; } } ldns_buffer_printf(output, "\n"); ldns_buffer_printf(output, ";; ADDITIONAL SECTION:\n"); for (i = 0; i < ldns_pkt_arcount(pkt); i++) { status = ldns_rr2buffer_str_fmt(output, fmt, ldns_rr_list_rr( ldns_pkt_additional(pkt), i)); if (status != LDNS_STATUS_OK) { return status; } } ldns_buffer_printf(output, "\n"); /* add some futher fields */ ldns_buffer_printf(output, ";; Query time: %d msec\n", ldns_pkt_querytime(pkt)); if (ldns_pkt_edns(pkt)) { ldns_buffer_printf(output, ";; EDNS: version %u; flags:", ldns_pkt_edns_version(pkt)); if (ldns_pkt_edns_do(pkt)) { ldns_buffer_printf(output, " do"); } /* the extended rcode is the value set, shifted four bits, * and or'd with the original rcode */ if (ldns_pkt_edns_extended_rcode(pkt)) { ldns_buffer_printf(output, " ; ext-rcode: %d", (ldns_pkt_edns_extended_rcode(pkt) << 4 | ldns_pkt_get_rcode(pkt))); } ldns_buffer_printf(output, " ; udp: %u\n", ldns_pkt_edns_udp_size(pkt)); if (ldns_pkt_edns_data(pkt)) { ldns_buffer_printf(output, ";; Data: "); (void)ldns_rdf2buffer_str(output, ldns_pkt_edns_data(pkt)); ldns_buffer_printf(output, "\n"); } } if (ldns_pkt_tsig(pkt)) { ldns_buffer_printf(output, ";; TSIG:\n;; "); (void) ldns_rr2buffer_str_fmt( output, fmt, ldns_pkt_tsig(pkt)); ldns_buffer_printf(output, "\n"); } if (ldns_pkt_answerfrom(pkt)) { tmp = ldns_rdf2str(ldns_pkt_answerfrom(pkt)); ldns_buffer_printf(output, ";; SERVER: %s\n", tmp); LDNS_FREE(tmp); } time = ldns_pkt_timestamp(pkt); time_tt = (time_t)time.tv_sec; ldns_buffer_printf(output, ";; WHEN: %s", (char*)ctime(&time_tt)); ldns_buffer_printf(output, ";; MSG SIZE rcvd: %d\n", (int)ldns_pkt_size(pkt)); } else { return ldns_buffer_status(output); } return status; } ldns_status ldns_pkt2buffer_str(ldns_buffer *output, const ldns_pkt *pkt) { return ldns_pkt2buffer_str_fmt(output, ldns_output_format_default, pkt); } #ifdef HAVE_SSL static ldns_status ldns_hmac_key2buffer_str(ldns_buffer *output, const ldns_key *k) { ldns_status status; size_t i; ldns_rdf *b64_bignum; ldns_buffer_printf(output, "Key: "); i = ldns_key_hmac_size(k); b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, ldns_key_hmac_key(k)); status = ldns_rdf2buffer_str(output, b64_bignum); ldns_rdf_deep_free(b64_bignum); ldns_buffer_printf(output, "\n"); return status; } #endif #if defined(HAVE_SSL) && defined(USE_GOST) static ldns_status ldns_gost_key2buffer_str(ldns_buffer *output, EVP_PKEY *p) { unsigned char* pp = NULL; int ret; ldns_rdf *b64_bignum; ldns_status status; ldns_buffer_printf(output, "GostAsn1: "); ret = i2d_PrivateKey(p, &pp); b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, (size_t)ret, pp); status = ldns_rdf2buffer_str(output, b64_bignum); ldns_rdf_deep_free(b64_bignum); OPENSSL_free(pp); ldns_buffer_printf(output, "\n"); return status; } #endif ldns_status ldns_key2buffer_str(ldns_buffer *output, const ldns_key *k) { ldns_status status = LDNS_STATUS_OK; unsigned char *bignum; #ifdef HAVE_SSL # ifndef S_SPLINT_S uint16_t i; # endif /* not used when ssl is not defined */ /*@unused@*/ ldns_rdf *b64_bignum = NULL; RSA *rsa; DSA *dsa; #endif /* HAVE_SSL */ if (!k) { return LDNS_STATUS_ERR; } bignum = LDNS_XMALLOC(unsigned char, LDNS_MAX_KEYLEN); if (!bignum) { return LDNS_STATUS_ERR; } if (ldns_buffer_status_ok(output)) { #ifdef HAVE_SSL switch(ldns_key_algorithm(k)) { case LDNS_SIGN_RSASHA1: case LDNS_SIGN_RSASHA1_NSEC3: case LDNS_SIGN_RSASHA256: case LDNS_SIGN_RSASHA512: case LDNS_SIGN_RSAMD5: /* copied by looking at dnssec-keygen output */ /* header */ rsa = ldns_key_rsa_key(k); ldns_buffer_printf(output,"Private-key-format: v1.2\n"); switch(ldns_key_algorithm(k)) { case LDNS_SIGN_RSAMD5: ldns_buffer_printf(output, "Algorithm: %u (RSA)\n", LDNS_RSAMD5); break; case LDNS_SIGN_RSASHA1: ldns_buffer_printf(output, "Algorithm: %u (RSASHA1)\n", LDNS_RSASHA1); break; case LDNS_SIGN_RSASHA1_NSEC3: ldns_buffer_printf(output, "Algorithm: %u (RSASHA1_NSEC3)\n", LDNS_RSASHA1_NSEC3); break; #ifdef USE_SHA2 case LDNS_SIGN_RSASHA256: ldns_buffer_printf(output, "Algorithm: %u (RSASHA256)\n", LDNS_RSASHA256); break; case LDNS_SIGN_RSASHA512: ldns_buffer_printf(output, "Algorithm: %u (RSASHA512)\n", LDNS_RSASHA512); break; #endif default: #ifdef STDERR_MSGS fprintf(stderr, "Warning: unknown signature "); fprintf(stderr, "algorithm type %u\n", ldns_key_algorithm(k)); #endif ldns_buffer_printf(output, "Algorithm: %u (Unknown)\n", ldns_key_algorithm(k)); break; } /* print to buf, convert to bin, convert to b64, * print to buf */ ldns_buffer_printf(output, "Modulus: "); #ifndef S_SPLINT_S i = (uint16_t)BN_bn2bin(rsa->n, bignum); if (i > LDNS_MAX_KEYLEN) { goto error; } b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum); if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) { ldns_rdf_deep_free(b64_bignum); goto error; } ldns_rdf_deep_free(b64_bignum); ldns_buffer_printf(output, "\n"); ldns_buffer_printf(output, "PublicExponent: "); i = (uint16_t)BN_bn2bin(rsa->e, bignum); if (i > LDNS_MAX_KEYLEN) { goto error; } b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum); if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) { ldns_rdf_deep_free(b64_bignum); goto error; } ldns_rdf_deep_free(b64_bignum); ldns_buffer_printf(output, "\n"); ldns_buffer_printf(output, "PrivateExponent: "); if (rsa->d) { i = (uint16_t)BN_bn2bin(rsa->d, bignum); if (i > LDNS_MAX_KEYLEN) { goto error; } b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum); if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) { ldns_rdf_deep_free(b64_bignum); goto error; } ldns_rdf_deep_free(b64_bignum); ldns_buffer_printf(output, "\n"); } else { ldns_buffer_printf(output, "(Not available)\n"); } ldns_buffer_printf(output, "Prime1: "); if (rsa->p) { i = (uint16_t)BN_bn2bin(rsa->p, bignum); if (i > LDNS_MAX_KEYLEN) { goto error; } b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum); if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) { ldns_rdf_deep_free(b64_bignum); goto error; } ldns_rdf_deep_free(b64_bignum); ldns_buffer_printf(output, "\n"); } else { ldns_buffer_printf(output, "(Not available)\n"); } ldns_buffer_printf(output, "Prime2: "); if (rsa->q) { i = (uint16_t)BN_bn2bin(rsa->q, bignum); if (i > LDNS_MAX_KEYLEN) { goto error; } b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum); if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) { ldns_rdf_deep_free(b64_bignum); goto error; } ldns_rdf_deep_free(b64_bignum); ldns_buffer_printf(output, "\n"); } else { ldns_buffer_printf(output, "(Not available)\n"); } ldns_buffer_printf(output, "Exponent1: "); if (rsa->dmp1) { i = (uint16_t)BN_bn2bin(rsa->dmp1, bignum); if (i > LDNS_MAX_KEYLEN) { goto error; } b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum); if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) { ldns_rdf_deep_free(b64_bignum); goto error; } ldns_rdf_deep_free(b64_bignum); ldns_buffer_printf(output, "\n"); } else { ldns_buffer_printf(output, "(Not available)\n"); } ldns_buffer_printf(output, "Exponent2: "); if (rsa->dmq1) { i = (uint16_t)BN_bn2bin(rsa->dmq1, bignum); if (i > LDNS_MAX_KEYLEN) { goto error; } b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum); if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) { ldns_rdf_deep_free(b64_bignum); goto error; } ldns_rdf_deep_free(b64_bignum); ldns_buffer_printf(output, "\n"); } else { ldns_buffer_printf(output, "(Not available)\n"); } ldns_buffer_printf(output, "Coefficient: "); if (rsa->iqmp) { i = (uint16_t)BN_bn2bin(rsa->iqmp, bignum); if (i > LDNS_MAX_KEYLEN) { goto error; } b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum); if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) { ldns_rdf_deep_free(b64_bignum); goto error; } ldns_rdf_deep_free(b64_bignum); ldns_buffer_printf(output, "\n"); } else { ldns_buffer_printf(output, "(Not available)\n"); } #endif /* splint */ RSA_free(rsa); break; case LDNS_SIGN_DSA: case LDNS_SIGN_DSA_NSEC3: dsa = ldns_key_dsa_key(k); ldns_buffer_printf(output,"Private-key-format: v1.2\n"); if (ldns_key_algorithm(k) == LDNS_SIGN_DSA) { ldns_buffer_printf(output,"Algorithm: 3 (DSA)\n"); } else if (ldns_key_algorithm(k) == LDNS_SIGN_DSA_NSEC3) { ldns_buffer_printf(output,"Algorithm: 6 (DSA_NSEC3)\n"); } /* print to buf, convert to bin, convert to b64, * print to buf */ ldns_buffer_printf(output, "Prime(p): "); #ifndef S_SPLINT_S if (dsa->p) { i = (uint16_t)BN_bn2bin(dsa->p, bignum); if (i > LDNS_MAX_KEYLEN) { goto error; } b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum); if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) { ldns_rdf_deep_free(b64_bignum); goto error; } ldns_rdf_deep_free(b64_bignum); ldns_buffer_printf(output, "\n"); } else { printf("(Not available)\n"); } ldns_buffer_printf(output, "Subprime(q): "); if (dsa->q) { i = (uint16_t)BN_bn2bin(dsa->q, bignum); if (i > LDNS_MAX_KEYLEN) { goto error; } b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum); if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) { ldns_rdf_deep_free(b64_bignum); goto error; } ldns_rdf_deep_free(b64_bignum); ldns_buffer_printf(output, "\n"); } else { printf("(Not available)\n"); } ldns_buffer_printf(output, "Base(g): "); if (dsa->g) { i = (uint16_t)BN_bn2bin(dsa->g, bignum); if (i > LDNS_MAX_KEYLEN) { goto error; } b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum); if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) { ldns_rdf_deep_free(b64_bignum); goto error; } ldns_rdf_deep_free(b64_bignum); ldns_buffer_printf(output, "\n"); } else { printf("(Not available)\n"); } ldns_buffer_printf(output, "Private_value(x): "); if (dsa->priv_key) { i = (uint16_t)BN_bn2bin(dsa->priv_key, bignum); if (i > LDNS_MAX_KEYLEN) { goto error; } b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum); if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) { ldns_rdf_deep_free(b64_bignum); goto error; } ldns_rdf_deep_free(b64_bignum); ldns_buffer_printf(output, "\n"); } else { printf("(Not available)\n"); } ldns_buffer_printf(output, "Public_value(y): "); if (dsa->pub_key) { i = (uint16_t)BN_bn2bin(dsa->pub_key, bignum); if (i > LDNS_MAX_KEYLEN) { goto error; } b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum); if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) { ldns_rdf_deep_free(b64_bignum); goto error; } ldns_rdf_deep_free(b64_bignum); ldns_buffer_printf(output, "\n"); } else { printf("(Not available)\n"); } #endif /* splint */ break; case LDNS_SIGN_ECC_GOST: /* no format defined, use blob */ #if defined(HAVE_SSL) && defined(USE_GOST) ldns_buffer_printf(output, "Private-key-format: v1.2\n"); ldns_buffer_printf(output, "Algorithm: %d (ECC-GOST)\n", LDNS_SIGN_ECC_GOST); status = ldns_gost_key2buffer_str(output, #ifndef S_SPLINT_S k->_key.key #else NULL #endif ); #else goto error; #endif /* GOST */ break; case LDNS_SIGN_ECDSAP256SHA256: case LDNS_SIGN_ECDSAP384SHA384: #ifdef USE_ECDSA ldns_buffer_printf(output, "Private-key-format: v1.2\n"); ldns_buffer_printf(output, "Algorithm: %d (", ldns_key_algorithm(k)); status=ldns_algorithm2buffer_str(output, (ldns_algorithm)ldns_key_algorithm(k)); #ifndef S_SPLINT_S ldns_buffer_printf(output, ")\n"); if(k->_key.key) { EC_KEY* ec = EVP_PKEY_get1_EC_KEY(k->_key.key); const BIGNUM* b = EC_KEY_get0_private_key(ec); ldns_buffer_printf(output, "PrivateKey: "); i = (uint16_t)BN_bn2bin(b, bignum); if (i > LDNS_MAX_KEYLEN) { goto error; } b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum); if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) { ldns_rdf_deep_free(b64_bignum); goto error; } ldns_rdf_deep_free(b64_bignum); ldns_buffer_printf(output, "\n"); /* down reference count in EC_KEY * its still assigned to the PKEY */ EC_KEY_free(ec); } #endif /* splint */ #else goto error; #endif /* ECDSA */ break; case LDNS_SIGN_HMACMD5: /* there's not much of a format defined for TSIG */ /* It's just a binary blob, Same for all algorithms */ ldns_buffer_printf(output, "Private-key-format: v1.2\n"); ldns_buffer_printf(output, "Algorithm: 157 (HMAC_MD5)\n"); status = ldns_hmac_key2buffer_str(output, k); break; case LDNS_SIGN_HMACSHA1: ldns_buffer_printf(output, "Private-key-format: v1.2\n"); ldns_buffer_printf(output, "Algorithm: 158 (HMAC_SHA1)\n"); status = ldns_hmac_key2buffer_str(output, k); break; case LDNS_SIGN_HMACSHA256: ldns_buffer_printf(output, "Private-key-format: v1.2\n"); ldns_buffer_printf(output, "Algorithm: 159 (HMAC_SHA256)\n"); status = ldns_hmac_key2buffer_str(output, k); break; } #endif /* HAVE_SSL */ } else { LDNS_FREE(bignum); return ldns_buffer_status(output); } LDNS_FREE(bignum); return status; #ifdef HAVE_SSL /* compiles warn the label isn't used */ error: LDNS_FREE(bignum); return LDNS_STATUS_ERR; #endif /* HAVE_SSL */ } /* * Zero terminate the buffer and copy data. */ char * ldns_buffer2str(ldns_buffer *buffer) { char *str; /* check if buffer ends with \0, if not, and if there is space, add it */ if (*(ldns_buffer_at(buffer, ldns_buffer_position(buffer))) != 0) { if (!ldns_buffer_reserve(buffer, 1)) { return NULL; } ldns_buffer_write_u8(buffer, (uint8_t) '\0'); if (!ldns_buffer_set_capacity(buffer, ldns_buffer_position(buffer))) { return NULL; } } str = strdup((const char *)ldns_buffer_begin(buffer)); if(!str) { return NULL; } return str; } /* * Zero terminate the buffer and export data. */ char * ldns_buffer_export2str(ldns_buffer *buffer) { /* Append '\0' as string terminator */ if (! ldns_buffer_reserve(buffer, 1)) { return NULL; } ldns_buffer_write_u8(buffer, 0); /* reallocate memory to the size of the string and export */ ldns_buffer_set_capacity(buffer, ldns_buffer_position(buffer)); return ldns_buffer_export(buffer); } char * ldns_rdf2str(const ldns_rdf *rdf) { char *result = NULL; ldns_buffer *tmp_buffer = ldns_buffer_new(LDNS_MAX_PACKETLEN); if (!tmp_buffer) { return NULL; } if (ldns_rdf2buffer_str(tmp_buffer, rdf) == LDNS_STATUS_OK) { /* export and return string, destroy rest */ result = ldns_buffer_export2str(tmp_buffer); } ldns_buffer_free(tmp_buffer); return result; } char * ldns_rr2str_fmt(const ldns_output_format *fmt, const ldns_rr *rr) { char *result = NULL; ldns_buffer *tmp_buffer = ldns_buffer_new(LDNS_MAX_PACKETLEN); if (!tmp_buffer) { return NULL; } if (ldns_rr2buffer_str_fmt(tmp_buffer, fmt, rr) == LDNS_STATUS_OK) { /* export and return string, destroy rest */ result = ldns_buffer_export2str(tmp_buffer); } ldns_buffer_free(tmp_buffer); return result; } char * ldns_rr2str(const ldns_rr *rr) { return ldns_rr2str_fmt(ldns_output_format_default, rr); } char * ldns_pkt2str_fmt(const ldns_output_format *fmt, const ldns_pkt *pkt) { char *result = NULL; ldns_buffer *tmp_buffer = ldns_buffer_new(LDNS_MAX_PACKETLEN); if (!tmp_buffer) { return NULL; } if (ldns_pkt2buffer_str_fmt(tmp_buffer, fmt, pkt) == LDNS_STATUS_OK) { /* export and return string, destroy rest */ result = ldns_buffer_export2str(tmp_buffer); } ldns_buffer_free(tmp_buffer); return result; } char * ldns_pkt2str(const ldns_pkt *pkt) { return ldns_pkt2str_fmt(ldns_output_format_default, pkt); } char * ldns_key2str(const ldns_key *k) { char *result = NULL; ldns_buffer *tmp_buffer = ldns_buffer_new(LDNS_MAX_PACKETLEN); if (!tmp_buffer) { return NULL; } if (ldns_key2buffer_str(tmp_buffer, k) == LDNS_STATUS_OK) { /* export and return string, destroy rest */ result = ldns_buffer_export2str(tmp_buffer); } ldns_buffer_free(tmp_buffer); return result; } char * ldns_rr_list2str_fmt(const ldns_output_format *fmt, const ldns_rr_list *list) { char *result = NULL; ldns_buffer *tmp_buffer = ldns_buffer_new(LDNS_MAX_PACKETLEN); if (!tmp_buffer) { return NULL; } if (list) { if (ldns_rr_list2buffer_str_fmt( tmp_buffer, fmt, list) == LDNS_STATUS_OK) { } } else { if (fmt == NULL) { fmt = ldns_output_format_default; } if (fmt->flags & LDNS_COMMENT_NULLS) { ldns_buffer_printf(tmp_buffer, "; (null)\n"); } } /* export and return string, destroy rest */ result = ldns_buffer_export2str(tmp_buffer); ldns_buffer_free(tmp_buffer); return result; } char * ldns_rr_list2str(const ldns_rr_list *list) { return ldns_rr_list2str_fmt(ldns_output_format_default, list); } void ldns_rdf_print(FILE *output, const ldns_rdf *rdf) { char *str = ldns_rdf2str(rdf); if (str) { fprintf(output, "%s", str); } else { fprintf(output, ";Unable to convert rdf to string\n"); } LDNS_FREE(str); } void ldns_rr_print_fmt(FILE *output, const ldns_output_format *fmt, const ldns_rr *rr) { char *str = ldns_rr2str_fmt(fmt, rr); if (str) { fprintf(output, "%s", str); } else { fprintf(output, ";Unable to convert rr to string\n"); } LDNS_FREE(str); } void ldns_rr_print(FILE *output, const ldns_rr *rr) { ldns_rr_print_fmt(output, ldns_output_format_default, rr); } void ldns_pkt_print_fmt(FILE *output, const ldns_output_format *fmt, const ldns_pkt *pkt) { char *str = ldns_pkt2str_fmt(fmt, pkt); if (str) { fprintf(output, "%s", str); } else { fprintf(output, ";Unable to convert packet to string\n"); } LDNS_FREE(str); } void ldns_pkt_print(FILE *output, const ldns_pkt *pkt) { ldns_pkt_print_fmt(output, ldns_output_format_default, pkt); } void ldns_rr_list_print_fmt(FILE *output, const ldns_output_format *fmt, const ldns_rr_list *lst) { size_t i; for (i = 0; i < ldns_rr_list_rr_count(lst); i++) { ldns_rr_print_fmt(output, fmt, ldns_rr_list_rr(lst, i)); } } void ldns_rr_list_print(FILE *output, const ldns_rr_list *lst) { ldns_rr_list_print_fmt(output, ldns_output_format_default, lst); } void ldns_resolver_print_fmt(FILE *output, const ldns_output_format *fmt, const ldns_resolver *r) { uint16_t i; ldns_rdf **n; ldns_rdf **s; size_t *rtt; if (!r) { return; } n = ldns_resolver_nameservers(r); s = ldns_resolver_searchlist(r); rtt = ldns_resolver_rtt(r); fprintf(output, "port: %d\n", (int)ldns_resolver_port(r)); fprintf(output, "edns0 size: %d\n", (int)ldns_resolver_edns_udp_size(r)); fprintf(output, "use ip6: %d\n", (int)ldns_resolver_ip6(r)); fprintf(output, "recursive: %d\n", ldns_resolver_recursive(r)); fprintf(output, "usevc: %d\n", ldns_resolver_usevc(r)); fprintf(output, "igntc: %d\n", ldns_resolver_igntc(r)); fprintf(output, "fail: %d\n", ldns_resolver_fail(r)); fprintf(output, "retry: %d\n", (int)ldns_resolver_retry(r)); fprintf(output, "retrans: %d\n", (int)ldns_resolver_retrans(r)); fprintf(output, "fallback: %d\n", ldns_resolver_fallback(r)); fprintf(output, "random: %d\n", ldns_resolver_random(r)); fprintf(output, "timeout: %d\n", (int)ldns_resolver_timeout(r).tv_sec); fprintf(output, "dnssec: %d\n", ldns_resolver_dnssec(r)); fprintf(output, "dnssec cd: %d\n", ldns_resolver_dnssec_cd(r)); fprintf(output, "trust anchors (%d listed):\n", (int)ldns_rr_list_rr_count(ldns_resolver_dnssec_anchors(r))); ldns_rr_list_print_fmt(output, fmt, ldns_resolver_dnssec_anchors(r)); fprintf(output, "tsig: %s %s\n", ldns_resolver_tsig_keyname(r)?ldns_resolver_tsig_keyname(r):"-", ldns_resolver_tsig_algorithm(r)?ldns_resolver_tsig_algorithm(r):"-"); fprintf(output, "debug: %d\n", ldns_resolver_debug(r)); fprintf(output, "default domain: "); ldns_rdf_print(output, ldns_resolver_domain(r)); fprintf(output, "\n"); fprintf(output, "apply default domain: %d\n", ldns_resolver_defnames(r)); fprintf(output, "searchlist (%d listed):\n", (int)ldns_resolver_searchlist_count(r)); for (i = 0; i < ldns_resolver_searchlist_count(r); i++) { fprintf(output, "\t"); ldns_rdf_print(output, s[i]); fprintf(output, "\n"); } fprintf(output, "apply search list: %d\n", ldns_resolver_dnsrch(r)); fprintf(output, "nameservers (%d listed):\n", (int)ldns_resolver_nameserver_count(r)); for (i = 0; i < ldns_resolver_nameserver_count(r); i++) { fprintf(output, "\t"); ldns_rdf_print(output, n[i]); switch ((int)rtt[i]) { case LDNS_RESOLV_RTT_MIN: fprintf(output, " - reachable\n"); break; case LDNS_RESOLV_RTT_INF: fprintf(output, " - unreachable\n"); break; } } } void ldns_resolver_print(FILE *output, const ldns_resolver *r) { ldns_resolver_print_fmt(output, ldns_output_format_default, r); } void ldns_zone_print_fmt(FILE *output, const ldns_output_format *fmt, const ldns_zone *z) { if(ldns_zone_soa(z)) ldns_rr_print_fmt(output, fmt, ldns_zone_soa(z)); ldns_rr_list_print_fmt(output, fmt, ldns_zone_rrs(z)); } void ldns_zone_print(FILE *output, const ldns_zone *z) { ldns_zone_print_fmt(output, ldns_output_format_default, z); } ldns-1.6.17/contrib/0000775000175100017510000000000012264060151013553 5ustar willemwillemldns-1.6.17/contrib/DNS-LDNS/0000775000175100017510000000000012264060171014737 5ustar willemwillemldns-1.6.17/contrib/DNS-LDNS/t/0000775000175100017510000000000012264060153015202 5ustar willemwillemldns-1.6.17/contrib/DNS-LDNS/t/dnssec_datachain.t0000664000175100017510000000304112264060153020640 0ustar willemwillemuse 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'); ldns-1.6.17/contrib/DNS-LDNS/t/DNS-LDNS.t0000664000175100017510000001552512264060153016561 0ustar willemwillem# 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. ldns-1.6.17/contrib/DNS-LDNS/t/rrlist.t0000664000175100017510000001042412264060153016707 0ustar willemwillemuse 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'); ldns-1.6.17/contrib/DNS-LDNS/t/zone.t0000664000175100017510000000531712264060153016350 0ustar willemwillemuse 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'); ldns-1.6.17/contrib/DNS-LDNS/t/dnssec_zone.t0000664000175100017510000000215112264060153017700 0ustar willemwillemuse 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'); ldns-1.6.17/contrib/DNS-LDNS/t/resolver.t0000664000175100017510000000102412264060153017225 0ustar willemwillemuse 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"); ldns-1.6.17/contrib/DNS-LDNS/t/rr.t0000664000175100017510000000400312264060153016007 0ustar willemwillemuse 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'); ldns-1.6.17/contrib/DNS-LDNS/t/key.t0000664000175100017510000000162012264060153016156 0ustar willemwillemuse 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'); ldns-1.6.17/contrib/DNS-LDNS/t/testdata/0000775000175100017510000000000012264060153017013 5ustar willemwillemldns-1.6.17/contrib/DNS-LDNS/t/testdata/key.private0000664000175100017510000000336312264060153021204 0ustar willemwillemPrivate-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 ldns-1.6.17/contrib/DNS-LDNS/t/testdata/resolv.conf0000664000175100017510000000010112264060153021164 0ustar willemwillemnameserver 127.0.0.1 nameserver 192.168.100.1 search foo.bar.org ldns-1.6.17/contrib/DNS-LDNS/t/testdata/myzone.org0000664000175100017510000000051512264060153021046 0ustar willemwillem$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 ldns-1.6.17/contrib/DNS-LDNS/t/rdata.t0000664000175100017510000000357412264060153016473 0ustar willemwillemuse 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'); ldns-1.6.17/contrib/DNS-LDNS/MANIFEST0000664000175100017510000000134012264060153016066 0ustar willemwillemChanges 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 ldns-1.6.17/contrib/DNS-LDNS/const-xs.inc0000664000175100017510000000513012264060153017207 0ustar willemwillemvoid 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); } ldns-1.6.17/contrib/DNS-LDNS/Changes0000664000175100017510000000156312264060153016237 0ustar willemwillemRevision 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 ldns-1.6.17/contrib/DNS-LDNS/typemap0000664000175100017510000000404312264060153016342 0ustar willemwillemTYPEMAP 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); ldns-1.6.17/contrib/DNS-LDNS/ppport.h0000664000175100017510000052540612264060153016450 0ustar willemwillem#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 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. =head2 --patch=I 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 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 or a C program to be installed. =head2 --diff=I Manually set the diff program and options to use. The default is to use C, when installed, and output unified context diffs. =head2 --compat-version=I Tell F 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 if you intend to be backward compatible only down to a certain Perl version. =head2 --cplusplus Usually, F will detect C++ style comments and replace them with C style comments for portability reasons. Using this option instructs F 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. This reduces the size of F dramatically and may be useful if you want to include F in smaller modules without increasing their distribution size too much. The stripped F will have a C<--unstrip> option that allows you to undo the stripping, but only if an appropriate C module is installed. =head2 --list-provided Lists the API elements for which compatibility is provided by F. 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 and below which version of Perl they probably won't be available or work. =head2 --api-info=I Show portability information for API elements matching I. If I 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 prefix is deprecated. Also, some API functions used to have a C prefix. Using this form is also deprecated. You can safely use the supported API, as F 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. These functions or variables will be marked C 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 or global variants. For a C 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 macro. Just C<#define> the macro before including C: #define DPPP_NAMESPACE MyOwnNamespace_ #include "ppport.h" The default namespace is C. =back The good thing is that most of the above can be checked by running F on your source code. See the next section for details. =head1 EXAMPLES To verify whether F is needed for your module, whether you should make any changes to your code, and whether any special defines should be used, F 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 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 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 is causing failure during the compilation of this module, please check if newer versions of either this module or C are available on CPAN before sending a bug report. If F was generated using the latest version of C and is causing failure of this module, please file a bug report using the CPAN Request Tracker at L. 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 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. =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 () { 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 $/; }; 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 = <
$tmp") { print F $str; close F; if (open F, "$prog $file $tmp |") { while () { 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 < }; 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 <$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 # endif # if !(defined(PERL_VERSION) || (defined(SUBVERSION) && defined(PATCHLEVEL))) # include # 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 #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 */ # 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 */ # 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 # 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 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 */ ldns-1.6.17/contrib/DNS-LDNS/lib/0000775000175100017510000000000012264060153015505 5ustar willemwillemldns-1.6.17/contrib/DNS-LDNS/lib/DNS/0000775000175100017510000000000012264060153016131 5ustar willemwillemldns-1.6.17/contrib/DNS-LDNS/lib/DNS/LDNS.pm0000664000175100017510000007316612264060153017244 0ustar willemwillempackage 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 Base class with static functions and constants =item B Represents a parsed zonefile (maps to the ldns_zone struct) =item B 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 Represents a resource record (RR), (maps to the ldns_rr struct) =item B Represents an rdata field or a dname in an RR (maps to the ldns_rdf struct) =item B Represents a DNS resolver (maps to the ldns_resolver struct) =item B Represents a DNS package (maps to the ldns_pkt struct) =item B Represents a DNSSec private key (maps to the ldns_key struct) =item B Represents a linked list of keys (maps to the ldns_key_list struct) =item B Represents a zone with dnssec data (maps to the ldns_dnssec_zone struct) =item B Represents a tree of DNSSecName nodes (maps to the ldns_rbtree struct) =item B Represents a node in the RBTree (maps to the ldns_rbnode struct) =item B 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 Represents a linked list of DNSSec RR sets, possibly with signatures (maps to the ldns_dnssec_rrsets struct) =item B Represents a linked list of RRs (maps to the ldns_dnssec_rrs struct) =item B 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 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 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, Eerik.ostlyngen@uninett.noE =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 ldns-1.6.17/contrib/DNS-LDNS/lib/DNS/LDNS/0000775000175100017510000000000012264060153016671 5ustar willemwillemldns-1.6.17/contrib/DNS-LDNS/lib/DNS/LDNS/Zone.pm0000664000175100017510000000521312264060153020143 0ustar willemwillempackage 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, Eerik.ostlyngen@uninett.noE =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 ldns-1.6.17/contrib/DNS-LDNS/lib/DNS/LDNS/DNSSecZone.pm0000664000175100017510000000676412264060153021157 0ustar willemwillempackage 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, Eerik.ostlyngen@uninett.noE =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 ldns-1.6.17/contrib/DNS-LDNS/lib/DNS/LDNS/RBNode.pm0000664000175100017510000000250212264060153020337 0ustar willemwillempackage 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, Eerik.ostlyngen@uninett.noE =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 ldns-1.6.17/contrib/DNS-LDNS/lib/DNS/LDNS/Resolver.pm0000664000175100017510000001700012264060153021026 0ustar willemwillempackage 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, Eerik.ostlyngen@uninett.noE =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 ldns-1.6.17/contrib/DNS-LDNS/lib/DNS/LDNS/KeyList.pm0000664000175100017510000000224412264060153020615 0ustar willemwillempackage 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, Eerik.ostlyngen@uninett.noE =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 ldns-1.6.17/contrib/DNS-LDNS/lib/DNS/LDNS/RRList.pm0000664000175100017510000001030312264060153020403 0ustar willemwillempackage 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, Eerik.ostlyngen@uninett.noE =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 ldns-1.6.17/contrib/DNS-LDNS/lib/DNS/LDNS/DNSSecName.pm0000664000175100017510000000375512264060153021121 0ustar willemwillempackage 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, Eerik.ostlyngen@uninett.noE =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 ldns-1.6.17/contrib/DNS-LDNS/lib/DNS/LDNS/DNSSecDataChain.pm0000664000175100017510000000350112264060153022042 0ustar willemwillempackage 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, Eerik.ostlyngen@uninett.noE =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 ldns-1.6.17/contrib/DNS-LDNS/lib/DNS/LDNS/Key.pm0000664000175100017510000000442112264060153017760 0ustar willemwillempackage 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, Eerik.ostlyngen@uninett.noE =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 ldns-1.6.17/contrib/DNS-LDNS/lib/DNS/LDNS/RData.pm0000664000175100017510000000315412264060153020225 0ustar willemwillempackage 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, Eerik.ostlyngen@uninett.noE =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 ldns-1.6.17/contrib/DNS-LDNS/lib/DNS/LDNS/DNSSecRRSets.pm0000664000175100017510000000325212264060153021413 0ustar willemwillempackage 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, Eerik.ostlyngen@uninett.noE =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 ldns-1.6.17/contrib/DNS-LDNS/lib/DNS/LDNS/Packet.pm0000664000175100017510000001175612264060153020450 0ustar willemwillempackage 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, Eerik.ostlyngen@uninett.noE =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 ldns-1.6.17/contrib/DNS-LDNS/lib/DNS/LDNS/RR.pm0000664000175100017510000002737012264060153017563 0ustar willemwillempackage 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, Eerik.ostlyngen@uninett.noE =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 ldns-1.6.17/contrib/DNS-LDNS/lib/DNS/LDNS/DNSSecRRs.pm0000664000175100017510000000307612264060153020743 0ustar willemwillempackage 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, Eerik.ostlyngen@uninett.noE =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 ldns-1.6.17/contrib/DNS-LDNS/lib/DNS/LDNS/DNSSecTrustTree.pm0000664000175100017510000000375712264060153022204 0ustar willemwillempackage 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, Eerik.ostlyngen@uninett.noE =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 ldns-1.6.17/contrib/DNS-LDNS/lib/DNS/LDNS/GC.pm0000664000175100017510000000511612264060153017523 0ustar willemwillempackage 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, Eerik.ostlyngen@uninett.noE =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 ldns-1.6.17/contrib/DNS-LDNS/lib/DNS/LDNS/RBTree.pm0000664000175100017510000000205412264060153020353 0ustar willemwillempackage 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, Eerik.ostlyngen@uninett.noE =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 ldns-1.6.17/contrib/DNS-LDNS/const-c.inc0000664000175100017510000030127112264060153017004 0ustar willemwillem#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; } ldns-1.6.17/contrib/DNS-LDNS/LDNS.xs0000664000175100017510000016734112264060153016067 0ustar willemwillem#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 ldns-1.6.17/contrib/DNS-LDNS/fallback/0000775000175100017510000000000012264060153016476 5ustar willemwillemldns-1.6.17/contrib/DNS-LDNS/fallback/const-xs.inc0000664000175100017510000000513012264060153020746 0ustar willemwillemvoid 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); } ldns-1.6.17/contrib/DNS-LDNS/fallback/const-c.inc0000664000175100017510000027621312264060153020552 0ustar willemwillem#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; } ldns-1.6.17/contrib/DNS-LDNS/README0000664000175100017510000000152012264060153015615 0ustar willemwillemDNS::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. ldns-1.6.17/contrib/DNS-LDNS/Makefile.PL0000664000175100017510000004200112264060153016706 0ustar willemwillemuse 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 ') : ()), 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: $!"; } } ldns-1.6.17/contrib/build-solaris.sh0000664000175100017510000000173012264060151016661 0ustar willemwillem#!/bin/ksh # # $Id$ PREFIX=/opt/ldns OPENSSL=/usr/sfw SUDO=sudo MAKE_PROGRAM=gmake MAKE_ARGS="-j 4" OBJ32=obj32 OBJ64=obj64 SRCDIR=`pwd` test -d $OBJ32 && $SUDO rm -fr $OBJ32 mkdir $OBJ32 export CFLAGS="" export LDFLAGS="-L${OPENSSL}/lib -R${OPENSSL}/lib" (cd $OBJ32; \ ${SRCDIR}/configure --with-ssl=${OPENSSL} --prefix=${PREFIX} --libdir=${PREFIX}/lib; \ $MAKE_PROGRAM $MAKE_ARGS) if [ `isainfo -k` = amd64 ]; then test -d $OBJ64 && $SUDO rm -fr $OBJ64 mkdir $OBJ64 export CFLAGS="-m64" export LDFLAGS="-L${OPENSSL}/lib/amd64 -R${OPENSSL}/lib/amd64" (cd $OBJ64; \ ${SRCDIR}/configure --with-ssl=${OPENSSL} --prefix=${PREFIX} --libdir=${PREFIX}/lib/amd64; \ $MAKE_PROGRAM $MAKE_ARGS) fi # optionally install # if [ x$1 = xinstall ]; then (cd $OBJ32; $SUDO $MAKE_PROGRAM install-h) (cd $OBJ32; $SUDO $MAKE_PROGRAM install-doc) (cd $OBJ32; $SUDO $MAKE_PROGRAM install-lib) if [ `isainfo -k` = amd64 ]; then (cd $OBJ64; $SUDO $MAKE_PROGRAM install-lib) fi fi ldns-1.6.17/contrib/python/0000775000175100017510000000000012264060151015074 5ustar willemwillemldns-1.6.17/contrib/python/ldns_key.i0000664000175100017510000004444712264060151017073 0ustar willemwillem/****************************************************************************** * ldns_key.i: LDNS key class * * Copyright (c) 2009, Zdenek Vasicek (vasicek AT fit.vutbr.cz) * Karel Slany (slany AT fit.vutbr.cz) * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * Redistributions of source code must retain the above copyright notice, * this list of conditions and the following disclaimer. * * Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * Neither the name of the organization nor the names of its * contributors may be used to endorse or promote products derived from this * software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. ******************************************************************************/ %typemap(in,numinputs=0,noblock=1) (ldns_key **) { ldns_key *$1_key; $1 = &$1_key; } /* result generation */ %typemap(argout,noblock=1) (ldns_key **) { $result = SWIG_Python_AppendOutput($result, SWIG_NewPointerObj(SWIG_as_voidptr($1_key), SWIGTYPE_p_ldns_struct_key, SWIG_POINTER_OWN | 0 )); } %exception ldns_key_set_pubkey_owner(ldns_key *k, ldns_rdf *r) %{ $action Py_INCREF(obj1); %} %nodefaultctor ldns_struct_key; //no default constructor & destructor %nodefaultdtor ldns_struct_key; %delobject ldns_key_free; %delobject ldns_key_deep_free; %newobject ldns_key_list_pop_key; %newobject ldns_key2rr; %newobject ldns_key_new_frm_algorithm; %newobject ldns_key_new_frm_fp; %newobject ldns_key_new_frm_fp_l; %newobject ldns_key_new_frm_engine; %rename(ldns_key) ldns_struct_key; #ifdef LDNS_DEBUG %rename(__ldns_key_free) ldns_key_free; %inline %{ void _ldns_key_free (ldns_key* k) { printf("******** LDNS_KEY free 0x%lX ************\n", (long unsigned int)k); ldns_key_deep_free(k); } %} #else %rename(_ldns_key_free) ldns_key_deep_free; %rename(__ldns_key_free) ldns_key_free; #endif %feature("docstring") ldns_struct_key "Key class This class can contains all types of keys that are used in DNSSEC. Mostly used to store private keys, since public keys can also be stored in a ldns_rr with type LDNS_RR_TYPE_DNSKEY. This class can also store some variables that influence the signatures generated by signing with this key, for instance the inception date. **Usage** >>> import ldns >>> ldns.ldns_init_random(open(\"/dev/random\",\"rb\"), 512/8) >>> key = ldns.ldns_key.new_frm_algorithm(ldns.LDNS_SIGN_DSA, 512) #generate new DSA key >>> print key Private-key-format: v1.2 Algorithm: 3 (DSA) Prime(p): XXXXXXXXHRQBGRflHZQriSAoLI2g+LGvZz8BlEesO+ZQg65wrFGs9IC441y/mn3nFnXfCdtX6zbN5bQuabPdlQ== Subprime(q): XXXXXdnWs/cWsGDglhEyZRLEVA8= Base(g): XXXXXXXqrd+dm2bcxDBdCsZRzkXQ22FxCk2ycnjgevr+s2HfA57BPk3xwqCrHUwuOBVg3Fvq4bpldrCe0sT6Og== Private_value(x): XXXXXcVubZF33pj04z4ZoETsQW1Y= Public_value(y): XXXXXX8t6zfOxJHoy57qteIw9sOZ/Zu0yFiPO083sPm11NlFx3b4m7TJ2k41gYicHXHLUQK1p0xXFToeZEkPGQ== >>> fw = open(\"key.priv\", \"wb\") >>> key.print_to_file(fw) #write priv key to file " %extend ldns_struct_key { %pythoncode %{ def __init__(self): self.this = _ldns.ldns_key_new() if not self.this: raise Exception("Can't create instance of this class") __swig_destroy__ = _ldns._ldns_key_free def __str__(self): """converts the data to presentation format""" return _ldns.ldns_key2str(self) def key_to_rr(self): """converts a ldns_key to a public key rr :returns: (ldns_rr \*) ldns_rr representation of the key """ return _ldns.ldns_key2rr(self) #parameters: const ldns_key *, #retvals: ldns_rr * def print_to_file(self, file): """print a private key to the file ouput :param file: output file pointer """ _ldns.ldns_key_print(file, self) #parameters: FILE *, const ldns_key *, #retvals: #LDNS_KEY_CONSTRUCTORS_# @staticmethod def new_frm_fp(file, raiseException=True): """Creates a new priv key based on the contents of the file pointed by fp. :param file: a file object :param raiseException: if True, an exception occurs in case a key instance can't be created :returns: key instance or None. If the object can't be created and raiseException is True, an exception occurs. """ status, key = _ldns.ldns_key_new_frm_fp(file) if status != LDNS_STATUS_OK: if (raiseException): raise Exception("Can't create key, error: %s (%d)" % (_ldns.ldns_get_errorstr_by_id(status),status)) return None return key @staticmethod def new_frm_fp_l(file, raiseException=True): """Creates a new private key based on the contents of the file pointed by fp. :param file: a file object :param raiseException: if True, an exception occurs in case a key instance can't be created :returns: * key - key instance or None. If an instance can't be created and raiseException is True, an exception occurs. * line - the line number (for debugging) """ status, key, line = _ldns.ldns_key_new_frm_fp_l(file) if status != LDNS_STATUS_OK: if (raiseException): raise Exception("Can't create key, error: %d" % status) return None return key, line @staticmethod def new_frm_algorithm(algorithm, size, raiseException=True): """Creates a new key based on the algorithm. :param algorithm: the algorithm to use :param size: the number of bytes for the keysize :param raiseException: if True, an exception occurs in case a key instance can't be created :returns: key instance or None. If the object can't be created and raiseException is True, an exception occurs. **Algorithms** LDNS_SIGN_RSAMD5, LDNS_SIGN_RSASHA1, LDNS_SIGN_DSA, LDNS_SIGN_RSASHA1_NSEC3, LDNS_SIGN_RSASHA256, LDNS_SIGN_RSASHA256_NSEC3, LDNS_SIGN_RSASHA512, LDNS_SIGN_RSASHA512_NSEC3, LDNS_SIGN_DSA_NSEC3, LDNS_SIGN_HMACMD5, LDNS_SIGN_HMACSHA1, LDNS_SIGN_HMACSHA256 """ key = _ldns.ldns_key_new_frm_algorithm(algorithm, size) if (not key) and (raiseException): raise Exception("Can't create key, error: %d" % status) return key #_LDNS_KEY_CONSTRUCTORS# #LDNS_KEY_METHODS_# def algorithm(self): """return the signing alg of the key :returns: (ldns_signing_algorithm) the algorithm """ return _ldns.ldns_key_algorithm(self) #parameters: const ldns_key *, #retvals: ldns_signing_algorithm def dsa_key(self): """returns the (openssl) DSA struct contained in the key :returns: (DSA \*) """ return _ldns.ldns_key_dsa_key(self) #parameters: const ldns_key *, #retvals: DSA * def evp_key(self): """returns the (openssl) EVP struct contained in the key :returns: (EVP_PKEY \*) the RSA * structure in the key """ return _ldns.ldns_key_evp_key(self) #parameters: const ldns_key *, #retvals: EVP_PKEY * def expiration(self): """return the key's expiration date :returns: (uint32_t) the experiration date """ return _ldns.ldns_key_expiration(self) #parameters: const ldns_key *, #retvals: uint32_t def flags(self): """return the flag of the key :returns: (uint16_t) the flag """ return _ldns.ldns_key_flags(self) #parameters: const ldns_key *, #retvals: uint16_t def hmac_key(self): """return the hmac key data :returns: (unsigned char \*) the hmac key data """ return _ldns.ldns_key_hmac_key(self) #parameters: const ldns_key *, #retvals: unsigned char * def hmac_size(self): """return the hmac key size :returns: (size_t) the hmac key size """ return _ldns.ldns_key_hmac_size(self) #parameters: const ldns_key *, #retvals: size_t def inception(self): """return the key's inception date :returns: (uint32_t) the inception date """ return _ldns.ldns_key_inception(self) #parameters: const ldns_key *, #retvals: uint32_t def keytag(self): """return the keytag :returns: (uint16_t) the keytag """ return _ldns.ldns_key_keytag(self) #parameters: const ldns_key *, #retvals: uint16_t def origttl(self): """return the original ttl of the key :returns: (uint32_t) the original ttl """ return _ldns.ldns_key_origttl(self) #parameters: const ldns_key *, #retvals: uint32_t def pubkey_owner(self): """return the public key's owner :returns: (ldns_rdf \*) the owner """ return _ldns.ldns_key_pubkey_owner(self) #parameters: const ldns_key *, #retvals: ldns_rdf * def rsa_key(self): """returns the (openssl) RSA struct contained in the key :returns: (RSA \*) the RSA * structure in the key """ return _ldns.ldns_key_rsa_key(self) #parameters: const ldns_key *, #retvals: RSA * def set_algorithm(self,l): """Set the key's algorithm. :param l: the algorithm """ _ldns.ldns_key_set_algorithm(self,l) #parameters: ldns_key *,ldns_signing_algorithm, #retvals: def set_dsa_key(self,d): """Set the key's dsa data. :param d: the dsa data """ _ldns.ldns_key_set_dsa_key(self,d) #parameters: ldns_key *,DSA *, #retvals: def set_evp_key(self,e): """Set the key's evp key. :param e: the evp key """ _ldns.ldns_key_set_evp_key(self,e) #parameters: ldns_key *,EVP_PKEY *, #retvals: def set_expiration(self,e): """Set the key's expiration date (seconds after epoch). :param e: the expiration """ _ldns.ldns_key_set_expiration(self,e) #parameters: ldns_key *,uint32_t, #retvals: def set_flags(self,flags): """Set the key's flags. :param flags: the flags """ _ldns.ldns_key_set_flags(self,flags) #parameters: ldns_key *,uint16_t, #retvals: def set_hmac_key(self,hmac): """Set the key's hmac data. :param hmac: the raw key data """ _ldns.ldns_key_set_hmac_key(self,hmac) #parameters: ldns_key *,unsigned char *, #retvals: def set_hmac_size(self,hmac_size): """Set the key's hmac size. :param hmac_size: the size of the hmac data """ _ldns.ldns_key_set_hmac_size(self,hmac_size) #parameters: ldns_key *,size_t, #retvals: def set_inception(self,i): """Set the key's inception date (seconds after epoch). :param i: the inception """ _ldns.ldns_key_set_inception(self,i) #parameters: ldns_key *,uint32_t, #retvals: def set_keytag(self,tag): """Set the key's key tag. :param tag: the keytag """ _ldns.ldns_key_set_keytag(self,tag) #parameters: ldns_key *,uint16_t, #retvals: def set_origttl(self,t): """Set the key's original ttl. :param t: the ttl """ _ldns.ldns_key_set_origttl(self,t) #parameters: ldns_key *,uint32_t, #retvals: def set_pubkey_owner(self,r): """Set the key's pubkey owner. :param r: the owner """ _ldns.ldns_key_set_pubkey_owner(self,r) #parameters: ldns_key *,ldns_rdf *, #retvals: def set_rsa_key(self,r): """Set the key's rsa data. :param r: the rsa data """ _ldns.ldns_key_set_rsa_key(self,r) #parameters: ldns_key *,RSA *, #retvals: def set_use(self,v): """set the use flag :param v: the boolean value to set the _use field to """ _ldns.ldns_key_set_use(self,v) #parameters: ldns_key *,bool, #retvals: def use(self): """return the use flag :returns: (bool) the boolean value of the _use field """ return _ldns.ldns_key_use(self) #parameters: const ldns_key *, #retvals: bool #_LDNS_KEY_METHODS# %} } %nodefaultctor ldns_struct_key_list; //no default constructor & destructor %nodefaultdtor ldns_struct_key_list; %newobject ldns_key_list_new; %newobject ldns_key_list_pop_key; %delobject ldns_key_list_free; %delobject ldns_key_list_push_key; %rename(ldns_key_list) ldns_struct_key_list; #ifdef LDNS_DEBUG %rename(__ldns_key_list_free) ldns_key_list_free; %inline %{ void _ldns_key_list_free (ldns_key_list* k) { printf("******** LDNS_KEY_LIST free 0x%lX ************\n", (long unsigned int)k); ldns_key_list_free(k); } %} #else %rename(_ldns_key_list_free) ldns_key_list_free; #endif %extend ldns_struct_key_list { %pythoncode %{ def __init__(self): self.this = _ldns.ldns_key_list_new() if not self.this: raise Exception("Can't create class") __swig_destroy__ = _ldns._ldns_key_list_free def keys(self): """Key list iterator""" for i in range(0, self.key_count()): yield self.key(i) def __str__(self): i = 0 s = "" for k in self.keys(): i += 1 s += "key %d:\n %s\n" % (i, str(k).replace("\n","\n ")) return s #LDNS_KEY_LIST_METHODS_# def key(self,nr): """returns a pointer to the key in the list at the given position :param nr: the position in the list :returns: (ldns_key \*) the key """ return _ldns.ldns_key_list_key(self,nr) #parameters: const ldns_key_list *,size_t, #retvals: ldns_key * def key_count(self): """returns the number of keys in the key list :returns: (size_t) the numbers of keys in the list """ return _ldns.ldns_key_list_key_count(self) #parameters: const ldns_key_list *, #retvals: size_t def pop_key(self): """pops the last rr from a keylist :returns: (ldns_key \*) NULL if nothing to pop. Otherwise the popped RR """ return _ldns.ldns_key_list_pop_key(self) #parameters: ldns_key_list *, #retvals: ldns_key * def push_key(self,key): """pushes a key to a keylist :param key: the key to push :returns: (bool) false on error, otherwise true """ return _ldns.ldns_key_list_push_key(self,key) #parameters: ldns_key_list *,ldns_key *, #retvals: bool def set_key_count(self,count): """Set the keylist's key count to count. :param count: the cuont """ _ldns.ldns_key_list_set_key_count(self,count) #parameters: ldns_key_list *,size_t, #retvals: def set_use(self,v): """Set the 'use' flag for all keys in the list. :param v: The value to set the use flags to """ _ldns.ldns_key_list_set_use(self,v) #parameters: ldns_key_list *,bool, #retvals: #_LDNS_KEY_LIST_METHODS# %} } ldns-1.6.17/contrib/python/ldns.i0000664000175100017510000003264212264060151016215 0ustar willemwillem/* * ldns.i: LDNS interface file * * Copyright (c) 2009, Zdenek Vasicek (vasicek AT fit.vutbr.cz) * Karel Slany (slany AT fit.vutbr.cz) * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * Redistributions of source code must retain the above copyright notice, * this list of conditions and the following disclaimer. * * Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * Neither the name of the organization nor the names of its * contributors may be used to endorse or promote products derived from this * software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. */ %module ldns #pragma SWIG nowarn=454 %{ #include "ldns.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include %} //#define LDNS_DEBUG //#define SWIG_FILE3_DEBUG %include "stdint.i" // uint_16_t is known type now #ifdef PY3 %include "file_py3.i" // python 3 FILE * #else %include "file.i" // FILE * #endif %include "typemaps.i" /* ========================================================================= */ /* Preliminary Python code. */ /* ========================================================================= */ %pythoncode %{ # # Use and don't ignore DeprecationWarning and # PendingDeprecationWarning. # import warnings warnings.filterwarnings("module", category=DeprecationWarning) warnings.filterwarnings("module", category=PendingDeprecationWarning) %} /* Tell SWIG how to handle ssize_t as input parameter. */ %typemap(in, noblock=1) (ssize_t) { int $1_res = 0; $1_res = SWIG_AsVal_long($input, &$1); if (!SWIG_IsOK($1_res)) { SWIG_exception_fail(SWIG_ArgError($1_res), "in method '" "$symname" "', argument " "$argnum" " of type '" "$type""'"); } } %inline %{ struct timeval* ldns_make_timeval(uint32_t sec, uint32_t usec) { struct timeval* res = (struct timeval*)malloc(sizeof(*res)); res->tv_sec = sec; res->tv_usec = usec; return res; } uint32_t ldns_read_timeval_sec(struct timeval* t) { return (uint32_t)t->tv_sec; } uint32_t ldns_read_timeval_usec(struct timeval* t) { return (uint32_t)t->tv_usec; } %} %immutable ldns_struct_lookup_table::name; %immutable ldns_struct_rr_descriptor::_name; %immutable ldns_error_str; %immutable ldns_signing_algorithms; //*_new_frm_fp_l %apply int *OUTPUT { (int *line_nr) }; %apply uint32_t *OUTPUT { uint32_t *default_ttl}; // wire2pkt %apply (char *STRING, int LENGTH) { (const char *str, int len) }; %include "ldns_packet.i" %include "ldns_resolver.i" %include "ldns_rr.i" %inline %{ int Python_str_Check(PyObject *o) { #if PY_VERSION_HEX>=0x03000000 return PyUnicode_Check(o); #else return PyString_Check(o); #endif } %} %include "ldns_rdf.i" %include "ldns_zone.i" %include "ldns_key.i" %include "ldns_buffer.i" %include "ldns_dnssec.i" %include %include %include %include %include %include %include %include %include %include %include %include %include %include %include %include %include %include %include %include %include %include %include %include %include typedef struct ldns_dnssec_name { }; typedef struct ldns_dnssec_rrs { }; typedef struct ldns_dnssec_rrsets { }; typedef struct ldns_dnssec_zone { }; // ================================================================================ %include "ldns_dname.i" %inline %{ PyObject* ldns_rr_new_frm_str_(const char *str, uint32_t default_ttl, ldns_rdf* origin, ldns_rdf* prev) //returns tuple (status, ldns_rr, prev) { PyObject* tuple; /* origin and prev have to be cloned in order to decouple the data * from the python wrapper */ if (origin != NULL) origin = ldns_rdf_clone(origin); if (prev != NULL) prev = ldns_rdf_clone(prev); ldns_rdf *p_prev = prev; ldns_rdf **pp_prev = &p_prev; if (p_prev == 0) pp_prev = 0; ldns_rr *p_rr = 0; ldns_rr **pp_rr = &p_rr; ldns_status st = ldns_rr_new_frm_str(pp_rr, str, default_ttl, origin, pp_prev); tuple = PyTuple_New(3); PyTuple_SetItem(tuple, 0, SWIG_From_int(st)); PyTuple_SetItem(tuple, 1, (st == LDNS_STATUS_OK) ? SWIG_NewPointerObj(SWIG_as_voidptr(p_rr), SWIGTYPE_p_ldns_struct_rr, SWIG_POINTER_OWN | 0 ) : (Py_INCREF(Py_None), Py_None)); PyTuple_SetItem(tuple, 2, (p_prev != prev) ? SWIG_NewPointerObj(SWIG_as_voidptr(p_prev), SWIGTYPE_p_ldns_struct_rdf, SWIG_POINTER_OWN | 0 ) : (Py_INCREF(Py_None), Py_None)); return tuple; } PyObject* ldns_rr_new_frm_fp_(FILE *fp, uint32_t default_ttl, ldns_rdf* origin, ldns_rdf* prev) //returns tuple (status, ldns_rr, ttl, origin, prev) { uint32_t defttl = default_ttl; uint32_t *p_defttl = &defttl; if (defttl == 0) p_defttl = 0; /* origin and prev have to be cloned in order to decouple the data * from the python wrapper */ if (origin != NULL) origin = ldns_rdf_clone(origin); if (prev != NULL) prev = ldns_rdf_clone(prev); ldns_rdf *p_origin = origin; ldns_rdf **pp_origin = &p_origin; //if (p_origin == 0) pp_origin = 0; ldns_rdf *p_prev = prev; ldns_rdf **pp_prev = &p_prev; //if (p_prev == 0) pp_prev = 0; ldns_rr *p_rr = 0; ldns_rr **pp_rr = &p_rr; ldns_status st = ldns_rr_new_frm_fp(pp_rr, fp, p_defttl, pp_origin, pp_prev); PyObject* tuple; tuple = PyTuple_New(5); int idx = 0; PyTuple_SetItem(tuple, idx, SWIG_From_int(st)); idx++; PyTuple_SetItem(tuple, idx, (st == LDNS_STATUS_OK) ? SWIG_NewPointerObj(SWIG_as_voidptr(p_rr), SWIGTYPE_p_ldns_struct_rr, SWIG_POINTER_OWN | 0 ) : (Py_INCREF(Py_None), Py_None)); idx++; PyTuple_SetItem(tuple, idx, SWIG_From_int(defttl)); idx++; PyTuple_SetItem(tuple, idx, SWIG_NewPointerObj(SWIG_as_voidptr(p_origin), SWIGTYPE_p_ldns_struct_rdf, SWIG_POINTER_OWN | 0 )); idx++; PyTuple_SetItem(tuple, idx, SWIG_NewPointerObj(SWIG_as_voidptr(p_prev), SWIGTYPE_p_ldns_struct_rdf, SWIG_POINTER_OWN | 0 )); return tuple; } PyObject* ldns_rr_new_frm_fp_l_(FILE *fp, uint32_t default_ttl, ldns_rdf* origin, ldns_rdf* prev) //returns tuple (status, ldns_rr, line, ttl, origin, prev) { int linenr = 0; int *p_linenr = &linenr; uint32_t defttl = default_ttl; uint32_t *p_defttl = &defttl; if (defttl == 0) p_defttl = 0; /* origin and prev have to be cloned in order to decouple the data * from the python wrapper */ if (origin != NULL) origin = ldns_rdf_clone(origin); if (prev != NULL) prev = ldns_rdf_clone(prev); ldns_rdf *p_origin = origin; ldns_rdf **pp_origin = &p_origin; //if (p_origin == 0) pp_origin = 0; ldns_rdf *p_prev = prev; ldns_rdf **pp_prev = &p_prev; //if (p_prev == 0) pp_prev = 0; ldns_rr *p_rr = 0; ldns_rr **pp_rr = &p_rr; ldns_status st = ldns_rr_new_frm_fp_l(pp_rr, fp, p_defttl, pp_origin, pp_prev, p_linenr); PyObject* tuple; tuple = PyTuple_New(6); int idx = 0; PyTuple_SetItem(tuple, idx, SWIG_From_int(st)); idx++; PyTuple_SetItem(tuple, idx, (st == LDNS_STATUS_OK) ? SWIG_NewPointerObj(SWIG_as_voidptr(p_rr), SWIGTYPE_p_ldns_struct_rr, SWIG_POINTER_OWN | 0 ) : (Py_INCREF(Py_None), Py_None)); idx++; PyTuple_SetItem(tuple, idx, SWIG_From_int(linenr)); idx++; PyTuple_SetItem(tuple, idx, SWIG_From_int(defttl)); idx++; PyTuple_SetItem(tuple, idx, SWIG_NewPointerObj(SWIG_as_voidptr(p_origin), SWIGTYPE_p_ldns_struct_rdf, SWIG_POINTER_OWN | 0 )); idx++; PyTuple_SetItem(tuple, idx, SWIG_NewPointerObj(SWIG_as_voidptr(p_prev), SWIGTYPE_p_ldns_struct_rdf, SWIG_POINTER_OWN | 0 )); return tuple; } PyObject* ldns_rr_new_question_frm_str_(const char *str, ldns_rdf* origin, ldns_rdf* prev) //returns tuple (status, ldns_rr, prev) { PyObject* tuple; /* origin and prev have to be cloned in order to decouple the data * from the python wrapper */ if (origin != NULL) origin = ldns_rdf_clone(origin); if (prev != NULL) prev = ldns_rdf_clone(prev); ldns_rdf *p_prev = prev; ldns_rdf **pp_prev = &p_prev; if (p_prev == 0) pp_prev = 0; ldns_rr *p_rr = 0; ldns_rr **pp_rr = &p_rr; ldns_status st = ldns_rr_new_question_frm_str(pp_rr, str, origin, pp_prev); tuple = PyTuple_New(3); PyTuple_SetItem(tuple, 0, SWIG_From_int(st)); PyTuple_SetItem(tuple, 1, (st == LDNS_STATUS_OK) ? SWIG_NewPointerObj(SWIG_as_voidptr(p_rr), SWIGTYPE_p_ldns_struct_rr, SWIG_POINTER_OWN | 0 ) : (Py_INCREF(Py_None), Py_None)); PyTuple_SetItem(tuple, 2, (p_prev != prev) ? SWIG_NewPointerObj(SWIG_as_voidptr(p_prev), SWIGTYPE_p_ldns_struct_rdf, SWIG_POINTER_OWN | 0 ) : (Py_INCREF(Py_None), Py_None)); return tuple; } PyObject* ldns_fetch_valid_domain_keys_(const ldns_resolver * res, const ldns_rdf * domain, const ldns_rr_list * keys) //returns tuple (status, result) { PyObject* tuple; ldns_rr_list *rrl = 0; ldns_status st = 0; rrl = ldns_fetch_valid_domain_keys(res, domain, keys, &st); tuple = PyTuple_New(2); PyTuple_SetItem(tuple, 0, SWIG_From_int(st)); PyTuple_SetItem(tuple, 1, (st == LDNS_STATUS_OK) ? SWIG_NewPointerObj(SWIG_as_voidptr(rrl), SWIGTYPE_p_ldns_struct_rr_list, SWIG_POINTER_OWN | 0 ) : (Py_INCREF(Py_None), Py_None)); return tuple; } PyObject* ldns_wire2pkt_(const char *str, int len) //returns tuple (status, result) { PyObject *resultobj = 0; ldns_pkt *arg1 = NULL; uint8_t *arg2 = (uint8_t *) str; size_t arg3 = (size_t) len; ldns_status result; PyObject* tuple; result = (ldns_status)ldns_wire2pkt(&arg1,arg2,arg3); tuple = PyTuple_New(2); PyTuple_SetItem(tuple, 0, SWIG_From_int(result)); if (result == LDNS_STATUS_OK) PyTuple_SetItem(tuple, 1, SWIG_NewPointerObj(SWIG_as_voidptr(arg1), SWIGTYPE_p_ldns_struct_pkt, SWIG_POINTER_OWN | 0 )); else { Py_INCREF(Py_None); PyTuple_SetItem(tuple, 1, Py_None); } return tuple; } %} %pythoncode %{ def ldns_fetch_valid_domain_keys(res, domain, keys): return _ldns.ldns_fetch_valid_domain_keys_(res, domain, keys) def ldns_wire2pkt(data): return _ldns.ldns_wire2pkt_(data) def ldns_rr_iter_frm_fp_l(input_file): """Creates an iterator (generator) that returns individual parsed RRs from an open zone file.""" # variables that preserve the parsers state my_ttl = 0; my_origin = None my_prev = None # additional state variables last_pos = 0 line_nr = 0 while True: ret = _ldns.ldns_rr_new_frm_fp_l_(input_file, my_ttl, my_origin, my_prev) s, rr, line_inc, new_ttl, new_origin, new_prev = ret # unpack the result line_nr += line_inc # increase number of parsed lines my_prev = new_prev # update ref to previous owner if s == _ldns.LDNS_STATUS_SYNTAX_TTL: my_ttl = new_ttl # update default TTL elif s == _ldns.LDNS_STATUS_SYNTAX_ORIGIN: my_origin = new_origin # update reference to origin elif s == _ldns.LDNS_STATUS_SYNTAX_EMPTY: if last_pos == input_file.tell(): break # no advance since last read - EOF last_pos = input_file.tell() elif s != _ldns.LDNS_STATUS_OK: raise ValueError("Parse error in line %d" % line_nr) else: # we are sure to have LDNS_STATUS_OK yield rr %} ldns-1.6.17/contrib/python/LICENSE0000664000175100017510000000310212264060151016075 0ustar willemwillemCopyright (c) 2009, Zdenek Vasicek (vasicek AT fit.vutbr.cz) Karel Slany (slany AT fit.vutbr.cz) All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the name of the organization nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ldns-1.6.17/contrib/python/ldns_packet.i0000664000175100017510000014312312264060151017541 0ustar willemwillem/****************************************************************************** * ldns_packet.i: LDNS packet class * * Copyright (c) 2009, Zdenek Vasicek (vasicek AT fit.vutbr.cz) * Karel Slany (slany AT fit.vutbr.cz) * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * Redistributions of source code must retain the above copyright notice, * this list of conditions and the following disclaimer. * * Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * Neither the name of the organization nor the names of its * contributors may be used to endorse or promote products derived from * this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. *****************************************************************************/ /* ========================================================================= */ /* SWIG setting and definitions. */ /* ========================================================================= */ /* Creates a temporary instance of (ldns_pkt *). */ %typemap(in,numinputs=0,noblock=1) (ldns_pkt **) { ldns_pkt *$1_pkt; $1 = &$1_pkt; } /* Result generation, appends (ldns_pkt *) after the result. */ %typemap(argout,noblock=1) (ldns_pkt **) { $result = SWIG_Python_AppendOutput($result, SWIG_NewPointerObj(SWIG_as_voidptr($1_pkt), SWIGTYPE_p_ldns_struct_pkt, SWIG_POINTER_OWN | 0 )); } %newobject ldns_pkt_new; %newobject ldns_pkt_clone; %newobject ldns_pkt_rr_list_by_type; %newobject ldns_pkt_rr_list_by_name_and_type; %newobject ldns_pkt_rr_list_by_name; %newobject ldns_update_pkt_new; %nodefaultctor ldns_struct_pkt; /* No default constructor. */ %nodefaultdtor ldns_struct_pkt; /* No default destructor. */ %rename(ldns_pkt) ldns_struct_pkt; %newobject ldns_pkt2str; %newobject ldns_pkt_opcode2str; %newobject ldns_pkt_rcode2str; %newobject ldns_pkt_algorithm2str; %newobject ldns_pkt_cert_algorithm2str; %newobject ldns_pkt_get_section_clone; /* Clone data on pull. */ %newobject _ldns_pkt_additional; %rename(__ldns_pkt_additional) ldns_pkt_additional; %inline %{ ldns_rr_list * _ldns_pkt_additional(ldns_pkt *p) { return ldns_rr_list_clone(ldns_pkt_additional(p)); } %} %newobject _ldns_pkt_answer; %rename(__ldns_pkt_answer) ldns_pkt_answer; %inline %{ ldns_rr_list * _ldns_pkt_answer(ldns_pkt *p) { return ldns_rr_list_clone(ldns_pkt_answer(p)); } %} %newobject _ldns_pkt_answerfrom; %rename(__ldns_pkt_answerfrom) ldns_pkt_answerfrom; %inline %{ ldns_rdf * _ldns_pkt_answerfrom(ldns_pkt *p) { ldns_rdf *rdf; rdf = ldns_pkt_answerfrom(p); if (rdf != NULL) { rdf = ldns_rdf_clone(rdf); } return rdf; } %} %newobject _ldns_pkt_authority; %rename(__ldns_pkt_authority) ldns_pkt_authority; %inline %{ ldns_rr_list * _ldns_pkt_authority(ldns_pkt *p) { return ldns_rr_list_clone(ldns_pkt_authority(p)); } %} %newobject _ldns_pkt_edns_data; %rename(__ldns_pkt_edns_data) ldns_pkt_edns_data; %inline %{ ldns_rdf * _ldns_pkt_edns_data(ldns_pkt *p) { ldns_rdf *rdf; rdf = ldns_pkt_edns_data(p); if (rdf != NULL) { rdf = ldns_rdf_clone(rdf); } return rdf; } %} %newobject _ldns_pkt_tsig; %rename(__ldns_pkt_tsig) ldns_pkt_tsig; %inline %{ ldns_rr * _ldns_pkt_tsig(const ldns_pkt *pkt) { return ldns_rr_clone(ldns_pkt_tsig(pkt)); } %} %newobject _ldns_pkt_question; %rename(__ldns_pkt_question) ldns_pkt_question; %inline %{ ldns_rr_list * _ldns_pkt_question(ldns_pkt *p) { return ldns_rr_list_clone(ldns_pkt_question(p)); } %} /* End of pull cloning. */ /* Clone data on push. */ %newobject _ldns_pkt_query_new; %rename(__ldns_pkt_query_new) ldns_pkt_query_new; %inline %{ ldns_pkt * _ldns_pkt_query_new(ldns_rdf *rr_name, ldns_rr_type rr_type, ldns_rr_class rr_class, uint16_t flags) { return ldns_pkt_query_new(ldns_rdf_clone(rr_name), rr_type, rr_class, flags); } %} %rename(__ldns_pkt_push_rr) ldns_pkt_push_rr; %inline %{ bool _ldns_pkt_push_rr(ldns_pkt *p, ldns_pkt_section sec, ldns_rr *rr) { return ldns_pkt_push_rr(p, sec, ldns_rr_clone(rr)); } %} %rename(__ldns_pkt_safe_push_rr) ldns_pkt_safe_push_rr; %inline %{ bool _ldns_pkt_safe_push_rr(ldns_pkt *pkt, ldns_pkt_section sec, ldns_rr *rr) { /* Prevents memory leaks when fails. */ ldns_rr *rr_clone = NULL; bool ret; if (rr != NULL) { rr_clone = ldns_rr_clone(rr); } ret = ldns_pkt_safe_push_rr(pkt, sec, rr_clone); if (!ret) { ldns_rr_free(rr_clone); } return ret; } %} %rename(__ldns_pkt_push_rr_list) ldns_pkt_push_rr_list; %inline %{ bool _ldns_pkt_push_rr_list(ldns_pkt *p, ldns_pkt_section sec, ldns_rr_list *rrl) { return ldns_pkt_push_rr_list(p, sec, ldns_rr_list_clone(rrl)); } %} %rename(__ldns_pkt_safe_push_rr_list) ldns_pkt_safe_push_rr_list; %inline %{ bool _ldns_pkt_safe_push_rr_list(ldns_pkt *p, ldns_pkt_section s, ldns_rr_list *rrl) { /* Prevents memory leaks when fails. */ ldns_rr_list *rrl_clone = NULL; bool ret; if (rrl != NULL) { rrl_clone = ldns_rr_list_clone(rrl); } ret = ldns_pkt_safe_push_rr_list(p, s, rrl_clone); if (!ret) { ldns_rr_list_free(rrl_clone); } return ret; } %} %rename(__ldns_pkt_set_additional) ldns_pkt_set_additional; %inline %{ void _ldns_pkt_set_additional(ldns_pkt *p, ldns_rr_list *rrl) { ldns_rr_list *rrl_clone = NULL; if (rrl != NULL) { rrl_clone = ldns_rr_list_clone(rrl); } /* May leak memory, when overwriting pointer value. */ ldns_pkt_set_additional(p, rrl_clone); } %} %rename(__ldns_pkt_set_answer) ldns_pkt_set_answer; %inline %{ void _ldns_pkt_set_answer(ldns_pkt *p, ldns_rr_list *rrl) { ldns_rr_list *rrl_clone = NULL; if (rrl != NULL) { rrl_clone = ldns_rr_list_clone(rrl); } /* May leak memory, when overwriting pointer value. */ ldns_pkt_set_answer(p, rrl_clone); } %} %rename (__ldns_pkt_set_answerfrom) ldns_pkt_set_answerfrom; %inline %{ void _ldns_pkt_set_answerfrom(ldns_pkt *packet, ldns_rdf *rdf) { ldns_rdf *rdf_clone = NULL; if (rdf != NULL) { rdf_clone = ldns_rdf_clone(rdf); } /* May leak memory, when overwriting pointer value. */ ldns_pkt_set_answerfrom(packet, rdf_clone); } %} %rename(__ldns_pkt_set_authority) ldns_pkt_set_authority; %inline %{ void _ldns_pkt_set_authority(ldns_pkt *p, ldns_rr_list *rrl) { ldns_rr_list *rrl_clone = NULL; if (rrl != NULL) { rrl_clone = ldns_rr_list_clone(rrl); } /* May leak memory, when overwriting pointer value. */ ldns_pkt_set_authority(p, rrl_clone); } %} %rename(__ldns_pkt_set_edns_data) ldns_pkt_set_edns_data; %inline %{ void _ldns_pkt_set_edns_data(ldns_pkt *packet, ldns_rdf *rdf) { ldns_rdf *rdf_clone = NULL; if (rdf != NULL) { rdf_clone = ldns_rdf_clone(rdf); } /* May leak memory, when overwriting pointer value. */ ldns_pkt_set_edns_data(packet, rdf_clone); } %} %rename(__ldns_pkt_set_question) ldns_pkt_set_question; %inline %{ void _ldns_pkt_set_question(ldns_pkt *p, ldns_rr_list *rrl) { ldns_rr_list *rrl_clone = NULL; if (rrl != NULL) { rrl_clone = ldns_rr_list_clone(rrl); } /* May leak memory, when overwriting pointer value. */ ldns_pkt_set_question(p, rrl_clone); } %} %rename(__ldns_pkt_set_tsig) ldns_pkt_set_tsig; %inline %{ void _ldns_pkt_set_tsig(ldns_pkt *pkt, ldns_rr *rr) { ldns_rr *rr_clone = NULL; if (rr != NULL) { rr_clone = ldns_rr_clone(rr); } /* May leak memory, when overwriting pointer value. */ ldns_pkt_set_tsig(pkt, rr_clone); } %} /* End of push cloning. */ /* ========================================================================= */ /* Debugging related code. */ /* ========================================================================= */ #ifdef LDNS_DEBUG %rename(__ldns_pkt_free) ldns_pkt_free; %inline %{ /*! * @brief Prints information about deallocated pkt and deallocates. */ void _ldns_pkt_free (ldns_pkt* p) { printf("******** LDNS_PKT free 0x%lX ************\n", (long unsigned int) p); ldns_pkt_free(p); } %} #else /* !LDNS_DEBUG */ %rename(_ldns_pkt_free) ldns_pkt_free; #endif /* LDNS_DEBUG */ /* ========================================================================= */ /* Added C code. */ /* ========================================================================= */ /* None. */ /* ========================================================================= */ /* Encapsulating Python code. */ /* ========================================================================= */ %feature("docstring") ldns_struct_pkt "LDNS packet object. The :class:`ldns_pkt` object contains DNS packed (either a query or an answer). It is the complete representation of what you actually send to a name server, and what you get back (see :class:`ldns.ldns_resolver`). **Usage** >>> import ldns >>> resolver = ldns.ldns_resolver.new_frm_file(\"/etc/resolv.conf\") >>> pkt = resolver.query(\"nic.cz\", ldns.LDNS_RR_TYPE_NS,ldns.LDNS_RR_CLASS_IN) >>> print pkt ;; ->>HEADER<<- opcode: QUERY, rcode: NOERROR, id: 63004 ;; flags: qr rd ra ; QUERY: 1, ANSWER: 3, AUTHORITY: 0, ADDITIONAL: 0 ;; QUESTION SECTION: ;; nic.cz. IN NS ;; ANSWER SECTION: nic.cz. 758 IN NS a.ns.nic.cz. nic.cz. 758 IN NS c.ns.nic.cz. nic.cz. 758 IN NS e.ns.nic.cz. ;; AUTHORITY SECTION: ;; ADDITIONAL SECTION: ;; Query time: 8 msec ;; SERVER: 82.100.38.2 ;; WHEN: Thu Jan 11 12:54:33 2009 ;; MSG SIZE rcvd: 75 This simple example instances a resolver in order to resolve NS for nic.cz." %extend ldns_struct_pkt { %pythoncode %{ def __init__(self): """ Cannot be created directly from Python. """ raise Exception("This class can't be created directly. " + "Please use: ldns_pkt_new, ldns_pkt_query_new " + "or ldns_pkt_query_new_frm_str") __swig_destroy__ = _ldns._ldns_pkt_free # # LDNS_PKT_CONSTRUCTORS_ # @staticmethod def new(): """ Creates new empty packet structure. :return: (:class:`ldns_pkt` ) New empty packet. """ return _ldns.ldns_pkt_new() @staticmethod def new_query(rr_name, rr_type, rr_class, flags): """ Creates a packet with a query in it for the given name, type and class. :param rr_name: The name to query for. :type rr_name: :class:`ldns_dname` :param rr_type: The type to query for. :type rr_type: ldns_rr_type :param rr_class: The class to query for. :type rr_class: ldns_rr_class :param flags: Packet flags. :type flags: uint16_t :throws TypeError: When arguments of inappropriate types. :return: (:class:`ldns_pkt`) New object. .. note:: The type checking of parameter `rr_name` is benevolent. It allows also to pass a dname :class:`ldns_rdf` object. This will probably change in future. """ if (not isinstance(rr_name, ldns_dname)) and \ isinstance(rr_name, ldns_rdf) and \ rr_name.get_type() == _ldns.LDNS_RDF_TYPE_DNAME: warnings.warn("The ldns_pkt.new_query() method will" + " drop the possibility to accept ldns_rdf." + " Convert argument to ldns_dname.", PendingDeprecationWarning, stacklevel=2) if not isinstance(rr_name, ldns_rdf): raise TypeError("Parameter must be derived from ldns_rdf.") if (rr_name.get_type() != _ldns.LDNS_RDF_TYPE_DNAME): raise Exception("Operands must be ldns_dname.") return _ldns._ldns_pkt_query_new(rr_name, rr_type, rr_class, flags) @staticmethod def new_query_frm_str(rr_name, rr_type, rr_class, flags, raiseException = True): """ Creates a query packet for the given name, type, class. :param rr_name: The name to query for. :type rr_name: str :param rr_type: The type to query for. :type rr_type: ldns_rr_type :param rr_class: The class to query for. :type rr_class: ldns_rr_class :param flags: Packet flags. :type flags: uint16_t :param raiseException: If True, an exception occurs in case a packet object can't be created. :throws TypeError: When arguments of inappropriate types. :throws Exception: When raiseException set and packet couldn't be created. :return: (:class:`ldns_pkt`) Query packet object or None. If the object can't be created and raiseException is True, an exception occurs. **Usage** >>> pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_QR | ldns.LDNS_AA) >>> rra = ldns.ldns_rr.new_frm_str("test.nic.cz. IN A 192.168.1.1",300) >>> list = ldns.ldns_rr_list() >>> if (rra): list.push_rr(rra) >>> pkt.push_rr_list(ldns.LDNS_SECTION_ANSWER, list) >>> print pkt ;; ->>HEADER<<- opcode: QUERY, rcode: NOERROR, id: 0 ;; flags: qr aa ; QUERY: 1, ANSWER: 1, AUTHORITY: 0, ADDITIONAL: 0 ;; QUESTION SECTION: ;; test.nic.cz. IN ANY ;; ANSWER SECTION: test.nic.cz. 300 IN A 192.168.1.1 ;; AUTHORITY SECTION: ;; ADDITIONAL SECTION: ;; Query time: 0 msec ;; WHEN: Thu Jan 1 01:00:00 1970 ;; MSG SIZE rcvd: 0 """ status, pkt = _ldns.ldns_pkt_query_new_frm_str(rr_name, rr_type, rr_class, flags) if status != LDNS_STATUS_OK: if (raiseException): raise Exception("Can't create query packet, error: %d" % status) return None return pkt # # _LDNS_PKT_CONSTRUCTORS # def __str__(self): """ Converts the data in the DNS packet to presentation format. :return: (str) """ return _ldns.ldns_pkt2str(self) def opcode2str(self): """ Converts a packet opcode to its mnemonic and returns that as an allocated null-terminated string. :return: (str) """ return _ldns.ldns_pkt_opcode2str(self.get_opcode()) def rcode2str(self): """ Converts a packet rcode to its mnemonic and returns that as an allocated null-terminated string. :return: (str) """ return _ldns.ldns_pkt_rcode2str(self.get_rcode()) def print_to_file(self, output): """ Prints the data in the DNS packet to the given file stream (in presentation format). :param output: Opened file to write to. :type output: file :throws TypeError: When arguments of inappropriate types. """ _ldns.ldns_pkt_print(output, self) #parameters: FILE *,const ldns_pkt *, def write_to_buffer(self, buffer): """ Copies the packet data to the buffer in wire format. :param buffer: Buffer to append the result to. :type buffer: :class:`ldns_buffer` :throws TypeError: When arguments of inappropriate types. :return: (ldns_status) ldns_status """ return _ldns.ldns_pkt2buffer_wire(buffer, self) #parameters: ldns_buffer *,const ldns_pkt *, #retvals: ldns_status @staticmethod def algorithm2str(alg): """ Converts a signing algorithms to its mnemonic and returns that as an allocated null-terminated string. :param alg: The algorithm to convert to text. :type alg: ldns_algorithm :return: (str) """ return _ldns.ldns_pkt_algorithm2str(alg) #parameters: ldns_algorithm, @staticmethod def cert_algorithm2str(alg): """ Converts a cert algorithm to its mnemonic and returns that as an allocated null-terminated string. :param alg: Cert algorithm to convert to text. :type alg: ldns_cert_algorithm :return: (str) """ return _ldns.ldns_pkt_cert_algorithm2str(alg) #parameters: ldns_algorithm, # # LDNS_PKT_METHODS_ # def aa(self): """ Read the packet's aa bit. :return: (bool) Value of the bit. """ return _ldns.ldns_pkt_aa(self) #parameters: const ldns_pkt *, #retvals: bool def ad(self): """ Read the packet's ad bit. :return: (bool) Value of the bit. """ return _ldns.ldns_pkt_ad(self) #parameters: const ldns_pkt *, #retvals: bool def additional(self): """ Return the packet's additional section. :return: (:class:`ldns_rr_list`) The additional section. """ return _ldns._ldns_pkt_additional(self) #parameters: const ldns_pkt *, #retvals: ldns_rr_list * def all(self): """ Return the packet's question, answer, authority and additional sections concatenated. :return: (:class:`ldns_rr_list`) Concatenated sections. """ return _ldns.ldns_pkt_all(self) #parameters: const ldns_pkt *, #retvals: ldns_rr_list * def all_noquestion(self): """ Return the packet's answer, authority and additional sections concatenated. Like :meth:`all` but without the questions. :return: (:class:`ldns_rr_list`) Concatenated sections except questions. """ return _ldns.ldns_pkt_all_noquestion(self) #parameters: const ldns_pkt *, #retvals: ldns_rr_list * def ancount(self): """ Return the packet's an count. :return: (int) The an count. """ return _ldns.ldns_pkt_ancount(self) #parameters: const ldns_pkt *, #retvals: uint16_t def answer(self): """ Return the packet's answer section. :return: (:class:`ldns_rr_list`) The answer section. """ return _ldns._ldns_pkt_answer(self) #parameters: const ldns_pkt *, #retvals: ldns_rr_list * def answerfrom(self): """ Return the packet's answerfrom. :return: (:class:`ldns_rdf`) The name of the server. """ return _ldns._ldns_pkt_answerfrom(self) #parameters: const ldns_pkt *, #retvals: ldns_rdf * def arcount(self): """ Return the packet's ar count. :return: (int) The ar count. """ return _ldns.ldns_pkt_arcount(self) #parameters: const ldns_pkt *, #retvals: uint16_t def authority(self): """ Return the packet's authority section. :return: (:class:`ldns_rr_list`) The authority section. """ return _ldns._ldns_pkt_authority(self) #parameters: const ldns_pkt *, #retvals: ldns_rr_list * def cd(self): """ Read the packet's cd bit. :return: (bool) Value of the bit. """ return _ldns.ldns_pkt_cd(self) #parameters: const ldns_pkt *, #retvals: bool def clone(self): """ Clones the packet, creating a fully allocated copy. :return: (:class:`ldns_pkt`) New packet clone. """ return _ldns.ldns_pkt_clone(self) #parameters: ldns_pkt *, #retvals: ldns_pkt * def edns(self): """ Returns True if this packet needs and EDNS rr to be sent. At the moment the only reason is an expected packet size larger than 512 bytes, but for instance DNSSEC would be a good reason too. :return: (bool) True if packet needs EDNS rr. """ return _ldns.ldns_pkt_edns(self) #parameters: const ldns_pkt *, #retvals: bool def edns_data(self): """ Return the packet's edns data. :return: (:class:`ldns_rdf`) The ensd data. """ return _ldns._ldns_pkt_edns_data(self) #parameters: const ldns_pkt *, #retvals: ldns_rdf * def edns_do(self): """ Return the packet's edns do bit :return: (bool) The bit's value. """ return _ldns.ldns_pkt_edns_do(self) #parameters: const ldns_pkt *, #retvals: bool def edns_extended_rcode(self): """ Return the packet's edns extended rcode. :return: (uint8_t) The rcode. """ return _ldns.ldns_pkt_edns_extended_rcode(self) #parameters: const ldns_pkt *, #retvals: uint8_t def edns_udp_size(self): """ Return the packet's edns udp size. :return: (uint16_t) The udp size. """ return _ldns.ldns_pkt_edns_udp_size(self) #parameters: const ldns_pkt *, #retvals: uint16_t def edns_version(self): """ Return the packet's edns version. :return: (uint8_t) The edns version. """ return _ldns.ldns_pkt_edns_version(self) #parameters: const ldns_pkt *, #retvals: uint8_t def edns_z(self): """ Return the packet's edns z value. :return: (uint16_t) The z value. """ return _ldns.ldns_pkt_edns_z(self) #parameters: const ldns_pkt *, #retvals: uint16_t def empty(self): """ Check if a packet is empty. :return: (bool) True: empty, False: not empty """ return _ldns.ldns_pkt_empty(self) #parameters: ldns_pkt *, #retvals: bool def get_opcode(self): """ Read the packet's code. :return: (ldns_pkt_opcode) the opcode """ return _ldns.ldns_pkt_get_opcode(self) #parameters: const ldns_pkt *, #retvals: ldns_pkt_opcode def get_rcode(self): """ Return the packet's response code. :return: (ldns_pkt_rcode) The response code. """ return _ldns.ldns_pkt_get_rcode(self) #parameters: const ldns_pkt *, #retvals: ldns_pkt_rcode def get_section_clone(self, s): """ Return the selected rr_list's in the packet. :param s: What section(s) to return. :type s: ldns_pkt_section :throws TypeError: When arguments of inappropriate types. :return: (:class:`ldns_rr_list`) RR list with the rr's or None if none were found. """ return _ldns.ldns_pkt_get_section_clone(self, s) #parameters: const ldns_pkt *,ldns_pkt_section, #retvals: ldns_rr_list * def id(self): """ Read the packet id. :return: (uint16_t) The packet id. """ return _ldns.ldns_pkt_id(self) #parameters: const ldns_pkt *, #retvals: uint16_t def nscount(self): """ Return the packet's ns count. :return: (uint16_t) The ns count. """ return _ldns.ldns_pkt_nscount(self) #parameters: const ldns_pkt *, #retvals: uint16_t def push_rr(self, section, rr): """ Push an rr on a packet. :param section: Where to put it. :type section: ldns_pkt_section :param rr: RR to push. :type rr: :class:`ldns_rr` :throws TypeError: When arguments of inappropriate types. :return: (bool) A boolean which is True when the rr was added. """ return _ldns._ldns_pkt_push_rr(self,section,rr) #parameters: ldns_pkt *,ldns_pkt_section,ldns_rr *, #retvals: bool def push_rr_list(self, section, list): """ Push a rr_list on a packet. :param section: Where to put it. :type section: ldns_pkt_section :param list: The rr_list to push. :type list: :class:`ldns_rr_list` :throws TypeError: When arguments of inappropriate types. :return: (bool) A boolean which is True when the rr was added. """ return _ldns._ldns_pkt_push_rr_list(self,section,list) #parameters: ldns_pkt *,ldns_pkt_section,ldns_rr_list *, #retvals: bool def qdcount(self): """ Return the packet's qd count. :return: (uint16_t) The qd count. """ return _ldns.ldns_pkt_qdcount(self) #parameters: const ldns_pkt *, #retvals: uint16_t def qr(self): """ Read the packet's qr bit. :return: (bool) value of the bit """ return _ldns.ldns_pkt_qr(self) #parameters: const ldns_pkt *, #retvals: bool def querytime(self): """ Return the packet's query time. :return: (uint32_t) The query time. """ return _ldns.ldns_pkt_querytime(self) #parameters: const ldns_pkt *, #retvals: uint32_t def question(self): """ Return the packet's question section. :return: (:class:`ldns_rr_list`) The question section. """ return _ldns._ldns_pkt_question(self) #parameters: const ldns_pkt *, #retvals: ldns_rr_list * def ra(self): """ Read the packet's ra bit. :return: (bool) Value of the bit. """ return _ldns.ldns_pkt_ra(self) #parameters: const ldns_pkt *, #retvals: bool def rd(self): """ Read the packet's rd bit. :return: (bool) Value of the bit. """ return _ldns.ldns_pkt_rd(self) #parameters: const ldns_pkt *, #retvals: bool def reply_type(self): """ Looks inside the packet to determine what kind of packet it is, AUTH, NXDOMAIN, REFERRAL, etc. :return: (ldns_pkt_type) The type of packet. """ return _ldns.ldns_pkt_reply_type(self) #parameters: ldns_pkt *, #retvals: ldns_pkt_type def rr(self, sec, rr): """ Check to see if an rr exist in the packet. :param sec: In which section to look. :type sec: ldns_pkt_section :param rr: The rr to look for. :type rr: :class:`ldns_rr` :throws TypeError: When arguments of inappropriate types. :return: (bool) Return True is exists. """ return _ldns.ldns_pkt_rr(self, sec, rr) #parameters: ldns_pkt *,ldns_pkt_section,ldns_rr *, #retvals: bool def rr_list_by_name(self, r, s): """ Return all the rr with a specific name from a packet. :param r: The name. :type r: :class:`ldns_rdf` :param s: The packet's section. :type s: ldns_pkt_section :throws TypeError: When arguments of inappropriate types. :return: (:class:`ldns_rr_list`) A list with the rr's or None if none were found. """ return _ldns.ldns_pkt_rr_list_by_name(self,r,s) #parameters: ldns_pkt *,ldns_rdf *,ldns_pkt_section, #retvals: ldns_rr_list * def rr_list_by_name_and_type(self, ownername, atype, sec): """ Return all the rr with a specific type and type from a packet. :param ownername: The name. :type ownername: :class:`ldns_rdf` :param atype: The type. :type atype: ldns_rr_type :param sec: The packet's section. :type sec: ldns_pkt_section :throws TypeError: When arguments of inappropriate types. :return: (:class:`ldns_rr_list`) A list with the rr's or None if none were found. """ return _ldns.ldns_pkt_rr_list_by_name_and_type(self, ownername, atype, sec) #parameters: const ldns_pkt *,const ldns_rdf *,ldns_rr_type,ldns_pkt_section, #retvals: ldns_rr_list * def rr_list_by_type(self, t, s): """ Return all the rr with a specific type from a packet. :param t: The type. :type t: ldns_rr_type :param s: The packet's section. :type s: ldns_pkt_section :throws TypeError: When arguments of inappropriate types. :return: (:class:`ldns_rr_list`) A list with the rr's or None if none were found. """ return _ldns.ldns_pkt_rr_list_by_type(self, t, s) #parameters: const ldns_pkt *,ldns_rr_type,ldns_pkt_section, #retvals: ldns_rr_list * def safe_push_rr(self, sec, rr): """ Push an rr on a packet, provided the RR is not there. :param sec: Where to put it. :type sec: ldns_pkt_section :param rr: RR to push. :type rr: :class:`ldns_rr` :throws TypeError: When arguments of inappropriate types. :return: (bool) A boolean which is True when the rr was added. """ return _ldns._ldns_pkt_safe_push_rr(self,sec,rr) #parameters: ldns_pkt *,ldns_pkt_section,ldns_rr *, #retvals: bool def safe_push_rr_list(self, sec, list): """ Push an rr_list to a packet, provided the RRs are not already there. :param sec: Where to put it. :type sec: ldns_pkt_section :param list: The rr_list to push. :type list: :class:`ldns_rr_list` :throws TypeError: When arguments of inappropriate types. :return: (bool) A boolean which is True when the list was added. """ return _ldns._ldns_pkt_safe_push_rr_list(self, sec, list) #parameters: ldns_pkt *,ldns_pkt_section,ldns_rr_list *, #retvals: bool def set_aa(self, b): """ Set the packet's aa bit. :param b: The value to set. :type b: bool """ _ldns.ldns_pkt_set_aa(self, b) #parameters: ldns_pkt *,bool, #retvals: def set_ad(self, b): """ Set the packet's ad bit. :param b: The value to set. :type b: bool """ _ldns.ldns_pkt_set_ad(self, b) #parameters: ldns_pkt *,bool, #retvals: def set_additional(self, rr): """ Directly set the additional section. :param rr: The rr list to set. :type rr: :class:`ldns_rr_list` :throws TypeError: When arguments of inappropriate types. """ _ldns._ldns_pkt_set_additional(self, rr) #parameters: ldns_pkt *,ldns_rr_list *, #retvals: def set_ancount(self, c): """ Set the packet's an count. :param c: The count. :type c: int :throws TypeError: When arguments of inappropriate types. """ _ldns.ldns_pkt_set_ancount(self, c) #parameters: ldns_pkt *,uint16_t, #retvals: def set_answer(self, rr): """ Directly set the answer section. :param rr: The rr list to set. :type rr: :class:`ldns_rr_list` :throws TypeError: When arguments of inappropriate types. """ _ldns._ldns_pkt_set_answer(self, rr) #parameters: ldns_pkt *,ldns_rr_list *, #retvals: def set_answerfrom(self, r): """ Set the packet's answering server. :param r: The address. :type r: :class:`ldns_rdf` :throws TypeError: When arguments of inappropriate types. """ _ldns._ldns_pkt_set_answerfrom(self, r) #parameters: ldns_pkt *,ldns_rdf *, #retvals: def set_arcount(self, c): """ Set the packet's arcount. :param c: The count. :type c: int :throws TypeError: When arguments of inappropriate types. """ _ldns.ldns_pkt_set_arcount(self,c) #parameters: ldns_pkt *,uint16_t, #retvals: def set_authority(self, rr): """ Directly set the authority section. :param rr: The rr list to set. :type rr: :class:`ldns_rr_list` :throws TypeError: When arguments of inappropriate types. """ _ldns._ldns_pkt_set_authority(self, rr) #parameters: ldns_pkt *,ldns_rr_list *, #retvals: def set_cd(self, b): """ Set the packet's cd bit. :param b: The value to set. :type b: bool """ _ldns.ldns_pkt_set_cd(self, b) #parameters: ldns_pkt *,bool, #retvals: def set_edns_data(self, data): """ Set the packet's edns data. :param data: The data. :type data: :class:`ldns_rdf` :throws TypeError: When arguments of inappropriate types. """ _ldns._ldns_pkt_set_edns_data(self, data) #parameters: ldns_pkt *,ldns_rdf *, #retvals: def set_edns_do(self, value): """ Set the packet's edns do bit. :param value: The bit's new value. :type value: bool """ _ldns.ldns_pkt_set_edns_do(self, value) #parameters: ldns_pkt *,bool, #retvals: def set_edns_extended_rcode(self, c): """ Set the packet's edns extended rcode. :param c: The code. :type c: uint8_t :throws TypeError: When arguments of inappropriate types. """ _ldns.ldns_pkt_set_edns_extended_rcode(self, c) #parameters: ldns_pkt *,uint8_t, #retvals: def set_edns_udp_size(self, s): """ Set the packet's edns udp size. :param s: The size. :type s: uint16_t :throws TypeError: When arguments of inappropriate types. """ _ldns.ldns_pkt_set_edns_udp_size(self, s) #parameters: ldns_pkt *,uint16_t, #retvals: def set_edns_version(self, v): """ Set the packet's edns version. :param v: The version. :type v: uint8_t :throws TypeError: When arguments of inappropriate types. """ _ldns.ldns_pkt_set_edns_version(self, v) #parameters: ldns_pkt *,uint8_t, #retvals: def set_edns_z(self, z): """ Set the packet's edns z value. :param z: The value. :type z: uint16_t :throws TypeError: When arguments of inappropriate types. """ _ldns.ldns_pkt_set_edns_z(self, z) #parameters: ldns_pkt *,uint16_t, #retvals: def set_flags(self, flags): """ Sets the flags in a packet. :param flags: ORed values: LDNS_QR| LDNS_AR for instance. :type flags: int :throws TypeError: When arguments of inappropriate types. :return: (bool) True on success, False otherwise. """ return _ldns.ldns_pkt_set_flags(self, flags) #parameters: ldns_pkt *,uint16_t, #retvals: bool def set_id(self, id): """ Set the packet's id. :param id: The id to set. :type id: uint16_t :throws TypeError: When arguments of inappropriate types. """ _ldns.ldns_pkt_set_id(self, id) #parameters: ldns_pkt *,uint16_t, #retvals: def set_nscount(self, c): """ Set the packet's ns count. :param c: The count. :type c: int :throws TypeError: When arguments of inappropriate types. """ _ldns.ldns_pkt_set_nscount(self, c) #parameters: ldns_pkt *,uint16_t, #retvals: def set_opcode(self, c): """ Set the packet's opcode. :param c: The opcode. :type c: ldns_pkt_opcode :throws TypeError: When arguments of inappropriate types. """ _ldns.ldns_pkt_set_opcode(self, c) #parameters: ldns_pkt *,ldns_pkt_opcode, #retvals: def set_qdcount(self, c): """ Set the packet's qd count. :param c: The count. :type c: int :throws TypeError: When arguments of inappropriate types. """ _ldns.ldns_pkt_set_qdcount(self, c) #parameters: ldns_pkt *,uint16_t, #retvals: def set_qr(self, b): """ Set the packet's qr bit. :param b: The value to set. :type b: bool """ _ldns.ldns_pkt_set_qr(self, b) #parameters: ldns_pkt *,bool, #retvals: def set_querytime(self, t): """ Set the packet's query time. :param t: The query time in msec. :type t: uint32_t :throws TypeError: When arguments of inappropriate types. """ _ldns.ldns_pkt_set_querytime(self, t) #parameters: ldns_pkt *,uint32_t, #retvals: def set_question(self, rr): """ Directly set the question section. :param rr: The rr list to set. :type rr: :class:`ldns_rr_list` :throws TypeError: When arguments of inappropriate types. """ _ldns._ldns_pkt_set_question(self, rr) #parameters: ldns_pkt *,ldns_rr_list *, #retvals: def set_ra(self, b): """ Set the packet's ra bit. :param b: The value to set. :type b: bool """ _ldns.ldns_pkt_set_ra(self, b) #parameters: ldns_pkt *,bool, #retvals: def set_random_id(self): """ Set the packet's id to a random value. """ _ldns.ldns_pkt_set_random_id(self) #parameters: ldns_pkt *, #retvals: def set_rcode(self, c): """ Set the packet's respons code. :param c: The rcode. :type c: uint8_t :throws TypeError: When arguments of inappropriate types. """ _ldns.ldns_pkt_set_rcode(self, c) #parameters: ldns_pkt *,uint8_t, #retvals: def set_rd(self, b): """ Set the packet's rd bit. :param b: The value to set. :type b: bool """ _ldns.ldns_pkt_set_rd(self, b) #parameters: ldns_pkt *,bool, #retvals: def set_section_count(self, s, x): """ Set a packet's section count to x. :param s: The section. :type s: ldns_pkt_section :param x: The section count. :type x: uint16_t :throws TypeError: When arguments of inappropriate types. """ _ldns.ldns_pkt_set_section_count(self, s, x) #parameters: ldns_pkt *,ldns_pkt_section,uint16_t, #retvals: def set_size(self, s): """ Set the packet's size. :param s: The size. :type s: int :throws TypeError: When arguments of inappropriate types. """ _ldns.ldns_pkt_set_size(self,s) #parameters: ldns_pkt *,size_t, #retvals: def set_tc(self, b): """ Set the packet's tc bit. :param b: The value to set. :type b: bool """ _ldns.ldns_pkt_set_tc(self, b) #parameters: ldns_pkt *,bool, #retvals: def set_timestamp(self, timeval): """ Set the packet's time stamp. :param timestamp: The time stamp. :type timestamp: struct timeval :throws TypeError: When arguments of inappropriate types. """ _ldns.ldns_pkt_set_timestamp(self, timeval) #parameters: ldns_pkt *,struct timeval, #retvals: def set_tsig(self, t): """ Set the packet's tsig rr. :param t: The tsig rr. :type t: :class:`ldns_rr` :throws TypeError: When arguments of inappropriate types. """ _ldns._ldns_pkt_set_tsig(self, t) #parameters: ldns_pkt *,ldns_rr *, #retvals: def size(self): """ Return the packet's size in bytes. :return: (size_t) The size. """ return _ldns.ldns_pkt_size(self) #parameters: const ldns_pkt *, #retvals: size_t def tc(self): """ Read the packet's tc bit. :return: (bool) Value of the bit. """ return _ldns.ldns_pkt_tc(self) #parameters: const ldns_pkt *, #retvals: bool def timestamp(self): """ Return the packet's time stamp. :return: (struct timeval) The time stamp. """ return _ldns.ldns_pkt_timestamp(self) #parameters: const ldns_pkt *, #retvals: struct timeval def tsig(self): """ Return the packet's tsig pseudo rr's. :return: (:class:`ldns_rr`) The tsig rr. """ return _ldns._ldns_pkt_tsig(self) #parameters: const ldns_pkt *, #retvals: ldns_rr * # # _LDNS_PKT_METHODS# # # # LDNS update methods # # # LDNS_METHODS_ # def update_ad(self): """ Get the ad count. :return: (uint16_t) The ad count. """ return _ldns.ldns_update_ad(self) #parameters: ldns_pkt * #retvals: uint16_t def update_pkt_tsig_add(self, r): """ Add tsig credentials to a packet from a resolver. :param r: Resolver to copy from. :type r: :class:`ldns_resolver` :throws TypeError: When arguments of inappropriate types. :return: (ldns_status) Status whether successful or not. """ return _ldns.ldns_update_pkt_tsig_add(self, r) #parameters: ldns_pkt *,ldns_resolver *, #retvals: ldns_status def update_prcount(self): """ Get the pr count. :return: (uint16_t) The pr count. """ return _ldns.ldns_update_prcount(self) #parameters: const ldns_pkt *, #retvals: uint16_t def update_set_adcount(self, c): """ Set the ad count. :param c: The ad count to set. :type c: uint16_t :throws TypeError: When arguments of inappropriate types. """ _ldns.ldns_update_set_adcount(self, c) #parameters: ldns_pkt *,uint16_t, #retvals: def update_set_prcount(self, c): """ Set the pr count. :param c: The pr count to set. :type c: uint16_t :throws TypeError: When arguments of inappropriate types. """ _ldns.ldns_update_set_prcount(self, c) #parameters: ldns_pkt *,uint16_t, #retvals: def update_set_upcount(self, c): """ Set the up count. :param c: The up count to set. :type c: uint16_t :throws TypeError: When arguments of inappropriate types. """ _ldns.ldns_update_set_upcount(self,c) #parameters: ldns_pkt *,uint16_t, #retvals: def update_set_zo(self, c): """ Set the zo count. :param c: The zo count to set. :type c: uint16_t :throws TypeError: When arguments of inappropriate types. """ _ldns.ldns_update_set_zo(self, c) #parameters: ldns_pkt *,uint16_t, #retvals: def update_upcount(self): """ Get the up count. :return: (uint16_t) The up count. """ return _ldns.ldns_update_upcount(self) #parameters: const ldns_pkt *, #retvals: uint16_t def update_zocount(self): """ Get the zo count. :return: (uint16_t) The zo count. """ return _ldns.ldns_update_zocount(self) #parameters: const ldns_pkt *, #retvals: uint16_t # # _LDNS_METHODS # %} } ldns-1.6.17/contrib/python/docs/0000775000175100017510000000000012264060151016024 5ustar willemwillemldns-1.6.17/contrib/python/docs/source/0000775000175100017510000000000012264060151017324 5ustar willemwillemldns-1.6.17/contrib/python/docs/source/install.rst0000664000175100017510000000422612264060151021530 0ustar willemwillemInstallation =================================== **Prerequisites** SWIG 1.3 and GNU make are required to build modules for Python 2.4 and higher (but lower than 3). In order to build modules for Python 3.2 or higher, SWIG in version 2.0.4 or higher is required. Note that Python 3.0 and 3.1 are not supported. In order to build this documentation the Sphinx Python documentation generator is required. **Download** The lates source codes can be downloaded from `here`_. .. _here: http://nlnetlabs.nl/projects/ldns/ **Compiling** After downloading the source code archive (this example uses ldns-1.6.13.tar.gz), pyLDNS can be enabled and compiled by typing:: > tar -xzf ldns-1.6.13.tar.gz > cd ldns-1.6.13 > ./configure --with-pyldns > make You need GNU make to compile pyLDNS; SWIG and Python development libraries to compile the extension module. **Selecting Target Python Interpreter** By default, the pyLDNS module builds for the default Python interpreter (i.e., the Python interpreter which can be accessed by just typing ``python`` in the command line). If you desire to build the pyLDNS module for a different Python version then you must specify the desired Python version by setting the ``PYTHON_VERSION`` variable during the configure phase:: > PYTHON_VERSION=3.2 ./configure --with-pyldns > make By default the pyLDNS compiles from sources for a single Python interpreter. Remember to execute scripts requiring pyLDNS in those Python interpreters which have pyLDNS installed. **Testing** If the compilation is successful, you can test the python LDNS extension module by executing the commands:: > cd contrib/python > make testenv > ./ldns-mx.py Again, remember to use the Python interpreter version which the pyLDNS module has been compiled with. The commands will start a new shell, in which several symbolic links will be set-up. When you exit the shell, then symbolic links will be deleted. In ``contrib/python/examples`` several simple Python scripts utilising pyLDNS can be found. These scripts demonstrate the capabilities of the LDNS library. **Installation** To install the libraries and it's extensions type:: > cd ldns-1.6.13 > make install ldns-1.6.17/contrib/python/docs/source/conf.py0000664000175100017510000001322412264060151020625 0ustar willemwillem# -*- coding: utf-8 -*- # # Unbound documentation build configuration file, created by # sphinx-quickstart on Fri Jan 2 19:14:13 2009. # # This file is execfile()d with the current directory set to its containing dir. # # The contents of this file are pickled, so don't put values in the namespace # that aren't pickleable (module imports are okay, they're removed automatically). # # All configuration values have a default value; values that are commented out # serve to show the default value. import sys, os # If your extensions are in another directory, add it here. If the directory # is relative to the documentation root, use os.path.abspath to make it # absolute, like shown here. sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__),'../../'))) #print sys.path # General configuration # --------------------- # Add any Sphinx extension module names here, as strings. They can be extensions # coming with Sphinx (named 'sphinx.ext.*') or your custom ones. extensions = ['sphinx.ext.autodoc', 'sphinx.ext.doctest'] # Add any paths that contain templates here, relative to this directory. templates_path = ['_templates'] # The suffix of source filenames. source_suffix = '.rst' # The master toctree document. master_doc = 'index' # General substitutions. project = 'pyLDNS' copyright = '2009-2013, Karel Slany, Zdenek Vasicek' # The default replacements for |version| and |release|, also used in various # other places throughout the built documents. # # The short X.Y version. version = '1.6' # The full version, including alpha/beta/rc tags. release = '1.6.17' # There are two options for replacing |today|: either, you set today to some # non-false value, then it is used: #today = '' # Else, today_fmt is used as the format for a strftime call. today_fmt = '%B %d, %Y' # List of documents that shouldn't be included in the build. #unused_docs = [] # List of directories, relative to source directories, that shouldn't be searched # for source files. #exclude_dirs = [] # The reST default role (used for this markup: `text`) to use for all documents. #default_role = None # If true, '()' will be appended to :func: etc. cross-reference text. #add_function_parentheses = True # If true, the current module name will be prepended to all description # unit titles (such as .. function::). #add_module_names = True # If true, sectionauthor and moduleauthor directives will be shown in the # output. They are ignored by default. #show_authors = False # The name of the Pygments (syntax highlighting) style to use. pygments_style = 'sphinx' # Options for HTML output # ----------------------- # The style sheet to use for HTML and HTML Help pages. A file of that name # must exist either in Sphinx' static/ path, or in one of the custom paths # given in html_static_path. html_style = 'default.css' # The name for this set of Sphinx documents. If None, it defaults to # " v documentation". #html_title = None # A shorter title for the navigation bar. Default is the same as html_title. #html_short_title = None # The name of an image file (within the static path) to place at the top of # the sidebar. #html_logo = None # The name of an image file (within the static path) to use as favicon of the # docs. This file should be a Windows icon file (.ico) being 16x16 or 32x32 # pixels large. #html_favicon = None # Add any paths that contain custom static files (such as style sheets) here, # relative to this directory. They are copied after the builtin static files, # so a file named "default.css" will overwrite the builtin "default.css". html_static_path = ['_static'] # If not '', a 'Last updated on:' timestamp is inserted at every page bottom, # using the given strftime format. html_last_updated_fmt = '%b %d, %Y' # If true, SmartyPants will be used to convert quotes and dashes to # typographically correct entities. #html_use_smartypants = True # Custom sidebar templates, maps document names to template names. #html_sidebars = {} # Additional templates that should be rendered to pages, maps page names to # template names. #html_additional_pages = {} # If false, no module index is generated. html_use_modindex = False # If false, no index is generated. #html_use_index = True # If true, the index is split into individual pages for each letter. html_split_index = False # If true, the reST sources are included in the HTML build as _sources/. html_copy_source = False # If true, an OpenSearch description file will be output, and all pages will # contain a tag referring to it. The value of this option must be the # base URL from which the finished HTML is served. #html_use_opensearch = '' # If nonempty, this is the file name suffix for HTML files (e.g. ".xhtml"). #html_file_suffix = '' # Output file base name for HTML help builder. htmlhelp_basename = 'ldnsdoc' # Options for LaTeX output # ------------------------ # The paper size ('letter' or 'a4'). #latex_paper_size = 'letter' # The font size ('10pt', '11pt' or '12pt'). #latex_font_size = '10pt' # Grouping the document tree into LaTeX files. List of tuples # (source start file, target name, title, author, document class [howto/manual]). latex_documents = [ ('index', 'ldns-doc.tex', 'LDNS Documentation', 'Karel Slany, Zdenek Vasicek', 'manual'), ] # The name of an image file (relative to this directory) to place at the top of # the title page. #latex_logo = None # For "manual" documents, if this is true, then toplevel headings are parts, # not chapters. #latex_use_parts = False # Additional stuff for the LaTeX preamble. #latex_preamble = '' # Documents to append as an appendix to all manuals. #latex_appendices = [] # If false, no module index is generated. #latex_use_modindex = True ldns-1.6.17/contrib/python/docs/source/examples/0000775000175100017510000000000012264060151021142 5ustar willemwillemldns-1.6.17/contrib/python/docs/source/examples/example1.rst0000664000175100017510000000406412264060151023414 0ustar willemwillemResolving the MX records ============================== This basic example shows how to create a resolver which asks for MX records which contain the information about mail servers. :: #!/usr/bin/python # # MX is a small program that prints out the mx records for a particular domain # import ldns resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") dname = ldns.ldns_dname("nic.cz") pkt = resolver.query(dname, ldns.LDNS_RR_TYPE_MX, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD) if (pkt): mx = pkt.rr_list_by_type(ldns.LDNS_RR_TYPE_MX, ldns.LDNS_SECTION_ANSWER) if (mx): mx.sort() print mx Resolving step by step ------------------------ First of all we import :mod:`ldns` extension module which make LDNS functions and classes accessible:: import ldns If importing fails, it means that Python cannot find the module or ldns library. Then we create the resolver by :meth:`ldns.ldns_resolver.new_frm_file` constructor :: resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") and domain name variable dname:: dname = ldns.ldns_dname("nic.cz") To create a resolver you may also use:: resolver = ldns.ldns_resolver.new_frm_file(None) which behaves in the same manner as the command above. In the third step we tell the resolver to query for our domain, type MX, of class IN:: pkt = resolver.query(dname, ldns.LDNS_RR_TYPE_MX, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD) The function should return a packet if everything goes well and this packet will contain resource records we asked for. Note that there exists a simplier way. Instead of using a dname variable, we can use a string which will be automatically converted. :: pkt = resolver.query("fit.vutbr.cz", ldns.LDNS_RR_TYPE_MX, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD) Now, we test whether the resolver returns a packet and then get all RRs of type MX from the answer packet and store them in list mx:: if (pkt): mx = pkt.rr_list_by_type(ldns.LDNS_RR_TYPE_MX, ldns.LDNS_SECTION_ANSWER) If this list is not empty, we sort and print the content to stdout:: if (mx): mx.sort() print mx ldns-1.6.17/contrib/python/docs/source/examples/example2.py0000775000175100017510000000215712264060151023241 0ustar willemwillem#!/usr/bin/python # -*- coding: utf-8 -*- import ldns import sys debug = True # Check args argc = len(sys.argv) name = "www.nic.cz" if argc < 2: print("Usage:", sys.argv[0], "domain [resolver_addr]") sys.exit(1) else: name = sys.argv[1] # Create resolver resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") resolver.set_dnssec(True) # Custom resolver if argc > 2: # Clear previous nameservers ns = resolver.pop_nameserver() while ns != None: ns = resolver.pop_nameserver() ip = ldns.ldns_rdf.new_frm_str(sys.argv[2], ldns.LDNS_RDF_TYPE_A) resolver.push_nameserver(ip) # Resolve DNS name pkt = resolver.query(name, ldns.LDNS_RR_TYPE_A, ldns.LDNS_RR_CLASS_IN) if pkt and pkt.answer(): # Debug if debug: print("NS returned:", pkt.get_rcode(), "(AA: %d AD: %d)" % ( pkt.ad(), pkt.ad() )) # SERVFAIL indicated bogus name if pkt.get_rcode() is ldns.LDNS_RCODE_SERVFAIL: print(name, "is bogus") # Check AD (Authenticated) bit if pkt.get_rcode() is ldns.LDNS_RCODE_NOERROR: if pkt.ad(): print(name, "is secure") else: print(name, "is insecure") ldns-1.6.17/contrib/python/docs/source/examples/example8.rst0000664000175100017510000000153712264060151023425 0ustar willemwillemSigning of a zone file =============================== This example shows how to sign the content of the given zone file .. literalinclude:: ../../../examples/ldns-signzone.py :language: python In order to be able sign a zone file, you have to generate a key-pair using ``ldns-keygen.py``. Don't forget to modify tag number. Signing consists of three steps 1. In the first step, the content of a zone file is readed and parsed. This can be done using :class:`ldns.ldns_zone` class. 2. In the second step, the private and public key is readed and public key is inserted into zone (as DNSKEY). 3. In the last step, the DNSSEC zone instace is created and all the RRs from zone file are copied here. Then, all the records are signed using :meth:`ldns.ldns_zone.sign` method. If the signing was successfull, the content of DNSSEC zone is written to a file. ldns-1.6.17/contrib/python/docs/source/examples/example3.rst0000664000175100017510000000027612264060151023417 0ustar willemwillemHigh-level functions =========================== This basic example shows how to get name by addr and vice versa. .. literalinclude:: ../../../examples/ldns-higher.py :language: python ldns-1.6.17/contrib/python/docs/source/examples/example7.rst0000664000175100017510000000037212264060151023420 0ustar willemwillemGenerate public/private key pair ======================================= This example shows how generate keys for DNSSEC (i.e. for signing a zone file according DNSSECbis). .. literalinclude:: ../../../examples/ldns-keygen.py :language: python ldns-1.6.17/contrib/python/docs/source/examples/example6.rst0000664000175100017510000000037512264060151023422 0ustar willemwillemRead zone file =============================== This example shows how to read the content of a zone file .. literalinclude:: ../../../examples/ldns-zone.py :language: python Zone file ``zone.txt``: .. literalinclude:: ../../../examples/zone.txt ldns-1.6.17/contrib/python/docs/source/examples/example4.rst0000664000175100017510000000035712264060151023420 0ustar willemwillemAXFR client with IDN support =============================== This example shows how to get AXFR working and how to get involved Internationalized Domain Names (IDN) .. literalinclude:: ../../../examples/ldns-axfr.py :language: python ldns-1.6.17/contrib/python/docs/source/examples/example5.rst0000664000175100017510000000054412264060151023417 0ustar willemwillemExamine the results =============================== This example shows how to go through the obtained results .. literalinclude:: ../../../examples/ldns-mx2.py :language: python This snippet of code prints:: nic.cz. 1761 IN MX 20 mx.cznic.org. nic.cz. 1761 IN MX 10 mail.nic.cz. nic.cz. 1761 IN MX 15 mail4.nic.cz. ldns-1.6.17/contrib/python/docs/source/examples/example2.rst0000664000175100017510000000511212264060151023410 0ustar willemwillem.. _ex_dnssec: Querying DNS-SEC validators =========================== This basic example shows how to query validating resolver and evaluate answer. Resolving step by step ------------------------ For DNS queries, we need to initialize ldns resolver (covered in previous example). :: # Create resolver resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") resolver.set_dnssec(True) # Custom resolver if argc > 2: # Clear previous nameservers ns = resolver.pop_nameserver() while ns != None: ns = resolver.pop_nameserver() ip = ldns.ldns_rdf.new_frm_str(sys.argv[2], ldns.LDNS_RDF_TYPE_A) resolver.push_nameserver(ip) Note the second line :meth:`resolver.set_dnssec`, which enables DNSSEC OK bit in queries in order to get meaningful results. As we have resolver initialized, we can start querying for domain names : :: # Resolve DNS name pkt = resolver.query(name, ldns.LDNS_RR_TYPE_A, ldns.LDNS_RR_CLASS_IN) if pkt and pkt.answer(): Now we evaluate result, where two flags are crucial : * Return code * AD flag (authenticated) When return code is `SERVFAIL`, it means that validating resolver marked requested name as **bogus** (or bad configuration). **AD** flag is set if domain name is authenticated **(secure)** or false if it's insecure. Complete source code -------------------- .. literalinclude:: ../../../examples/ldns-dnssec.py :language: python Testing ------- In order to get meaningful results, you have to enter IP address of validating resolver or setup your own (see howto). Execute `./example2.py` with options `domain name` and `resolver IP`, example: :: user@localhost# ./example2.py www.dnssec.cz 127.0.0.1 # Secure (Configured Unbound running on localhost) user@localhost# ./example2.py www.rhybar.cz 127.0.0.1 # Bogus Howto setup Unbound as validating resolver ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Install Unbound according to instructions. Modify following options in `unbound.conf` (located in `/etc` or `/usr/local/etc`)/ Uncomment `module-config` and set `validator` before iterator. :: module-config: "validator iterator" Download DLV keys and update path in `unbound.conf`:: # DLV keys # Download from http://ftp.isc.org/www/dlv/dlv.isc.org.key dlv-anchor-file: "/usr/local/etc/unbound/dlv.isc.org.key" Update trusted keys (`.cz` for example):: # Trusted keys # For current key, see www.dnssec.cz trusted-keys-file: "/usr/local/etc/unbound/trusted.key" Now you should have well configured Unbound, so run it:: user@localhost# unbound -dv ldns-1.6.17/contrib/python/docs/source/examples/index.rst0000664000175100017510000000031512264060151023002 0ustar willemwillemTutorials ============================== Here you can find a set of simple applications which utilizes the ldns library in Python environment. `Tutorials` .. toctree:: :maxdepth: 1 :glob: example* ldns-1.6.17/contrib/python/docs/source/modules/0000775000175100017510000000000012264060151020774 5ustar willemwillemldns-1.6.17/contrib/python/docs/source/modules/ldns_key.rst0000664000175100017510000000025212264060151023335 0ustar willemwillemClass ldns_key ================================ .. automodule:: ldns Class ldns_key ------------------------------ .. autoclass:: ldns_key :members: :undoc-members: ldns-1.6.17/contrib/python/docs/source/modules/ldns_rdf.rst0000664000175100017510000000171212264060151023322 0ustar willemwillemClass ldns_rdf ================================ .. automodule:: ldns Class ldns_rdf ------------------------------ .. autoclass:: ldns_rdf :members: :undoc-members: Predefined constants ------------------------------ **RDF TYPE** * LDNS_RDF_TYPE_NONE, * LDNS_RDF_TYPE_DNAME, * LDNS_RDF_TYPE_INT8, * LDNS_RDF_TYPE_INT16, * LDNS_RDF_TYPE_INT32, * LDNS_RDF_TYPE_A, * LDNS_RDF_TYPE_AAAA, * LDNS_RDF_TYPE_STR, * LDNS_RDF_TYPE_APL, * LDNS_RDF_TYPE_B32_EXT, * LDNS_RDF_TYPE_B64, * LDNS_RDF_TYPE_HEX, * LDNS_RDF_TYPE_NSEC, * LDNS_RDF_TYPE_TYPE, * LDNS_RDF_TYPE_CLASS, * LDNS_RDF_TYPE_CERT_ALG, * LDNS_RDF_TYPE_ALG, * LDNS_RDF_TYPE_UNKNOWN, * LDNS_RDF_TYPE_TIME, * LDNS_RDF_TYPE_PERIOD, * LDNS_RDF_TYPE_TSIGTIME, * LDNS_RDF_TYPE_HIP, * LDNS_RDF_TYPE_INT16_DATA, * LDNS_RDF_TYPE_SERVICE, * LDNS_RDF_TYPE_LOC, * LDNS_RDF_TYPE_WKS, * LDNS_RDF_TYPE_NSAP, * LDNS_RDF_TYPE_IPSECKEY, * LDNS_RDF_TYPE_NSEC3_SALT, * LDNS_RDF_TYPE_NSEC3_NEXT_OWNER ldns-1.6.17/contrib/python/docs/source/modules/ldns_buffer.rst0000664000175100017510000000026312264060151024020 0ustar willemwillemClass ldns_buffer ================================ .. automodule:: ldns Class ldns_buffer ------------------------------ .. autoclass:: ldns_buffer :members: :undoc-members: ldns-1.6.17/contrib/python/docs/source/modules/ldns_dnssec.rst0000664000175100017510000000103412264060151024023 0ustar willemwillemClass ldns_dnssec_zone ================================ .. automodule:: ldns Class ldns_dnssec_zone ------------------------------ .. autoclass:: ldns_dnssec_zone :members: :undoc-members: Class ldns_dnssec_name ------------------------------ .. autoclass:: ldns_dnssec_name :members: :undoc-members: Class ldns_dnssec_rrsets ------------------------------ .. autoclass:: ldns_dnssec_rrsets :members: :undoc-members: Class ldns_dnssec_rrs ------------------------------ .. autoclass:: ldns_dnssec_rrs :members: :undoc-members: ldns-1.6.17/contrib/python/docs/source/modules/ldns_zone.rst0000664000175100017510000000025512264060151023523 0ustar willemwillemClass ldns_zone ================================ .. automodule:: ldns Class ldns_zone ------------------------------ .. autoclass:: ldns_zone :members: :undoc-members: ldns-1.6.17/contrib/python/docs/source/modules/ldns_dname.rst0000664000175100017510000000026012264060151023630 0ustar willemwillemClass ldns_dname ================================ .. automodule:: ldns Class ldns_dname ------------------------------ .. autoclass:: ldns_dname :members: :undoc-members: ldns-1.6.17/contrib/python/docs/source/modules/ldns_pkt.rst0000664000175100017510000000025212264060151023343 0ustar willemwillemClass ldns_pkt ================================ .. automodule:: ldns Class ldns_pkt ------------------------------ .. autoclass:: ldns_pkt :members: :undoc-members: ldns-1.6.17/contrib/python/docs/source/modules/ldns_resolver.rst0000664000175100017510000000027312264060151024411 0ustar willemwillemClass ldns_resolver ================================ .. automodule:: ldns Class ldns_resolver ------------------------------ .. autoclass:: ldns_resolver :members: :undoc-members: ldns-1.6.17/contrib/python/docs/source/modules/ldns_rr_list.rst0000664000175100017510000000026612264060151024230 0ustar willemwillemClass ldns_rr_list ================================ .. automodule:: ldns Class ldns_rr_list ------------------------------ .. autoclass:: ldns_rr_list :members: :undoc-members: ldns-1.6.17/contrib/python/docs/source/modules/ldns_rr.rst0000664000175100017510000000043712264060151023175 0ustar willemwillemClass ldns_rr ================================ .. automodule:: ldns Class ldns_rr ------------------------------ .. autoclass:: ldns_rr :members: :undoc-members: Class ldns_rr_descriptor ------------------------------ .. autoclass:: ldns_rr_descriptor :members: :undoc-members: ldns-1.6.17/contrib/python/docs/source/modules/ldns_key_list.rst0000664000175100017510000000027112264060151024371 0ustar willemwillemClass ldns_key_list ================================ .. automodule:: ldns Class ldns_key_list ------------------------------ .. autoclass:: ldns_key_list :members: :undoc-members: ldns-1.6.17/contrib/python/docs/source/modules/ldns_func.rst0000664000175100017510000001553612264060151023513 0ustar willemwillemVarious functions ================================ Here you can find list of functions that are not assigned to the classes. These functions have the same parameters as LDNS functions of the same name. You are encouraged to read the LDNS documentation. **List of functions** * ldns_algorithm2buffer_str * ldns_bget_keyword_data * ldns_bget_token * ldns_bgetc * ldns_bskipcs * ldns_bubblebabble * ldns_buffer2pkt_wire * ldns_buffer2str * ldns_calc_keytag * ldns_calc_keytag_raw * ldns_cert_algorithm2buffer_str * ldns_convert_dsa_rrsig_asn12rdf * ldns_convert_dsa_rrsig_rdf2asn1 * ldns_create_nsec * ldns_create_nsec3 * ldns_dname2buffer_wire * ldns_dname2canonical * ldns_dnssec_build_data_chain * ldns_dnssec_chain_nsec3_list * ldns_dnssec_create_nsec * ldns_dnssec_create_nsec3 * ldns_dnssec_create_nsec_bitmap * ldns_dnssec_data_chain_deep_free * ldns_dnssec_data_chain_free * ldns_dnssec_data_chain_new * ldns_dnssec_data_chain_print * ldns_dnssec_default_add_to_signatures * ldns_dnssec_default_delete_signatures * ldns_dnssec_default_leave_signatures * ldns_dnssec_default_replace_signatures * ldns_dnssec_derive_trust_tree * ldns_dnssec_derive_trust_tree_dnskey_rrset * ldns_dnssec_derive_trust_tree_ds_rrset * ldns_dnssec_derive_trust_tree_no_sig * ldns_dnssec_derive_trust_tree_normal_rrset * ldns_dnssec_get_dnskey_for_rrsig * ldns_dnssec_get_rrsig_for_name_and_type * ldns_dnssec_nsec3_closest_encloser * ldns_dnssec_pkt_get_rrsigs_for_name_and_type * ldns_dnssec_pkt_get_rrsigs_for_type * ldns_dnssec_pkt_has_rrsigs * ldns_dnssec_remove_signatures * ldns_dnssec_trust_tree_add_parent * ldns_dnssec_trust_tree_contains_keys * ldns_dnssec_trust_tree_depth * ldns_dnssec_trust_tree_free * ldns_dnssec_trust_tree_new * ldns_dnssec_trust_tree_print * ldns_dnssec_verify_denial * ldns_dnssec_verify_denial_nsec3 * ldns_fetch_valid_domain_keys * ldns_fget_keyword_data * ldns_fget_keyword_data_l * ldns_fget_token * ldns_fget_token_l * ldns_fskipcs * ldns_fskipcs_l * ldns_get_bit * ldns_get_bit_r * ldns_get_errorstr_by_id * ldns_get_rr_class_by_name * ldns_get_rr_list_addr_by_name * ldns_get_rr_list_hosts_frm_file * ldns_get_rr_list_hosts_frm_fp * ldns_get_rr_list_hosts_frm_fp_l * ldns_get_rr_list_name_by_addr * ldns_get_rr_type_by_name * ldns_getaddrinfo * ldns_hexdigit_to_int * ldns_hexstring_to_data * ldns_init_random * ldns_int_to_hexdigit * ldns_is_rrset * ldns_key2buffer_str * ldns_key2rr * ldns_key2str * ldns_lookup_by_id * ldns_lookup_by_name * ldns_native2rdf_int16 * ldns_native2rdf_int16_data * ldns_native2rdf_int32 * ldns_native2rdf_int8 * ldns_nsec3_add_param_rdfs * ldns_nsec3_algorithm * ldns_nsec3_bitmap * ldns_nsec3_flags * ldns_nsec3_hash_name * ldns_nsec3_hash_name_frm_nsec3 * ldns_nsec3_iterations * ldns_nsec3_next_owner * ldns_nsec3_optout * ldns_nsec3_salt * ldns_nsec3_salt_data * ldns_nsec3_salt_length * ldns_nsec_bitmap_covers_type * ldns_nsec_covers_name * ldns_nsec_get_bitmap * ldns_nsec_type_check * ldns_octet * ldns_pkt2buffer_str * ldns_pkt2buffer_wire * ldns_pkt2str * ldns_pkt2wire * ldns_pktheader2buffer_str * ldns_power * ldns_print_rr_rdf * ldns_rbtree_create * ldns_rbtree_delete * ldns_rbtree_find_less_equal * ldns_rbtree_first * ldns_rbtree_free * ldns_rbtree_init * ldns_rbtree_insert * ldns_rbtree_insert_vref * ldns_rbtree_last * ldns_rbtree_next * ldns_rbtree_previous * ldns_rbtree_search * ldns_rdf2buffer_str * ldns_rdf2buffer_str_a * ldns_rdf2buffer_str_aaaa * ldns_rdf2buffer_str_alg * ldns_rdf2buffer_str_apl * ldns_rdf2buffer_str_b64 * ldns_rdf2buffer_str_cert_alg * ldns_rdf2buffer_str_class * ldns_rdf2buffer_str_dname * ldns_rdf2buffer_str_hex * ldns_rdf2buffer_str_int16 * ldns_rdf2buffer_str_int16_data * ldns_rdf2buffer_str_ipseckey * ldns_rdf2buffer_str_loc * ldns_rdf2buffer_str_nsap * ldns_rdf2buffer_str_nsec * ldns_rdf2buffer_str_period * ldns_rdf2buffer_str_str * ldns_rdf2buffer_str_tsig * ldns_rdf2buffer_str_tsigtime * ldns_rdf2buffer_str_type * ldns_rdf2buffer_str_unknown * ldns_rdf2buffer_str_wks * ldns_rdf2buffer_wire * ldns_rdf2buffer_wire_canonical * ldns_rdf2native_int16 * ldns_rdf2native_int32 * ldns_rdf2native_int8 * ldns_rdf2native_sockaddr_storage * ldns_rdf2native_time_t * ldns_rdf2rr_type * ldns_rdf2str * ldns_rdf2wire * ldns_read_anchor_file * ldns_read_uint16 * ldns_read_uint32 * ldns_rr2buffer_str * ldns_rr2buffer_wire * ldns_rr2buffer_wire_canonical * ldns_rr2canonical * ldns_rr2str * ldns_rr2wire * ldns_rrsig2buffer_wire * ldns_send * ldns_send_buffer * ldns_set_bit * ldns_sign_public * ldns_sockaddr_storage2rdf * ldns_str2period * ldns_str2rdf_a * ldns_str2rdf_aaaa * ldns_str2rdf_alg * ldns_str2rdf_apl * ldns_str2rdf_b32_ext * ldns_str2rdf_b64 * ldns_str2rdf_cert_alg * ldns_str2rdf_class * ldns_str2rdf_dname * ldns_str2rdf_hex * ldns_str2rdf_int16 * ldns_str2rdf_int32 * ldns_str2rdf_int8 * ldns_str2rdf_loc * ldns_str2rdf_nsap * ldns_str2rdf_nsec * ldns_str2rdf_nsec3_salt * ldns_str2rdf_period * ldns_str2rdf_service * ldns_str2rdf_str * ldns_str2rdf_time * ldns_str2rdf_tsig * ldns_str2rdf_type * ldns_str2rdf_unknown * ldns_str2rdf_wks * ldns_tcp_bgsend * ldns_tcp_connect * ldns_tcp_read_wire * ldns_tcp_send * ldns_tcp_send_query * ldns_traverse_postorder * ldns_tsig_algorithm * ldns_tsig_keydata * ldns_tsig_keydata_clone * ldns_tsig_keyname * ldns_tsig_keyname_clone * ldns_udp_bgsend * ldns_udp_connect * ldns_udp_read_wire * ldns_udp_send * ldns_udp_send_query * ldns_update_pkt_new * ldns_update_pkt_tsig_add * ldns_update_prcount * ldns_update_set_adcount * ldns_update_set_prcount * ldns_update_set_upcount * ldns_update_soa_mname * ldns_update_soa_zone_mname * ldns_update_upcount * ldns_update_zocount * ldns_validate_domain_dnskey * ldns_validate_domain_ds * ldns_verify * ldns_verify_rrsig * ldns_verify_rrsig_buffers * ldns_verify_rrsig_buffers_raw * ldns_verify_rrsig_dsa * ldns_verify_rrsig_dsa_raw * ldns_verify_rrsig_keylist * ldns_verify_rrsig_rsamd5 * ldns_verify_rrsig_rsamd5_raw * ldns_verify_rrsig_rsasha1 * ldns_verify_rrsig_rsasha1_raw * ldns_verify_rrsig_rsasha256_raw * ldns_verify_rrsig_rsasha512_raw * ldns_verify_trusted * ldns_version * ldns_wire2dname * ldns_wire2pkt * ldns_wire2rdf * ldns_wire2rr * ldns_write_uint16 * ldns_write_uint32 * ldns_write_uint64_as_uint48 * mktime_from_utc * qsort_rr_compare_nsec3 ldns-1.6.17/contrib/python/docs/source/modules/ldns.rst0000664000175100017510000000206112264060151022465 0ustar willemwillemLDNS module documentation ================================ Here you can find the documentation of pyLDNS extension module. This module consists of several classes and a couple of functions. .. toctree:: :maxdepth: 1 :glob: ldns_resolver ldns_pkt ldns_rr ldns_rdf ldns_dname ldns_rr_list ldns_zone ldns_key ldns_key_list ldns_buffer ldns_dnssec ldns_func **Differences against libLDNS** * You don't need to use ldns-compare functions, instances can be compared using standard operators <, >, = :: if (some_rr.owner() == another_rr.rdf(1)): pass * Classes contain static methods that create new instances, the name of these methods starts with the new\_ prefix (e.g. :meth:`ldns.ldns_pkt.new_frm_file`). * Is it possible to print the content of an object using ``print objinst`` (see :meth:`ldns.ldns_resolver.get_addr_by_name`). * Classes contain write_to_buffer method that writes the content into buffer. * All the methods that consume parameter of (const ldns_rdf) type allows to use string instead (see :meth:`ldns.ldns_resolver.query`). ldns-1.6.17/contrib/python/docs/source/index.rst0000664000175100017510000000151412264060151021166 0ustar willemwillemPyLDNS documentation ======================================= PyLDNS provides an `LDNS`_ wrapper (Python extension module) - the thinnest layer over the library possible. Everything you can do from the C API, you can do from Python, but with less effort. The purpose of porting LDNS library to Python is to simplify DNS programming and usage of LDNS, however, still preserve the performance of this library as the speed represents the main benefit of LDNS. The proposed object approach allows the users to be concentrated at the essential part of application only and don't bother with deallocation of objects and so on. .. _LDNS: http://www.nlnetlabs.nl/projects/ldns/ Contents ---------- .. toctree:: :maxdepth: 2 install.rst examples/index.rst modules/ldns Indices and tables ------------------- * :ref:`genindex` * :ref:`search` ldns-1.6.17/contrib/python/docs/Makefile0000664000175100017510000000460512264060151017471 0ustar willemwillem# Makefile for Sphinx documentation # # You can set these variables from the command line. SPHINXOPTS = SPHINXBUILD = sphinx-build PAPER = # Internal variables. PAPEROPT_a4 = -D latex_paper_size=a4 PAPEROPT_letter = -D latex_paper_size=letter ALLSPHINXOPTS = -d build/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) source .PHONY: help clean html web pickle htmlhelp latex changes linkcheck help: @echo "Please use \`make ' where is one of" @echo " html to make standalone HTML files" @echo " pickle to make pickle files (usable by e.g. sphinx-web)" @echo " htmlhelp to make HTML files and a HTML help project" @echo " latex to make LaTeX files, you can set PAPER=a4 or PAPER=letter" @echo " changes to make an overview over all changed/added/deprecated items" @echo " linkcheck to check all external links for integrity" clean: -rm -rf build/* html: mkdir -p build/html build/doctrees LD_LIBRARY_PATH=../../../.libs $(SPHINXBUILD) -b html $(ALLSPHINXOPTS) build/html @echo @echo "Build finished. The HTML pages are in build/html." pickle: mkdir -p build/pickle build/doctrees LD_LIBRARY_PATH=../../../.libs $(SPHINXBUILD) -b pickle $(ALLSPHINXOPTS) build/pickle @echo @echo "Build finished; now you can process the pickle files or run" @echo " sphinx-web build/pickle" @echo "to start the sphinx-web server." web: pickle htmlhelp: mkdir -p build/htmlhelp build/doctrees LD_LIBRARY_PATH=../../../.libs $(SPHINXBUILD) -b htmlhelp $(ALLSPHINXOPTS) build/htmlhelp @echo @echo "Build finished; now you can run HTML Help Workshop with the" \ ".hhp project file in build/htmlhelp." latex: mkdir -p build/latex build/doctrees LD_LIBRARY_PATH=../../../.libs $(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) build/latex @echo @echo "Build finished; the LaTeX files are in build/latex." @echo "Run \`make all-pdf' or \`make all-ps' in that directory to" \ "run these through (pdf)latex." changes: mkdir -p build/changes build/doctrees LD_LIBRARY_PATH=../../../.libs $(SPHINXBUILD) -b changes $(ALLSPHINXOPTS) build/changes @echo @echo "The overview file is in build/changes." linkcheck: mkdir -p build/linkcheck build/doctrees LD_LIBRARY_PATH=../../../.libs $(SPHINXBUILD) -b linkcheck $(ALLSPHINXOPTS) build/linkcheck @echo @echo "Link check complete; look for any errors in the above output " \ "or in build/linkcheck/output.txt." ldns-1.6.17/contrib/python/Changelog0000664000175100017510000001165712264060151016720 0ustar willemwillem1.6.17 2014-01-10 * Added ldns_rdf.data_as_bytearray(). The method returns a bytearray object containing rdf data. * Changed the behaviour of ldns_resolver.trusted_key() in order to prevent memory corrupotion and leaks. * Fixed memory leaks when destroying ldns_resolver. * Removed ldns_pkt.section_count(), ldns_resolver.set_searchlist_count() because it is marked static in the library. * Added ldns_pkt.new(), ldns_resolver.new(). * Marked as returning new object ldns_pkt.get_section_clone(), ldns_resolver.get_addr_by_name(), ldns_resolver.get_name_by_addr(), ldns_resolver.search(). * Added push cloning for ldns_pkt.safe_push_rr(), ldns_pkt.safe_push_rr_list(), ldns_pkt.set_additional(), ldns_pkt.set_answer(), ldns_pkt.set_answerfrom(), ldns_pkt.set_authority(), ldns_pkt.set_edns_data(), ldns_pkt.set_question(), ldns_pkt.set_tsig(), ldns_resolver.set_dnssec_anchors(), ldns_resolver.set_domain(). * Added pull cloning for ldns_pkt.answerfrom(), ldns_pkt.edns_data(), ldns_pkt.tsig(), ldns_resolver.axfr_last_pkt(), ldns_resolver.dnssec_anchors(), ldns_resolver.domain(), ldns_resolver.tsig_algorithm(), ldns_resolver.tsig_keydata(), ldns_resolver.tsig_keyname(). * Method ldns_rdf.reverse() now throws an exception when not applied on dname rdfs. This is to prevent assertion fails in ldns' C code. 1.6.16 2012-11-13 * Fix typo in ldns_struct_pkt.opcode2str 1.6.14 2012-10-23 * Added rich comparison methods for ldns_dname, ldns_rdf, ldns_rr and ldns_rr_list classes. * Added deprecation warnings into ldns_rr.new_frm_fp() and ldns_rr.new_frm_fp_l() and others. * Fixed ldns_rr.set_rdf(), which may cause memory leaks, because it returns new objects (in the scope of Python). Also it leaked memory, when the call was not successful. * Fixed ldns_get_rr_list_hosts_frm_file, marked as newobject. * Fixed ldns_rr_list.cat() to return bool as mentioned in documentation. * Fixed ldns_rr_list_cat_clone, marked as newobject. * Fixed ldns_rr_list.new_frm_file(). Exception argument was invalid. * Fixed ldns_rr_list.push_rr() to return bool as mentioned in documentation. * Fixed ldns_rr_list.push_rr_list() to return bool as mentioned in documentation. * Fixed ldns_rr_list.set_rr(), which caused memory corruption, double free problems and memory leaks. (The wrapper used original function instead of its push cloned variant which was missing.) * Fixed ldns_rr_list.set_rr_count(), added python exception raise in order to avoid assertion failure. * Fixed ldns_rr_list.subtype_by_rdf(), marked as newobject. * Added ldns_rr.to_canonical(), ldns_rr.is_question(), ldns_rr.type_by_name(), ldns_rr.class_by_name(), ldns_rr_list.new(), ldns_rr.set_question(). * Modified ldns_rr_list.owner() and ldns_rr.owner(), now returns ldns_dname. * Fixed assertion failures for several methods when receiving incorrect but syntactically valid arguments (i.e., ldns_rr.a_address(), ldns_rr.dnskey_algorithm(), ldns_rr.dnskey_flags(), ldns_rr.dnskey_key(), ldns_rr.dnskey_protocol(), ldns_rr.mx_exchange(), ldns_rr.mx_preference(), ldns_rr.ns_nsdname(), ldns_rr.owner(), ldns_rr.rdf(), ldns_rr.rrsig_algorithm(), ldns_rr.rrsig_expiration(), ldns_rr.rrsig_inception(), ldns_rr.rrsig_keytag(), ldns_rr.rrsig_labels(), ldns_rr.rrsig_origttl(), ldns_rr.rrsig_sig(), ldns_rr.rrsig_signame(), ldns_rr.rrsig_typecovered(), ldns_rr_list.owner(), ldns_rr_list.rr()) * Fixed ldns_rr.a_address(), which was asserting when called on non A or AAAA type rr. Now returns None when fails. * Added scripts for testing the basic functionality of the ldns_rr, ldns_rr_descriptor and ldns_rr_list class code. * Improved documentation of ldns_rr, ldns_rr_descriptor and ldns_rr_list. * Fixed automatic conversion from Python string to ldns_rdf and ldns_dname. Caused memory corruption when using Python 3. * The Python 3 wrapper code now raises TypeError instead of ValueError when receiving a non FILE * argument when it should be a FILE *. * Fixed wrong handling of _ldns_rr_list_free() and _ldns_rr_list_deep_free() when compiling with LDNS_DEBUG directive. * Fixed malfunctioning ldns.ldns_rdf_new_frm_fp_l(). * Fixed malfunctioning ldns_drf.absolute() and ldns_dname.absolute(). * Marked several functions related to ldns_rdf and ldns_buffer as returning new objects. * Method operating on ldns_dnames and returning dname ldns_rdfs now return ldns_dname instances. * Improved documentation of ldns_buffer, ldns_rdf and ldns_dname classes. * Methods ldns_buffer.available() and ldns_buffer.available_at() now return bool types as described in the documentation. * Added scripts for testing the basic functionality of the ldns_buffer, ldns_rdf, ldns_dname class code. * Added deprecation warnings to ldns_rdf methods operating on dname rdfs. The user is encouraged to converts dname ldns_rdfs to ldns_dnames. * Extended ldns_dname constructor to accept ldns_rdfs containing dnames. ldns-1.6.17/contrib/python/ldns_rdf.i0000664000175100017510000010101712264060151017041 0ustar willemwillem/****************************************************************************** * ldns_rdf.i: LDNS record data * * Copyright (c) 2009, Zdenek Vasicek (vasicek AT fit.vutbr.cz) * Karel Slany (slany AT fit.vutbr.cz) * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * Redistributions of source code must retain the above copyright notice, * this list of conditions and the following disclaimer. * * Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * Neither the name of the organization nor the names of its * contributors may be used to endorse or promote products derived from * this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. *****************************************************************************/ /* ========================================================================= */ /* SWIG setting and definitions. */ /* ========================================================================= */ /* Creates a temporary instance of (ldns_rdf *). */ %typemap(in, numinputs=0, noblock=1) (ldns_rdf **) { ldns_rdf *$1_rdf = NULL; $1 = &$1_rdf; } /* Result generation, appends (ldns_rdf *) after the result. */ %typemap(argout, noblock=1) (ldns_rdf **) { $result = SWIG_Python_AppendOutput($result, SWIG_NewPointerObj(SWIG_as_voidptr($1_rdf), SWIGTYPE_p_ldns_struct_rdf, SWIG_POINTER_OWN | 0)); } /* * Automatic conversion of const (ldns_rdf *) parameter from string. * Argument default value. */ %typemap(arginit, noblock=1) const ldns_rdf * { char *$1_str = NULL; } /* * Automatic conversion of const (ldns_rdf *) parameter from string. * Preparation of arguments. */ %typemap(in, noblock=1) const ldns_rdf * (void* argp, $1_ltype tmp = 0, int res) { if (Python_str_Check($input)) { $1_str = SWIG_Python_str_AsChar($input); if ($1_str == NULL) { %argument_fail(SWIG_TypeError, "char *", $symname, $argnum); } tmp = ldns_dname_new_frm_str($1_str); if (tmp == NULL) { %argument_fail(SWIG_TypeError, "char *", $symname, $argnum); } $1 = ($1_ltype) tmp; } else { res = SWIG_ConvertPtr($input, &argp, SWIGTYPE_p_ldns_struct_rdf, 0 | 0); if (!SWIG_IsOK(res)) { %argument_fail(res, "ldns_rdf const *", $symname, $argnum); } $1 = ($1_ltype) argp; } } /* * Automatic conversion of const (ldns_rdf *) parameter from string. * Freeing of allocated memory (in Python 3 when daling with strings). */ %typemap(freearg, noblock=1) const ldns_rdf * { if ($1_str != NULL) { /* Is not NULL only when a conversion form string occurred. */ SWIG_Python_str_DelForPy3($1_str); /* Is a empty macro for Python < 3. */ } } %nodefaultctor ldns_struct_rdf; /* No default constructor. */ %nodefaultdtor ldns_struct_rdf; /* No default destructor. */ /* * This file must contain all %newobject and %delobject tags also for * ldns_dname. This is because the ldns_dname is a derived class from ldns_rdf. */ %newobject ldns_rdf_new; %newobject ldns_rdf_new_frm_str; %newobject ldns_rdf_new_frm_data; %newobject ldns_rdf_address_reverse; %newobject ldns_rdf_clone; %newobject ldns_rdf2str; %newobject ldns_dname_new; %newobject ldns_dname_new_frm_str; %newobject ldns_dname_new_frm_data; %newobject ldns_dname_cat_clone; %newobject ldns_dname_label; %newobject ldns_dname_left_chop; %newobject ldns_dname_reverse; %delobject ldns_rdf_deep_free; %delobject ldns_rdf_free; /* * Should the ldns_rdf_new() also be marked as deleting its data parameter? */ %delobject ldns_rdf_set_data; /* Because data are directly coupled into rdf. */ %rename(ldns_rdf) ldns_struct_rdf; /* ========================================================================= */ /* Debugging related code. */ /* ========================================================================= */ #ifdef LDNS_DEBUG %rename(__ldns_rdf_deep_free) ldns_rdf_deep_free; %rename(__ldns_rdf_free) ldns_rdf_free; %inline %{ /*! * @brief Prints information about deallocated rdf and deallocates. */ void _ldns_rdf_deep_free (ldns_rdf *r) { printf("******** LDNS_RDF deep free 0x%lX ************\n", (long unsigned int) r); ldns_rdf_deep_free(r); } /*! * @brief Prints information about deallocated rdf and deallocates. */ void _ldns_rdf_free (ldns_rdf* r) { printf("******** LDNS_RDF free 0x%lX ************\n", (long unsigned int) r); ldns_rdf_free(r); } %} #else /* !LDNS_DEBUG */ %rename(_ldns_rdf_deep_free) ldns_rdf_deep_free; %rename(_ldns_rdf_free) ldns_rdf_free; #endif /* LDNS_DEBUG */ /* ========================================================================= */ /* Added C code. */ /* ========================================================================= */ %inline %{ /*! * @brief returns a human readable string containing rdf type. */ const char *ldns_rdf_type2str(const ldns_rdf *rdf) { if (rdf) { switch(ldns_rdf_get_type(rdf)) { case LDNS_RDF_TYPE_NONE: return 0; case LDNS_RDF_TYPE_DNAME: return "DNAME"; case LDNS_RDF_TYPE_INT8: return "INT8"; case LDNS_RDF_TYPE_INT16: return "INT16"; case LDNS_RDF_TYPE_INT32: return "INT32"; case LDNS_RDF_TYPE_A: return "A"; case LDNS_RDF_TYPE_AAAA: return "AAAA"; case LDNS_RDF_TYPE_STR: return "STR"; case LDNS_RDF_TYPE_APL: return "APL"; case LDNS_RDF_TYPE_B32_EXT: return "B32_EXT"; case LDNS_RDF_TYPE_B64: return "B64"; case LDNS_RDF_TYPE_HEX: return "HEX"; case LDNS_RDF_TYPE_NSEC: return "NSEC"; case LDNS_RDF_TYPE_TYPE: return "TYPE"; case LDNS_RDF_TYPE_CLASS: return "CLASS"; case LDNS_RDF_TYPE_CERT_ALG: return "CER_ALG"; case LDNS_RDF_TYPE_ALG: return "ALG"; case LDNS_RDF_TYPE_UNKNOWN: return "UNKNOWN"; case LDNS_RDF_TYPE_TIME: return "TIME"; case LDNS_RDF_TYPE_PERIOD: return "PERIOD"; case LDNS_RDF_TYPE_TSIGTIME: return "TSIGTIME"; case LDNS_RDF_TYPE_HIP: return "HIP"; case LDNS_RDF_TYPE_INT16_DATA: return "INT16_DATA"; case LDNS_RDF_TYPE_SERVICE: return "SERVICE"; case LDNS_RDF_TYPE_LOC: return "LOC"; case LDNS_RDF_TYPE_WKS: return "WKS"; case LDNS_RDF_TYPE_NSAP: return "NSAP"; case LDNS_RDF_TYPE_ATMA: return "ATMA"; case LDNS_RDF_TYPE_IPSECKEY: return "IPSECKEY"; case LDNS_RDF_TYPE_NSEC3_SALT: return "NSEC3_SALT"; case LDNS_RDF_TYPE_NSEC3_NEXT_OWNER: return "NSEC3_NEXT_OWNER"; case LDNS_RDF_TYPE_ILNP64: return "ILNP64"; case LDNS_RDF_TYPE_EUI48: return "EUI48"; case LDNS_RDF_TYPE_EUI64: return "EUI64"; case LDNS_RDF_TYPE_TAG: return "TAG"; case LDNS_RDF_TYPE_LONG_STR: return "LONG_STR"; } } return 0; } %} %inline %{ /*! * @brief Returns the rdf data organised into a list of bytes. */ PyObject * ldns_rdf_data_as_bytearray(const ldns_rdf *rdf) { Py_ssize_t len; uint8_t *data; assert(rdf != NULL); len = ldns_rdf_size(rdf); data = ldns_rdf_data(rdf); return PyByteArray_FromStringAndSize((char *) data, len); } %} /* ========================================================================= */ /* Encapsulating Python code. */ /* ========================================================================= */ %feature("docstring") ldns_struct_rdf "Resource record data field. The data is a network ordered array of bytes, which size is specified by the (16-bit) size field. To correctly parse it, use the type specified in the (16-bit) type field with a value from ldns_rdf_type." %extend ldns_struct_rdf { %pythoncode %{ def __init__(self): """ Cannot be created directly from Python. """ raise Exception("This class can't be created directly. " + "Please use: ldns_rdf_new, ldns_rdf_new_frm_data, " + "ldns_rdf_new_frm_str, ldns_rdf_new_frm_fp, " + "ldns_rdf_new_frm_fp_l") __swig_destroy__ = _ldns._ldns_rdf_deep_free # # LDNS_RDF_CONSTRUCTORS_ # @staticmethod def new_frm_str(string, rr_type, raiseException = True): """ Creates a new rdf from a string of a given type. :param string: string to use :type string: string :param rr_type: The type of the rdf. See predefined `RDF_TYPE_` constants. :type rr_type: integer :param raiseException: If True, an exception occurs in case a RDF object can't be created. :type raiseException: bool :throws TypeError: When parameters of mismatching types. :throws Exception: When raiseException set and rdf couldn't be created. :return: :class:`ldns_rdf` object or None. If the object can't be created and `raiseException` is True, an exception occurs. **Usage** >>> rdf = ldns.ldns_rdf.new_frm_str("74.125.43.99", ldns.LDNS_RDF_TYPE_A) >>> print rdf, rdf.get_type_str() A 74.125.43.99 >>> name = ldns.ldns_resolver.new_frm_file().get_name_by_addr(rdf) >>> if (name): print name 99.43.125.74.in-addr.arpa. 85277 IN PTR bw-in-f99.google.com. """ rr = _ldns.ldns_rdf_new_frm_str(rr_type, string) if (not rr) and raiseException: raise Exception("Can't create query packet, " + "error: %d" % status) return rr # # _LDNS_RDF_CONSTRUCTORS # def __str__(self): """ Converts the rdata field to presentation format. """ return _ldns.ldns_rdf2str(self) def __cmp__(self, other): """ Compares two rdfs on their wire formats. (To order dnames according to rfc4034, use ldns_dname_compare.) :param other: The second one RDF. :type other: :class:`ldns_rdf` :throws TypeError: When `other` of non-:class:`ldns_rdf` type. :return: (int) -1, 0 or 1 if self comes before other, is equal or self comes after other respectively. """ return _ldns.ldns_rdf_compare(self, other) def __lt__(self, other): """ Compares two rdfs on their formats. :param other: The socond one RDF. :type other: :class:`ldns_rdf` :throws TypeError: When `other` of non-:class:`ldns_rdf` type. :return: (bool) True when `self` is less than 'other'. """ return _ldns.ldns_rdf_compare(self, other) == -1 def __le__(self, other): """ Compares two rdfs on their formats. :param other: The socond one RDF. :type other: :class:`ldns_rdf` :throws TypeError: When `other` of non-:class:`ldns_rdf` type. :return: (bool) True when `self` is less than or equal to 'other'. """ return _ldns.ldns_rdf_compare(self, other) != 1 def __eq__(self, other): """ Compares two rdfs on their formats. :param other: The socond one RDF. :type other: :class:`ldns_rdf` :throws TypeError: When `other` of non-:class:`ldns_rdf` type. :return: (bool) True when `self` is equal to 'other'. """ return _ldns.ldns_rdf_compare(self, other) == 0 def __ne__(self, other): """ Compares two rdfs on their formats. :param other: The socond one RDF. :type other: :class:`ldns_rdf` :throws TypeError: When `other` of non-:class:`ldns_rdf` type. :return: (bool) True when `self` is not equal to 'other'. """ return _ldns.ldns_rdf_compare(self, other) != 0 def __gt__(self, other): """ Compares two rdfs on their formats. :param other: The socond one RDF. :type other: :class:`ldns_rdf` :throws TypeError: When `other` of non-:class:`ldns_rdf` type. :return: (bool) True when `self` is greater than 'other'. """ return _ldns.ldns_rdf_compare(self, other) == 1 def __ge__(self, other): """ Compares two rdfs on their formats. :param other: The socond one RDF. :type other: :class:`ldns_rdf` :throws TypeError: When `other` of non-:class:`ldns_rdf` type. :return: (bool) True when `self` is greater than or equal to 'other'. """ return _ldns.ldns_rdf_compare(self, other) != -1 def print_to_file(self, output): """ Prints the data in the rdata field to the given `output` file stream (in presentation format). """ _ldns.ldns_rdf_print(output, self) def get_type_str(self): """ Returns the type of the rdf as a human readable string. :return: String containing rdf type. """ return ldns_rdf_type2str(self) def write_to_buffer(self, buffer): """ Copies the rdata data to the buffer in wire format. :param buffer: Buffer to append the rdf to. :type param: :class:`ldns_buffer` :throws TypeError: When `buffer` of non-:class:`ldns_buffer` type. :return: (ldns_status) ldns_status """ return _ldns.ldns_rdf2buffer_wire(buffer, self) #parameters: ldns_buffer *, const ldns_rdf *, #retvals: ldns_status def write_to_buffer_canonical(self, buffer): """ Copies the rdata data to the buffer in wire format. If the rdata is a dname, the letters will be converted to lower case during the conversion. :param buffer: LDNS buffer. :type buffer: :class:`ldns_buffer` :throws TypeError: When `buffer` of non-:class:`ldns_buffer` type. :return: (ldns_status) ldns_status """ return _ldns.ldns_rdf2buffer_wire_canonical(buffer, self) #parameters: ldns_buffer *, const ldns_rdf *, #retvals: ldns_status # # LDNS_RDF_METHODS_ # def address_reverse(self): """ Reverses an rdf, only actually useful for AAAA and A records. The returned rdf has the type LDNS_RDF_TYPE_DNAME! :return: (:class:`ldns_rdf`) The reversed rdf (a newly created rdf). """ return _ldns.ldns_rdf_address_reverse(self) #parameters: ldns_rdf *, #retvals: ldns_rdf * def clone(self): """ Clones a rdf structure. The data are copied. :return: (:class:`ldns_rdf`) A new rdf structure. """ return _ldns.ldns_rdf_clone(self) #parameters: const ldns_rdf *, #retvals: ldns_rdf * def data(self): """ Returns the data of the rdf. :return: (uint8_t \*) uint8_t* pointer to the rdf's data. """ return _ldns.ldns_rdf_data(self) #parameters: const ldns_rdf *, #retvals: uint8_t * def data_as_bytearray(self): """ Returns the data of the rdf as a bytearray. :return: (bytearray) Bytearray containing the rdf data. """ return _ldns.ldns_rdf_data_as_bytearray(self) #parameters: const ldns_rdf *, #retvals: bytearray def get_type(self): """ Returns the type of the rdf. We need to prepend the prefix get_ here to prevent conflict with the rdf_type TYPE. :return: (ldns_rdf_type) Identifier of the type. """ return _ldns.ldns_rdf_get_type(self) #parameters: const ldns_rdf *, #retvals: ldns_rdf_type def set_data(self, data): """ Sets the data portion of the rdf. The data are not copied, but are assigned to the rdf, `data` are decoupled from the Python engine. :param data: Data to be set. :type data: void \* """ _ldns.ldns_rdf_set_data(self, data) #parameters: ldns_rdf *, void *, #retvals: def set_size(self, size): """ Sets the size of the rdf. :param size: The new size. :type size: integer :throws TypeError: When size of non-integer type. """ _ldns.ldns_rdf_set_size(self,size) #parameters: ldns_rdf *,size_t, #retvals: def set_type(self, atype): """ Sets the type of the rdf. :param atype: rdf type :type atype: integer :throws TypeError: When atype of non-integer type. """ _ldns.ldns_rdf_set_type(self, atype) #parameters: ldns_rdf *, ldns_rdf_type, #retvals: def size(self): """ Returns the size of the rdf. :return: (size_t) uint16_t with the size. """ return _ldns.ldns_rdf_size(self) #parameters: const ldns_rdf *, #retvals: size_t @staticmethod def dname_new_frm_str(string): """ Creates a new dname rdf instance from a given string. This static method is equivalent to using of default :class:`ldns_rdf` constructor. :parameter string: String to use. :type string: string :throws TypeError: When not a string used. :return: :class:`ldns_rdf` or None if error. .. warning:: It is scheduled to be deprecated and removed. Use :class:`ldns_dname` constructor instead. """ warnings.warn("The ldns_rdf.dname_new_frm_str() method is" + " scheduled to be deprecated in future releases." + " Use ldsn_dname constructor instead.", PendingDeprecationWarning, stacklevel=2) return _ldns.ldns_dname_new_frm_str(string) def absolute(self): """ Checks whether the given dname string is absolute (i.e., ends with a '.'). :return: (bool) True or False .. note:: This method was malfunctioning in ldns-1.3.16 and also possibly earlier. .. warning:: It is scheduled to be deprecated and removed. Convert :class:`ldns_rdf` to :class:`ldns_dname` to use the method. """ warnings.warn("The ldns_rdf.absolute() method is scheduled" + " to be deprecated in future releases." + " Convert the ldns_rdf to ldsn_dname and the use its" + " methods.", PendingDeprecationWarning, stacklevel=2) if self.get_type() == _ldns.LDNS_RDF_TYPE_DNAME: string = self.__str__() return _ldns.ldns_dname_str_absolute(string) != 0 else: return False def make_canonical(self): """ Put a dname into canonical format (i.e., convert to lower case). Performs no action if not a dname. .. warning:: This method is scheduled to be deprecated and removed. Convert :class:`ldns_rdf` to :class:`ldns_dname` to use the method. """ warnings.warn("The ldns_rdf.make_canonical() method is scheduled" + " to be deprecated in future releases." + " Convert the ldns_rdf to ldsn_dname and the use its" + " methods.", PendingDeprecationWarning, stacklevel=2) _ldns.ldns_dname2canonical(self) def dname_compare(self, other): """ Compares two dname rdf according to the algorithm for ordering in RFC4034 Section 6. :param other: The second dname rdf to compare. :type other: :class:`ldns_rdf` :throws TypeError: When not a :class:`ldns_rdf` used. :throws Exception: When not dnames compared. :return: (int) -1, 0 or 1 if `self` comes before `other`, `self` is equal or `self` comes after `other` respectively. .. warning:: It is scheduled to be deprecated and removed. Convert :class:`ldns_rdf` to :class:`ldns_dname`. """ warnings.warn("The ldns_rdf.dname_compare() method is" + " scheduled to be deprecated in future releases." + " Convert the ldns_rdf to ldsn_dname and the use its" + " methods.", PendingDeprecationWarning, stacklevel=2) # # The wrapped function generates asserts instead of setting # error status. They cannot be caught from Python so a check # is necessary. # if not isinstance(other, ldns_rdf): raise TypeError("Parameter must be derived from ldns_rdf.") if (self.get_type() != _ldns.LDNS_RDF_TYPE_DNAME) or \ (other.get_type() != _ldns.LDNS_RDF_TYPE_DNAME): raise Exception("Both operands must be dname rdfs.") return _ldns.ldns_dname_compare(self, other) def cat(self, rd2): """ Concatenates `rd2` after `this` dname (`rd2` is copied, `this` dname is modified). :param rd2: The right-hand side. :type rd2: :class:`ldns_rdf` :throws TypeError: When `rd2` of non-:class:`ldns_rdf` or non-:class:`ldns_dname` type. :return: (ldns_status) LDNS_STATUS_OK on success. .. warning:: It is scheduled to be deprecated and removed. Convert :class:`ldns_rdf` to :class:`ldns_dname`. """ warnings.warn("The ldns_rdf.cat() method is scheduled" + " to be deprecated in future releases." + " Convert the ldns_rdf to ldsn_dname and the use its" + " methods.", PendingDeprecationWarning, stacklevel=2) return _ldns.ldns_dname_cat(self, rd2) #parameters: ldns_rdf *, ldns_rdf *, #retvals: ldns_status def cat_clone(self, rd2): """ Concatenates two dnames together. :param rd2: The right-hand side. :type rd2: :class:`ldns_rdf` :throws TypeError: When `rd2` of non-:class:`ldns_rdf` or non-:class:`ldns_dname` type. :return: (:class:`ldns_rdf`) A new rdf with left-hand side + right-hand side content None when error. .. warning:: It is scheduled to be deprecated and removed. Convert :class:`ldns_rdf` to :class:`ldns_dname`. """ warnings.warn("The ldns_rdf.cat_clone() method is scheduled" + " to be deprecated in future releases." + " Convert the ldns_rdf to ldsn_dname and the use its" + " methods.", PendingDeprecationWarning, stacklevel=2) return _ldns.ldns_dname_cat_clone(self, rd2) #parameters: const ldns_rdf *, const ldns_rdf *, #retvals: ldns_rdf * def interval(self, middle, next): """ Check whether the `middle` lays in the interval defined by `this` and `next` (`this` <= `middle` < `next`). This method is useful for nsec checking :param middle: The dname to check. :type middle: :class:`ldns_rdf` :param next: The boundary. :type next: :class:`ldns_rdf` :throws TypeError: When `middle` or `next` of non-:class:`ldns_rdf` type. :throws Exception: When non-dname rdfs compared. :return: (int) 0 on error or unknown, -1 when middle is in the interval, 1 when not. .. warning:: It is scheduled to be deprecated and removed. Convert :class:`ldns_rdf` to :class:`ldns_dname`. """ warnings.warn("The ldns_rdf.interval() method is scheduled" + " to be deprecated in future releases." + " Convert the ldns_rdf to ldsn_dname and the use its" + " methods.", PendingDeprecationWarning, stacklevel=2) # # The wrapped function generates asserts instead of setting # error status. They cannot be caught from Python so a check # is necessary. # if (not isinstance(middle, ldns_rdf)) or \ (not isinstance(next, ldns_rdf)): raise TypeError("Parameters must be derived from ldns_rdf.") if (self.get_type() != _ldns.LDNS_RDF_TYPE_DNAME) or \ (middle.get_type() != _ldns.LDNS_RDF_TYPE_DNAME) or \ (next.get_type() != _ldns.LDNS_RDF_TYPE_DNAME): raise Exception("All operands must be dname rdfs.") return _ldns.ldns_dname_interval(self, middle, next) #parameters: const ldns_rdf *, const ldns_rdf *, const ldns_rdf *, #retvals: int def is_subdomain(self, parent): """ Tests whether the name of the given instance falls under `parent` (i.e., is a sub-domain of `parent`). This function will return False if the given dnames are equal. :param parent: The parent's name. :type parent: :class:`ldns_rdf` :throws TypeError: When `parent` of non-:class:`ldns_rdf` type. :return: (bool) True if `this` falls under `parent`, otherwise False. .. warning:: It is scheduled to be deprecated and removed. Convert :class:`ldns_rdf` to :class:`ldns_dname`. """ warnings.warn("The ldns_rdf.is_subdomain() method is scheduled" + " to be deprecated in future releases." + " Convert the ldns_rdf to ldsn_dname and the use its" + " methods.", PendingDeprecationWarning, stacklevel=2) return _ldns.ldns_dname_is_subdomain(self, parent) #parameters: const ldns_rdf *, const ldns_rdf *, #retvals: bool def label(self, labelpos): """ Look inside the rdf and if it is an LDNS_RDF_TYPE_DNAME try and retrieve a specific label. The labels are numbered starting from 0 (left most). :param labelpos: Index of the label. (Labels are numbered 0, which is the left most.) :type labelpos: integer :throws TypeError: When `labelpos` of non-integer type. :return: (:class:`ldns_rdf`) A new rdf with the label as name or None on error. .. warning:: It is scheduled to be deprecated and removed. Convert :class:`ldns_rdf` to :class:`ldns_dname`. """ warnings.warn("The ldns_rdf.label() method is scheduled" + " to be deprecated in future releases." + " Convert the ldns_rdf to ldsn_dname and the use its" + " methods.", PendingDeprecationWarning, stacklevel=2) return _ldns.ldns_dname_label(self, labelpos) #parameters: const ldns_rdf *, uint8_t, #retvals: ldns_rdf * def label_count(self): """ Count the number of labels inside a LDNS_RDF_DNAME type rdf. :return: (uint8_t) The number of labels. Will return 0 if not a dname. .. warning:: It is scheduled to be deprecated and removed. Convert :class:`ldns_rdf` to :class:`ldns_dname`. """ warnings.warn("The ldns_rdf.label_count() method is scheduled" + " to be deprecated in future releases." + " Convert the ldns_rdf to ldsn_dname and the use its" + " methods.", PendingDeprecationWarning, stacklevel=2) return _ldns.ldns_dname_label_count(self) #parameters: const ldns_rdf *, #retvals: uint8_t def left_chop(self): """ Chop one label off the left side of a dname. (e.g., wwww.nlnetlabs.nl, becomes nlnetlabs.nl) :return: (:class:`ldns_rdf`) The remaining dname or None when error. .. warning:: It is scheduled to be deprecated and removed. Convert :class:`ldns_rdf` to :class:`ldns_dname`. """ warnings.warn("The ldns_rdf.left_chop() method is scheduled" + " to be deprecated in future releases." + " Convert the ldns_rdf to ldsn_dname and the use its" + " methods.", PendingDeprecationWarning, stacklevel=2) return _ldns.ldns_dname_left_chop(self) #parameters: const ldns_rdf *, #retvals: ldns_rdf * def reverse(self): """ Returns a clone of the given dname with the labels reversed. When reversing non-dnames a "." (root name) dname is returned. :throws Exception: When used on non-dname rdfs. :return: (:class:`ldns_rdf`) Clone of the dname with the labels reversed or ".". .. warning:: It is scheduled to be deprecated and removed. Convert :class:`ldns_rdf` to :class:`ldns_dname`. """ warnings.warn("The ldns_rdf.reverse() method is scheduled" + " to be deprecated in future releases." + " Convert the ldns_rdf to ldsn_dname and the use its" + " methods.", PendingDeprecationWarning, stacklevel=2) if self.get_type() != _ldns.LDNS_RDF_TYPE_DNAME: raise Exception("Operand must be a dname rdf.") return _ldns.ldns_dname_reverse(self) #parameters: const ldns_rdf *, #retvals: ldns_rdf * # # _LDNS_RDF_METHODS # %} } ldns-1.6.17/contrib/python/file_py3.i0000664000175100017510000000774612264060151016776 0ustar willemwillem/* * file_py3.i: Typemaps for FILE* for Python 3 * * Copyright (c) 2011, Karel Slany (karel.slany AT nic.cz) * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * Redistributions of source code must retain the above copyright notice, * this list of conditions and the following disclaimer. * * Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * Neither the name of the organization nor the names of its * contributors may be used to endorse or promote products derived from this * software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. */ %{ #include #include %} %types(FILE *); /* converts basic file descriptor flags onto a string */ %fragment("fdfl_to_str", "header") { const char * fdfl_to_str(int fdfl) { static const char * const file_mode[] = {"w+", "w", "r"}; if (fdfl & O_RDWR) { return file_mode[0]; } else if (fdfl & O_WRONLY) { return file_mode[1]; } else { return file_mode[2]; } } } %fragment("obj_to_file","header", fragment="fdfl_to_str") { FILE * obj_to_file(PyObject *obj) { %#if PY_VERSION_HEX >= 0x03000000 int fd, fdfl; FILE *fp; if (!PyLong_Check(obj) && /* is not an integer */ PyObject_HasAttrString(obj, "fileno") && /* has fileno method */ (PyObject_CallMethod(obj, "flush", NULL) != NULL) && /* flush() succeeded */ ((fd = PyObject_AsFileDescriptor(obj)) != -1) && /* got file descriptor */ ((fdfl = fcntl(fd, F_GETFL)) != -1) /* got descriptor flags */ ) { fp = fdopen(dup(fd), fdfl_to_str(fdfl)); /* the FILE* must be flushed and closed after being used */ #ifdef SWIG_FILE3_DEBUG fprintf(stderr, "opening fd %d (fl %d \"%s\") as FILE %p\n", fd, fdfl, fdfl_to_str(fdfl), (void *)fp); #endif return fp; } %#endif return NULL; } } /* returns -1 if error occurred */ %fragment("dispose_file", "header") { int dispose_file(FILE **fp) { #ifdef SWIG_FILE3_DEBUG fprintf(stderr, "flushing FILE %p\n", (void *)fp); #endif if (*fp == NULL) { return 0; } if ((fflush(*fp) == 0) && /* flush file */ (fclose(*fp) == 0)) { /* close file */ *fp = NULL; return 0; } return -1; } } %typemap(arginit, noblock = 1) FILE* { $1 = NULL; } %typemap(check, noblock = 1) FILE* { if ($1 == NULL) { /* The generated wrapper function raises TypeError on mismatching types. */ SWIG_exception_fail(SWIG_TypeError, "in method '" "$symname" "', argument " "$argnum"" of type '" "$type""'"); } } %typemap(in, noblock = 1, fragment = "obj_to_file") FILE* { $1 = obj_to_file($input); } %typemap(freearg, noblock = 1, fragment = "dispose_file") FILE* { if (dispose_file(&$1) == -1) { SWIG_exception_fail(SWIG_IOError, "closing file in method '" "$symname" "', argument " "$argnum"" of type '" "$type""'"); } } ldns-1.6.17/contrib/python/ldns_resolver.i0000664000175100017510000015041412264060151020134 0ustar willemwillem/****************************************************************************** * ldns_resolver.i: LDNS resolver class * * Copyright (c) 2009, Zdenek Vasicek (vasicek AT fit.vutbr.cz) * Karel Slany (slany AT fit.vutbr.cz) * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * Redistributions of source code must retain the above copyright notice, * this list of conditions and the following disclaimer. * * Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * Neither the name of the organization nor the names of its * contributors may be used to endorse or promote products derived from * this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. *****************************************************************************/ /* ========================================================================= */ /* SWIG setting and definitions. */ /* ========================================================================= */ /* Creates temporary instance of (ldns_rersolver *). */ %typemap(in,numinputs=0,noblock=1) (ldns_resolver **r) { ldns_resolver *$1_res; $1 = &$1_res; } /* Result generation, appends (ldns_resolver *) after the result. */ %typemap(argout,noblock=1) (ldns_resolver **r) { $result = SWIG_Python_AppendOutput($result, SWIG_NewPointerObj(SWIG_as_voidptr($1_res), SWIGTYPE_p_ldns_struct_resolver, SWIG_POINTER_OWN | 0 )); } %newobject ldns_resolver_new; %newobject ldns_resolver_pop_nameserver; %newobject ldns_resolver_query; %newobject ldns_resolver_search; %newobject ldns_axfr_next; %newobject ldns_get_rr_list_addr_by_name; %newobject ldns_get_rr_list_name_by_addr; %delobject ldns_resolver_deep_free; %delobject ldns_resolver_free; %nodefaultctor ldns_struct_resolver; /* No default constructor. */ %nodefaultdtor ldns_struct_resolver; /* No default destructor. */ %ignore ldns_struct_resolver::_searchlist; %ignore ldns_struct_resolver::_nameservers; %ignore ldns_resolver_set_nameservers; %rename(ldns_resolver) ldns_struct_resolver; /* Clone data on pull. */ %newobject _ldns_axfr_last_pkt; %rename(__ldns_axfr_last_pkt) ldns_axfr_last_pkt; %inline %{ ldns_pkt * _ldns_axfr_last_pkt(const ldns_resolver *res) { return ldns_pkt_clone(ldns_axfr_last_pkt(res)); } %} %newobject _ldns_resolver_dnssec_anchors; %rename(__ldns_resolver_dnssec_anchors) ldns_resolver_dnssec_anchors; %inline %{ ldns_rr_list * _ldns_resolver_dnssec_anchors(const ldns_resolver *res) { return ldns_rr_list_clone(ldns_resolver_dnssec_anchors(res)); } %} %newobject _ldns_resolver_domain; %rename(__ldns_resolver_domain) ldns_resolver_domain; %inline %{ ldns_rdf * _ldns_resolver_domain(const ldns_resolver *res) { /* Prevents assertion failures. */ ldns_rdf *rdf; rdf = ldns_resolver_domain(res); if (rdf != NULL) { rdf = ldns_rdf_clone(rdf); } return rdf; } %} %newobject _ldns_resolver_tsig_algorithm; %rename(__ldns_resolver_tsig_algorithm) ldns_resolver_tsig_algorithm; %inline %{ char * _ldns_resolver_tsig_algorithm(const ldns_resolver *res) { char *str; str = ldns_resolver_tsig_algorithm(res); if (str != NULL) { str = strdup(str); } return str; } %} %newobject _ldns_resolver_tsig_keydata; %rename(__ldns_resolver_tsig_keydata) ldns_resolver_tsig_keydata; %inline %{ char * _ldns_resolver_tsig_keydata(const ldns_resolver *res) { char *str; str = ldns_resolver_tsig_keydata(res); if (str != NULL) { str = strdup(str); } return str; } %} %newobject _ldns_resolver_tsig_keyname; %rename(__ldns_resolver_tsig_keyname) ldns_resolver_tsig_keyname; %inline %{ char * _ldns_resolver_tsig_keyname(const ldns_resolver *res) { char *str; str = ldns_resolver_tsig_keyname(res); if (str != NULL) { str = strdup(str); } return str; } %} /* End of pull cloning. */ /* Clone data on push. */ %rename(__ldns_resolver_set_dnssec_anchors) ldns_resolver_set_dnssec_anchors; %inline %{ void _ldns_resolver_set_dnssec_anchors(ldns_resolver *res, ldns_rr_list * rrl) { ldns_rr_list *rrl_clone = NULL; if (rrl != NULL) { rrl_clone = ldns_rr_list_clone(rrl); } /* May leak memory, when overwriting pointer value. */ ldns_resolver_set_dnssec_anchors(res, rrl_clone); } %} %rename(__ldns_resolver_set_domain) ldns_resolver_set_domain; %inline %{ void _ldns_resolver_set_domain(ldns_resolver *res, ldns_rdf *rdf) { ldns_rdf *rdf_clone = NULL; if (rdf != NULL) { rdf_clone = ldns_rdf_clone(rdf); } /* May leak memory, when overwriting pointer value. */ ldns_resolver_set_domain(res, rdf_clone); } %} /* End of push cloning. */ /* ========================================================================= */ /* Debugging related code. */ /* ========================================================================= */ #ifdef LDNS_DEBUG %rename(__ldns_resolver_deep_free) ldns_resolver_deep_free; %rename(__ldns_resolver_free) ldns_resolver_free; %inline %{ /*! * @brief Prints information about deallocated resolver and deallocates. */ void _ldns_resolver_deep_free(ldns_resolver *r) { printf("******** LDNS_RESOLVER deep free 0x%lX ************\n", (long unsigned int) r); ldns_resolver_deep_free(r); } /*! * @brief Prints information about deallocated resolver and deallocates. * * @note There should be no need to use this function in the wrapper code, as * it is likely to leak memory. */ void _ldns_resolver_free(ldns_resolver *r) { printf("******** LDNS_RESOLVER free 0x%lX ************\n", (long unsigned int) r); ldns_resolver_free(r); } %} #else /* !LDNS_DEBUG */ %rename(_ldns_resolver_deep_free) ldns_resolver_deep_free; %rename(_ldns_resolver_free) ldns_resolver_free; #endif /* LDNS_DEBUG */ /* ========================================================================= */ /* Added C code. */ /* ========================================================================= */ %newobject _replacement_ldns_resolver_trusted_key; %inline %{ /*! * @brief Replaces the rrs in the list with their clones. * * Prevents memory corruption when automatically deallocating list content. */ void _rr_list_replace_content_with_clones(ldns_rr_list *rrl) { size_t count; unsigned int i; if (rrl == NULL) { return; } count = ldns_rr_list_rr_count(rrl); for (i = 0; i < count; ++i) { ldns_rr_list_set_rr(rrl, ldns_rr_clone(ldns_rr_list_rr(rrl, i)), i); } } /* * @brief Behaves similarly to ldns_resolver_trusted_key(). * * Prevents memory leakage by controlling the usage of content cloning. * * @return Newly allocated list of trusted key clones if any found, * NULL else. */ ldns_rr_list * _replacement_ldns_resolver_trusted_key( const ldns_resolver *res, ldns_rr_list *keys) { ldns_rr_list *trusted_keys = ldns_rr_list_new(); if (ldns_resolver_trusted_key(res, keys, trusted_keys)) { _rr_list_replace_content_with_clones(trusted_keys); } else { ldns_rr_list_deep_free(trusted_keys); trusted_keys = NULL; } return trusted_keys; } %} /* ========================================================================= */ /* Encapsulating Python code. */ /* ========================================================================= */ %feature("docstring") ldns_struct_resolver "LDNS resolver object. The :class:`ldns_resolver` object keeps a list of name servers and can perform queries. **Usage** >>> import ldns >>> resolver = ldns.ldns_resolver.new_frm_file(\"/etc/resolv.conf\") >>> pkt = resolver.query(\"www.nic.cz\", ldns.LDNS_RR_TYPE_A,ldns.LDNS_RR_CLASS_IN) >>> if (pkt) and (pkt.answer()): >>> print pkt.answer() www.nic.cz. 1757 IN A 217.31.205.50 This simple example instances a resolver in order to resolve www.nic.cz A type record." %extend ldns_struct_resolver { %pythoncode %{ def __init__(self): """ Cannot be created directly from Python. """ raise Exception("This class can't be created directly. " + "Please use: new_frm_file(filename), new_frm_fp(file) " + "or new_frm_fp_l(file, line)") __swig_destroy__ = _ldns._ldns_resolver_deep_free # # LDNS_RESOLVER_CONSTRUCTORS_ # @staticmethod def new(): """ Creates a new resolver object. :return: (:class:`ldns_resolver`) New resolver object or None. .. note:: The returned resolver object is unusable unless some name servers are added. **Usage** >>> resolver = ldns.ldns_resolver.new() >>> ns_addr = ldns.ldns_rdf.new_frm_str("8.8.8.8", ldns.LDNS_RDF_TYPE_A) >>> if not ns_addr: raise Exception("Can't create resolver address.") >>> status = resolver.push_nameserver(ns_addr) >>> if status != ldns.LDNS_STATUS_OK: raise Exception("Can't push resolver address.") >>> pkt = resolver.query("www.nic.cz.", ldns.LDNS_RR_TYPE_A, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD) >>> if (pkt) and (pkt.answer()): >>> print pkt.answer() www.nic.cz. 1265 IN A 217.31.205.50 """ return _ldns.ldns_resolver_new() @staticmethod def new_frm_file(filename = "/etc/resolv.conf", raiseException=True): """ Creates a resolver object from given file name :param filename: Name of file which contains resolver informations (usually /etc/resolv.conf). :type filename: str :param raiseException: If True, an exception occurs in case a resolver object can't be created. :type raiseException: bool :throws TypeError: When arguments of inappropriate types. :throws Exception: When `raiseException` set and resolver couldn't be created. :return: (:class:`ldns_resolver`) Resolver object or None. An exception occurs if the object can't be created and 'raiseException' is True. """ status, resolver = _ldns.ldns_resolver_new_frm_file(filename) if status != LDNS_STATUS_OK: if (raiseException): raise Exception("Can't create resolver, error: %d" % status) return None return resolver @staticmethod def new_frm_fp(file, raiseException=True): """ Creates a resolver object from file :param file: A file object. :type file: file :param raiseException: If True, an exception occurs in case a resolver object can't be created. :type raiseException: bool :throws TypeError: When arguments of inappropriate types. :throws Exception: When `raiseException` set and resolver couldn't be created. :return: (:class:`ldns_resolver`) Resolver object or None. An exception occurs if the object can't be created and `raiseException` is True. """ status, resolver = _ldns.ldns_resolver_new_frm_fp(file) if status != LDNS_STATUS_OK: if (raiseException): raise Exception("Can't create resolver, error: %d" % status) return None return resolver @staticmethod def new_frm_fp_l(file, raiseException=True): """ Creates a resolver object from file :param file: A file object. :type file: file :param raiseException: If True, an exception occurs in case a resolver instance can't be created. :type raiseException: bool :throws TypeError: When arguments of inappropriate types. :throws Exception: When `raiseException` set and resolver couldn't be created. :return: * (:class:`ldns_resolver`) Resolver instance or None. An exception occurs if an instance can't be created and `raiseException` is True. * (int) - The line number. (e.g., for debugging) """ status, resolver, line = _ldns.ldns_resolver_new_frm_fp_l(file) if status != LDNS_STATUS_OK: if (raiseException): raise Exception("Can't create resolver, error: %d" % status) return None return resolver, line # # _LDNS_RESOLVER_CONSTRUCTORS # # High level functions def get_addr_by_name(self, name, aclass = _ldns.LDNS_RR_CLASS_IN, flags = _ldns.LDNS_RD): """ Ask the resolver about name and return all address records. :param name: The name to look for. String is automatically converrted to dname. :type name: :class:`ldns_dname` or str :param aclass: The class to use. :type aclass: ldns_rr_class :param flags: Give some optional flags to the query. :type flags: uint16_t :throws TypeError: When arguments of inappropriate types. :return: (:class:`ldns_rr_list`) RR List object or None. **Usage** >>> addr = resolver.get_addr_by_name("www.google.com", ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD) >>> if (not addr): raise Exception("Can't retrieve server address") >>> for rr in addr.rrs(): >>> print rr www.l.google.com. 300 IN A 74.125.43.99 www.l.google.com. 300 IN A 74.125.43.103 www.l.google.com. 300 IN A 74.125.43.104 www.l.google.com. 300 IN A 74.125.43.147 """ rdf = name if isinstance(name, str): rdf = _ldns.ldns_dname_new_frm_str(name) return _ldns.ldns_get_rr_list_addr_by_name(self, rdf, aclass, flags) def get_name_by_addr(self, addr, aclass = _ldns.LDNS_RR_CLASS_IN, flags = _ldns.LDNS_RD): """ Ask the resolver about the address and return the name. :param name: (ldns_rdf of A or AAAA type) the addr to look for. If a string is given, A or AAAA type is identified automatically. :type name: :class:`ldns_rdf` of A or AAAA type :param aclass: The class to use. :type aclass: ldns_rr_class :param flags: Give some optional flags to the query. :type flags: uint16_t :throws TypeError: When arguments of inappropriate types. :return: (:class:`ldns_rr_list`) RR List object or None. **Usage** >>> addr = resolver.get_name_by_addr("74.125.43.99", ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD) >>> if (not addr): raise Exception("Can't retrieve server address") >>> for rr in addr.rrs(): >>> print rr 99.43.125.74.in-addr.arpa. 85641 IN PTR bw-in-f99.google.com. """ rdf = addr if isinstance(addr, str): if (addr.find("::") >= 0): #IPv6 rdf = _ldns.ldns_rdf_new_frm_str(_ldns.LDNS_RDF_TYPE_AAAA, addr) else: rdf = _ldns.ldns_rdf_new_frm_str(_ldns.LDNS_RDF_TYPE_A, addr) return _ldns.ldns_get_rr_list_name_by_addr(self, rdf, aclass, flags) def print_to_file(self,output): """Print a resolver (in so far that is possible) state to output.""" _ldns.ldns_resolver_print(output,self) def axfr_complete(self): """ Returns True if the axfr transfer has completed (i.e., 2 SOA RRs and no errors were encountered). :return: (bool) """ return _ldns.ldns_axfr_complete(self) #parameters: const ldns_resolver *, #retvals: bool def axfr_last_pkt(self): """ Returns a last packet that was sent by the server in the AXFR transfer (usable for instance to get the error code on failure). :return: (:class:`ldns_pkt`) Last packet of the AXFR transfer. """ return _ldns._ldns_axfr_last_pkt(self) #parameters: const ldns_resolver *, #retvals: ldns_pkt * def axfr_next(self): """ Get the next stream of RRs in a AXFR. :return: (:class:`ldns_rr`) The next RR from the AXFR stream. """ return _ldns.ldns_axfr_next(self) #parameters: ldns_resolver *, #retvals: ldns_rr * def axfr_start(self, domain, aclass): """ Prepares the resolver for an axfr query. The query is sent and the answers can be read with :meth:`axfr_next`. :param domain: Domain to axfr. :type domain: :class:`dlsn_dname` :param aclass: The class to use. :type aclass: ldns_rr_class :throws TypeError: When arguments of inappropriate types. :return: (ldns_status) The status of the transfer. .. note:: The type checking of parameter `domain` is benevolent. It allows also to pass a dname :class:`ldns_rdf` object. This will probably change in future. **Usage** :: status = resolver.axfr_start("nic.cz", ldns.LDNS_RR_CLASS_IN) if (status != ldns.LDNS_STATUS_OK): raise Exception("Can't start AXFR, error: %s" % ldns.ldns_get_errorstr_by_id(status)) #Print the results while True: rr = resolver.axfr_next() if not rr: break print rr """ # TODO -- Add checking for ldns_rdf and ldns_dname. rdf = domain if isinstance(domain, str): rdf = _ldns.ldns_dname_new_frm_str(domain) return _ldns.ldns_axfr_start(self, rdf, aclass) #parameters: ldns_resolver *resolver, ldns_rdf *domain, ldns_rr_class c #retvals: int # # LDNS_RESOLVER_METHODS_ # def debug(self): """ Get the debug status of the resolver. :return: (bool) True if so, otherwise False. """ return _ldns.ldns_resolver_debug(self) #parameters: const ldns_resolver *, #retvals: bool def dec_nameserver_count(self): """ Decrement the resolver's name server count. """ _ldns.ldns_resolver_dec_nameserver_count(self) #parameters: ldns_resolver *, #retvals: def defnames(self): """ Does the resolver apply default domain name. :return: (bool) """ return _ldns.ldns_resolver_defnames(self) #parameters: const ldns_resolver *, #retvals: bool def dnsrch(self): """ Does the resolver apply search list. :return: (bool) """ return _ldns.ldns_resolver_dnsrch(self) #parameters: const ldns_resolver *, #retvals: bool def dnssec(self): """ Does the resolver do DNSSEC. :return: (bool) True: yes, False: no. """ return _ldns.ldns_resolver_dnssec(self) #parameters: const ldns_resolver *, #retvals: bool def dnssec_anchors(self): """ Get the resolver's DNSSEC anchors. :return: (:class:`ldns_rr_list`) An rr list containing trusted DNSSEC anchors. """ return _ldns._ldns_resolver_dnssec_anchors(self) #parameters: const ldns_resolver *, #retvals: ldns_rr_list * def dnssec_cd(self): """ Does the resolver set the CD bit. :return: (bool) True: yes, False: no. """ return _ldns.ldns_resolver_dnssec_cd(self) #parameters: const ldns_resolver *, #retvals: bool def domain(self): """ What is the default dname to add to relative queries. :return: (:class:`ldns_dname`) The dname which is added. """ dname = _ldns._ldns_resolver_domain(self) if dname != None: return ldns_dname(_ldns._ldns_resolver_domain(self), clone=False) else: return dname #parameters: const ldns_resolver *, #retvals: ldns_rdf * def edns_udp_size(self): """ Get the resolver's udp size. :return: (uint16_t) The udp mesg size. """ return _ldns.ldns_resolver_edns_udp_size(self) #parameters: const ldns_resolver *, #retvals: uint16_t def fail(self): """ Does the resolver only try the first name server. :return: (bool) True: yes, fail, False: no, try the others. """ return _ldns.ldns_resolver_fail(self) #parameters: const ldns_resolver *, #retvals: bool def fallback(self): """ Get the truncation fall-back status. :return: (bool) Whether the truncation fall*back mechanism is used. """ return _ldns.ldns_resolver_fallback(self) #parameters: const ldns_resolver *, #retvals: bool def igntc(self): """ Does the resolver ignore the TC bit (truncated). :return: (bool) True: yes, False: no. """ return _ldns.ldns_resolver_igntc(self) #parameters: const ldns_resolver *, #retvals: bool def incr_nameserver_count(self): """ Increment the resolver's name server count. """ _ldns.ldns_resolver_incr_nameserver_count(self) #parameters: ldns_resolver *, #retvals: def ip6(self): """ Does the resolver use ip6 or ip4. :return: (uint8_t) 0: both, 1: ip4, 2:ip6 """ return _ldns.ldns_resolver_ip6(self) #parameters: const ldns_resolver *, #retvals: uint8_t def nameserver_count(self): """ How many name server are configured in the resolver. :return: (size_t) Number of name servers. """ return _ldns.ldns_resolver_nameserver_count(self) #parameters: const ldns_resolver *, #retvals: size_t def nameserver_rtt(self, pos): """ Return the used round trip time for a specific name server. :param pos: The index to the name server. :type pos: size_t :throws TypeError: When arguments of inappropriate types. :return: (size_t) The rrt, 0: infinite, >0: undefined (as of * yet). """ return _ldns.ldns_resolver_nameserver_rtt(self, pos) #parameters: const ldns_resolver *,size_t, #retvals: size_t def nameservers(self): """ Return the configured name server ip address. :return: (ldns_rdf \*\*) A ldns_rdf pointer to a list of the addresses. """ # TODO -- Convert to list of ldns_rdf. return _ldns.ldns_resolver_nameservers(self) #parameters: const ldns_resolver *, #retvals: ldns_rdf ** def nameservers_randomize(self): """ Randomize the name server list in the resolver. """ _ldns.ldns_resolver_nameservers_randomize(self) #parameters: ldns_resolver *, #retvals: def pop_nameserver(self): """ Pop the last name server from the resolver. :return: (:class:`ldns_rdf`) The popped address or None if empty. """ return _ldns.ldns_resolver_pop_nameserver(self) #parameters: ldns_resolver *, #retvals: ldns_rdf * def port(self): """ Get the port the resolver should use. :return: (uint16_t) The port number. """ return _ldns.ldns_resolver_port(self) #parameters: const ldns_resolver *, #retvals: uint16_t def prepare_query_pkt(self, name, t, c, f, raiseException=True): """ Form a query packet from a resolver and name/type/class combo. :param name: Query for this name. :type name: :class:`ldns_dname` or str :param t: Query for this type (may be 0, defaults to A). :type t: ldns_rr_type :param c: Query for this class (may be 0, default to IN). :type c: ldns_rr_class :param f: The query flags. :type f: uint16_t :throws TypeError: When arguments of inappropriate types. :throws Exception: When `raiseException` set and answer couldn't be resolved. :return: (:class:`ldns_pkt`) Query packet or None. An exception occurs if the object can't be created and 'raiseException' is True. """ rdf = name if isinstance(name, str): rdf = _ldns.ldns_dname_new_frm_str(name) status, pkt = _ldns.ldns_resolver_prepare_query_pkt(self, rdf, t, c, f) if status != LDNS_STATUS_OK: if (raiseException): raise Exception("Can't create resolver, error: %d" % status) return None return pkt #parameters: ldns_resolver *,const ldns_rdf *,ldns_rr_type,ldns_rr_class,uint16_t, #retvals: ldns_status,ldns_pkt ** def push_dnssec_anchor(self, rr): """ Push a new trust anchor to the resolver. It must be a DS or DNSKEY rr. :param rr: The RR to add as a trust anchor. :type rr: DS of DNSKEY :class:`ldns_rr` :throws TypeError: When arguments of inappropriate types. :return: (ldns_status) A status. """ return _ldns.ldns_resolver_push_dnssec_anchor(self, rr) #parameters: ldns_resolver *,ldns_rr *, #retvals: ldns_status def push_nameserver(self, n): """ Push a new name server to the resolver. It must be an IP address v4 or v6. :param n: The ip address. :type n: :class:`ldns_rdf` of A or AAAA type. :throws TypeError: When arguments of inappropriate types. :return: (ldns_status) A status. """ return _ldns.ldns_resolver_push_nameserver(self, n) #parameters: ldns_resolver *,ldns_rdf *, #retvals: ldns_status def push_nameserver_rr(self, rr): """ Push a new name server to the resolver. It must be an A or AAAA RR record type. :param rr: The resource record. :type rr: :class:`ldns_rr` of A or AAAA type. :throws TypeError: When arguments of inappropriate types. :return: (ldns_status) A status. """ return _ldns.ldns_resolver_push_nameserver_rr(self, rr) #parameters: ldns_resolver *,ldns_rr *, #retvals: ldns_status def push_nameserver_rr_list(self, rrlist): """ Push a new name server rr_list to the resolver. :param rrlist: The rr list to push. :type rrlist: :class:`ldns_rr_list` :throws TypeError: When arguments of inappropriate types. :return: (ldns_status) A status. """ return _ldns.ldns_resolver_push_nameserver_rr_list(self, rrlist) #parameters: ldns_resolver *,ldns_rr_list *, #retvals: ldns_status def push_searchlist(self, rd): """ Push a new rd to the resolver's search-list. :param rd: To push. :param rd: :class:`ldns_dname` or str :throws TypeError: When arguments of inappropriate types. .. note: The function does not return any return status, so the caller must ensure the correctness of the passed values. """ rdf = rd if isinstance(rd, str): rdf = _ldns.ldns_dname_new_frm_str(rd) _ldns.ldns_resolver_push_searchlist(self, rdf) #parameters: ldns_resolver *,ldns_rdf *, #retvals: def query(self,name,atype=_ldns.LDNS_RR_TYPE_A,aclass=_ldns.LDNS_RR_CLASS_IN,flags=_ldns.LDNS_RD): """ Send a query to a name server. :param name: The name to look for. :type name: :class:`ldns_dname` or str :param atype: The RR type to use. :type atype: ldns_rr_type :param aclass: The RR class to use. :type aclass: ldns_rr_class :param flags: Give some optional flags to the query. :type flags: uint16_t :throws TypeError: When arguments of inappropriate types. :return: (:class:`ldns_pkt`) A packet with the reply from the name server if _defnames is true the default domain will be added. """ # Explicit conversion from string to ldns_rdf prevents memory leaks. # TODO -- Find out why. dname = name if isinstance(name, str): dname = _ldns.ldns_dname_new_frm_str(name) return _ldns.ldns_resolver_query(self, dname, atype, aclass, flags) #parameters: const ldns_resolver *,const ldns_rdf *,ldns_rr_type,ldns_rr_class,uint16_t, #retvals: ldns_pkt * def random(self): """ Does the resolver randomize the name server before usage? :return: (bool) True: yes, False: no. """ return _ldns.ldns_resolver_random(self) #parameters: const ldns_resolver *, #retvals: bool def recursive(self): """ Is the resolver set to recurse? :return: (bool) True if so, otherwise False. """ return _ldns.ldns_resolver_recursive(self) #parameters: const ldns_resolver *, #retvals: bool def retrans(self): """ Get the retransmit interval. :return: (uint8_t) The retransmit interval. """ return _ldns.ldns_resolver_retrans(self) #parameters: const ldns_resolver *, #retvals: uint8_t def retry(self): """ Get the number of retries. :return: (uint8_t) The number of retries. """ return _ldns.ldns_resolver_retry(self) #parameters: const ldns_resolver *, #retvals: uint8_t def rtt(self): """ Return the used round trip times for the name servers. :return: (size_t \*) a size_t* pointer to the list. yet) """ return _ldns.ldns_resolver_rtt(self) #parameters: const ldns_resolver *, #retvals: size_t * def search(self, name, atype=_ldns.LDNS_RR_TYPE_A, aclass=_ldns.LDNS_RR_CLASS_IN, flags=_ldns.LDNS_RD): """ Send the query for using the resolver and take the search list into account The search algorithm is as follows: If the name is absolute, try it as-is, otherwise apply the search list. :param name: The name to look for. :type name: :class:`ldns_dname` or str :param atype: The RR type to use. :type atype: ldns_rr_type :param aclass: The RR class to use. :type aclass: ldns_rr_class :param flags: Give some optional flags to the query. :type flags: uint16_t :throws TypeError: When arguments of inappropriate types. :return: (:class:`ldns_pkt`) A packet with the reply from the name server. """ # Explicit conversion from string to ldns_rdf prevents memory leaks. # TODO -- Find out why. dname = name if isinstance(name, str): dname = _ldns.ldns_dname_new_frm_str(name) return _ldns.ldns_resolver_search(self, dname, atype, aclass, flags) #parameters: const ldns_resolver *,const ldns_rdf *,ldns_rr_type,ldns_rr_class,uint16_t, #retvals: ldns_pkt * def searchlist(self): """ What is the search-list as used by the resolver. :return: (ldns_rdf \*\*) A ldns_rdf pointer to a list of the addresses. """ return _ldns.ldns_resolver_searchlist(self) #parameters: const ldns_resolver *, #retvals: ldns_rdf \*\* def searchlist_count(self): """ Return the resolver's search-list count. :return: (size_t) The search-list count. """ return _ldns.ldns_resolver_searchlist_count(self) #parameters: const ldns_resolver *, #retvals: size_t def send(self, name, atype, aclass, flags, raiseException=True): """ Send the query for name as-is. :param name: The name to look for. :type name: :class:`ldns_dname` or str :param atype: The RR type to use. :type atype: ldns_rr_type :param aclass: The RR class to use. :type aclass: ldns_rr_class :param flags: Give some optional flags to the query. :type flags: uint16_t :throws TypeError: When arguments of inappropriate types. :throws Exception: When `raiseException` set and answer couldn't be resolved. :return: (:class:`ldns_pkt`) A packet with the reply from the name server. """ # Explicit conversion from string to ldns_rdf prevents memory leaks. # TODO -- Find out why. dname = name if isinstance(name, str): dname = _ldns.ldns_dname_new_frm_str(name) status, pkt = _ldns.ldns_resolver_send(self, dname, atype, aclass, flags) if status != LDNS_STATUS_OK: if (raiseException): raise Exception("Can't create resolver, error: %d" % status) return None return pkt #parameters: ldns_resolver *,const ldns_rdf *,ldns_rr_type,ldns_rr_class,uint16_t, #retvals: ldns_status,ldns_pkt ** def send_pkt(self, query_pkt): """ Send the given packet to a name server. :param query_pkt: Query packet. :type query_pkt: :class:`ldns_pkt` :throws TypeError: When arguments of inappropriate types. :return: * (ldns_status) Return status. * (:class:`ldns_pkt`) Response packet if returns status ok. """ status, answer = _ldns.ldns_resolver_send_pkt(self, query_pkt) return _ldns.ldns_resolver_send_pkt(self,query_pkt) #parameters: ldns_resolver *,ldns_pkt *, #retvals: ldns_status,ldns_pkt ** def set_debug(self, b): """ Set the resolver debugging. :param b: True: debug on, False: debug off. :type b: bool """ _ldns.ldns_resolver_set_debug(self, b) #parameters: ldns_resolver *,bool, #retvals: def set_defnames(self, b): """ Whether the resolver uses the name set with _set_domain. :param b: True: use the defaults, False: don't use them. :type b: bool """ _ldns.ldns_resolver_set_defnames(self, b) #parameters: ldns_resolver *,bool, #retvals: def set_dnsrch(self, b): """ Whether the resolver uses the search list. :param b: True: use the list, False: don't use the list. :type b: bool """ _ldns.ldns_resolver_set_dnsrch(self, b) #parameters: ldns_resolver *,bool, #retvals: def set_dnssec(self, b): """ Whether the resolver uses DNSSEC. :param b: True: use DNSSEC, False: don't use DNSSEC. :type b: bool """ _ldns.ldns_resolver_set_dnssec(self, b) #parameters: ldns_resolver *,bool, #retvals: def set_dnssec_anchors(self, l): """ Set the resolver's DNSSEC anchor list directly. RRs should be of type DS or DNSKEY. :param l: The list of RRs to use as trust anchors. :type l: :class:`ldns_rr_list` :throws TypeError: When arguments of inappropriate types. """ _ldns._ldns_resolver_set_dnssec_anchors(self, l) #parameters: ldns_resolver *,ldns_rr_list *, #retvals: def set_dnssec_cd(self, b): """ Whether the resolver uses the checking disable bit. :param b: True: enable, False: disable. :type b: bool """ _ldns.ldns_resolver_set_dnssec_cd(self, b) #parameters: ldns_resolver *,bool, #retvals: def set_domain(self, rd): """ Set the resolver's default domain. This gets appended when no absolute name is given. :param rd: The name to append. :type rd: :class:`ldns_dname` or str :throws TypeError: When arguments of inappropriate types. :throws Exception: When `rd` a non dname rdf. .. note:: The type checking of parameter `rd` is benevolent. It allows also to pass a dname :class:`ldns_rdf` object. This will probably change in future. """ # Also has to be able to pass None or dame string. if isinstance(rd, str): dname = _ldns.ldns_dname_new_frm_str(rd) elif (not isinstance(rd, ldns_dname)) and \ isinstance(rd, ldns_rdf) and \ rd.get_type() == _ldns.LDNS_RDF_TYPE_DNAME: warnings.warn("The ldns_resolver.set_domain() method" + " will drop the possibility to accept ldns_rdf." + " Convert argument to ldns_dname.", PendingDeprecationWarning, stacklevel=2) dname = rd else: dname = rd if (not isinstance(dname, ldns_rdf)) and (dname != None): raise TypeError("Parameter must be derived from ldns_rdf.") if (isinstance(dname, ldns_rdf)) and \ (dname.get_type() != _ldns.LDNS_RDF_TYPE_DNAME): raise Exception("Operands must be ldns_dname.") _ldns._ldns_resolver_set_domain(self, dname) #parameters: ldns_resolver *,ldns_rdf *, #retvals: def set_edns_udp_size(self, s): """ Set maximum udp size. :param s: The udp max size. :type s: uint16_t :throws TypeError: When arguments of inappropriate types. """ _ldns.ldns_resolver_set_edns_udp_size(self,s) #parameters: ldns_resolver *,uint16_t, #retvals: def set_fail(self, b): """ Whether or not to fail after one failed query. :param b: True: yes fail, False: continue with next name server. :type b: bool """ _ldns.ldns_resolver_set_fail(self, b) #parameters: ldns_resolver *,bool, #retvals: def set_fallback(self, fallback): """ Set whether the resolvers truncation fall-back mechanism is used when :meth:`query` is called. :param fallback: Whether to use the fall-back mechanism. :type fallback: bool """ _ldns.ldns_resolver_set_fallback(self, fallback) #parameters: ldns_resolver *,bool, #retvals: def set_igntc(self, b): """ Whether or not to ignore the TC bit. :param b: True: yes ignore, False: don't ignore. :type b: bool """ _ldns.ldns_resolver_set_igntc(self, b) #parameters: ldns_resolver *,bool, #retvals: def set_ip6(self, i): """ Whether the resolver uses ip6. :param i: 0: no pref, 1: ip4, 2: ip6 :type i: uint8_t :throws TypeError: When arguments of inappropriate types. """ _ldns.ldns_resolver_set_ip6(self, i) #parameters: ldns_resolver *,uint8_t, #retvals: def set_nameserver_count(self, c): """ Set the resolver's name server count directly. :param c: The name server count. :type c: size_t :throws TypeError: When arguments of inappropriate types. """ _ldns.ldns_resolver_set_nameserver_count(self, c) #parameters: ldns_resolver *,size_t, #retvals: def set_nameserver_rtt(self, pos, value): """ Set round trip time for a specific name server. Note this currently differentiates between: unreachable and reachable. :param pos: The name server position. :type pos: size_t :param value: The rtt. :type value: size_t :throws TypeError: When arguments of inappropriate types. """ _ldns.ldns_resolver_set_nameserver_rtt(self, pos, value) #parameters: ldns_resolver *,size_t,size_t, #retvals: def set_nameservers(self, rd): """ Set the resolver's name server count directly by using an rdf list. :param rd: The resolver addresses. :type rd: ldns_rdf \*\* :throws TypeError: When arguments of inappropriate types. """ _ldns.ldns_resolver_set_nameservers(self, rd) #parameters: ldns_resolver *,ldns_rdf **, #retvals: def set_port(self, p): """ Set the port the resolver should use. :param p: The port number. :type p: uint16_t :throws TypeError: When arguments of inappropriate types. """ _ldns.ldns_resolver_set_port(self, p) #parameters: ldns_resolver *,uint16_t, #retvals: def set_random(self, b): """ Should the name server list be randomized before each use. :param b: True: randomize, False: don't. :type b: bool """ _ldns.ldns_resolver_set_random(self, b) #parameters: ldns_resolver *,bool, #retvals: def set_recursive(self, b): """ Set the resolver recursion. :param b: True: set to recurse, False: unset. :type b: bool """ _ldns.ldns_resolver_set_recursive(self, b) #parameters: ldns_resolver *,bool, #retvals: def set_retrans(self, re): """ Set the resolver retrans time-out (in seconds). :param re: The retransmission interval in seconds. :type re: uint8_t :throws TypeError: When arguments of inappropriate types. """ _ldns.ldns_resolver_set_retrans(self, re) #parameters: ldns_resolver *,uint8_t, #retvals: def set_retry(self, re): """ Set the resolver retry interval (in seconds). :param re: The retry interval. :type re: uint8_t :throws TypeError: When arguments of inappropriate types. """ _ldns.ldns_resolver_set_retry(self,re) #parameters: ldns_resolver *,uint8_t, #retvals: def set_rtt(self, rtt): """ Set round trip time for all name servers. Note this currently differentiates between: unreachable and reachable. :param rtt: A list with the times. :type rtt: size \* :throws TypeError: When arguments of inappropriate types. """ _ldns.ldns_resolver_set_rtt(self, rtt) #parameters: ldns_resolver *,size_t *, #retvals: def set_timeout(self, timeout): """ Set the resolver's socket time out when talking to remote hosts. :param timeout: The time-out to use. :param timeout: struct timeval :throws TypeError: When arguments of inappropriate types. """ _ldns.ldns_resolver_set_timeout(self,timeout) #parameters: ldns_resolver *,struct timeval, #retvals: def set_tsig_algorithm(self, tsig_algorithm): """ Set the tsig algorithm. :param tsig_algorithm: The tsig algorithm. :param tsig_algorithm: str :throws TypeError: When arguments of inappropriate types. """ _ldns.ldns_resolver_set_tsig_algorithm(self, tsig_algorithm) #parameters: ldns_resolver *,char *, #retvals: def set_tsig_keydata(self, tsig_keydata): """ Set the tsig key data. :param tsig_keydata: The key data. :type tsig_keydata: str :throws TypeError: When arguments of inappropriate types. """ _ldns.ldns_resolver_set_tsig_keydata(self, tsig_keydata) #parameters: ldns_resolver *,char *, #retvals: def set_tsig_keyname(self, tsig_keyname): """ Set the tsig key name. :param tsig_keyname: The tsig key name. :type tsig_keyname: str :throws TypeError: When arguments of inappropriate types. """ _ldns.ldns_resolver_set_tsig_keyname(self, tsig_keyname) #parameters: ldns_resolver *,char *, #retvals: def set_usevc(self, b): """ Whether the resolver uses a virtual circuit (TCP). :param b: True: use TCP, False: don't use TCP. :type b: bool """ _ldns.ldns_resolver_set_usevc(self, b) #parameters: ldns_resolver *,bool, #retvals: def timeout(self): """ What is the time-out on socket connections. :return: (struct timeval) The time-out. """ return _ldns.ldns_resolver_timeout(self) #parameters: const ldns_resolver *, #retvals: struct timeval def trusted_key(self, keys): """ Returns true if at least one of the provided keys is a trust anchor. :param keys: The key set to check. :type keys: :class:`ldns_rr_list` :throws TypeError: When arguments of inappropriate types. :return: (:class:`ldns_rr_list`) List of trusted keys if at least one of the provided keys is a configured trust anchor, None else. """ return _ldns._replacement_ldns_resolver_trusted_key(self, keys) #parameters: const ldns_resolver *,ldns_rr_list *,ldns_rr_list *, #retvals: bool def tsig_algorithm(self): """ Return the tsig algorithm as used by the name server. :return: (str) The algorithm used. """ return _ldns._ldns_resolver_tsig_algorithm(self) #parameters: const ldns_resolver *, #retvals: char * def tsig_keydata(self): """ Return the tsig key data as used by the name server. :return: (str) The key data used. """ return _ldns._ldns_resolver_tsig_keydata(self) #parameters: const ldns_resolver *, #retvals: char * def tsig_keyname(self): """ Return the tsig key name as used by the name server. :return: (str) The name used. """ return _ldns._ldns_resolver_tsig_keyname(self) #parameters: const ldns_resolver *, #retvals: char * def usevc(self): """ Does the resolver use tcp or udp. :return: (bool) True: tcp, False: udp. """ return _ldns.ldns_resolver_usevc(self) #parameters: const ldns_resolver *, #retvals: bool # # _LDNS_RESOLVER_METHODS # %} } ldns-1.6.17/contrib/python/ldns_dnssec.i0000664000175100017510000004454612264060151017562 0ustar willemwillem/****************************************************************************** * ldns_dnssec.i: DNSSEC zone, name, rrs * * Copyright (c) 2009, Zdenek Vasicek (vasicek AT fit.vutbr.cz) * Karel Slany (slany AT fit.vutbr.cz) * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * Redistributions of source code must retain the above copyright notice, * this list of conditions and the following disclaimer. * * Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * Neither the name of the organization nor the names of its * contributors may be used to endorse or promote products derived from this * software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. ******************************************************************************/ %nodefaultctor ldns_dnssec_rrs; //no default constructor & destructor %nodefaultdtor ldns_dnssec_rrs; %newobject ldns_dnssec_rrs_new; %delobject ldns_dnssec_rrs_free; %extend ldns_dnssec_rrs { %pythoncode %{ def __init__(self): """Creates a new entry for 1 pointer to an rr and 1 pointer to the next rrs. :returns: (ldns_dnssec_rrs) the allocated data """ self.this = _ldns.ldns_dnssec_rrs_new() if not self.this: raise Exception("Can't create rrs instance") __swig_destroy__ = _ldns.ldns_dnssec_rrs_free #LDNS_DNSSEC_RRS_METHODS_# def add_rr(self,rr): """Adds an RR to the list of RRs. The list will remain ordered :param rr: the RR to add :returns: (ldns_status) LDNS_STATUS_OK on success """ return _ldns.ldns_dnssec_rrs_add_rr(self,rr) #parameters: ldns_dnssec_rrs *,ldns_rr *, #retvals: ldns_status #_LDNS_DNSSEC_RRS_METHODS# %} } // ================================================================================ // DNNSEC RRS // ================================================================================ %nodefaultctor ldns_dnssec_rrsets; //no default constructor & destructor %nodefaultdtor ldns_dnssec_rrsets; %newobject ldns_dnssec_rrsets_new; %delobject ldns_dnssec_rrsets_free; %extend ldns_dnssec_rrsets { %pythoncode %{ def __init__(self): """Creates a new list (entry) of RRsets. :returns: (ldns_dnssec_rrsets \*) instance """ self.this = _ldns.ldns_dnssec_rrsets_new() if not self.this: raise Exception("Can't create rrsets instance") __swig_destroy__ = _ldns.ldns_dnssec_rrsets_free def print_to_file(self, file, follow): """Print the given list of rrsets to the given file descriptor. :param file: file pointer :param follow: if set to false, only print the first RRset """ _ldns.ldns_dnssec_rrsets_print(file,self,follow) #parameters: FILE *,ldns_dnssec_rrsets *,bool, #retvals: #LDNS_DNSSEC_RRSETS_METHODS_# def add_rr(self,rr): """Add an ldns_rr to the corresponding RRset in the given list of RRsets. If it is not present, add it as a new RRset with 1 record. :param rr: the rr to add to the list of rrsets :returns: (ldns_status) LDNS_STATUS_OK on success """ return _ldns.ldns_dnssec_rrsets_add_rr(self,rr) #parameters: ldns_dnssec_rrsets *,ldns_rr *, #retvals: ldns_status def set_type(self,atype): """Sets the RR type of the rrset (that is head of the given list). :param atype: :returns: (ldns_status) LDNS_STATUS_OK on success """ return _ldns.ldns_dnssec_rrsets_set_type(self,atype) #parameters: ldns_dnssec_rrsets *,ldns_rr_type, #retvals: ldns_status def type(self): """Returns the rr type of the rrset (that is head of the given list). :returns: (ldns_rr_type) the rr type """ return _ldns.ldns_dnssec_rrsets_type(self) #parameters: ldns_dnssec_rrsets *, #retvals: ldns_rr_type #_LDNS_DNSSEC_RRSETS_METHODS# %} } // ================================================================================ // DNNSEC NAME // ================================================================================ %nodefaultctor ldns_dnssec_name; //no default constructor & destructor %nodefaultdtor ldns_dnssec_name; %newobject ldns_dnssec_name_new; %delobject ldns_dnssec_name_free; %extend ldns_dnssec_name { %pythoncode %{ def __init__(self): """Create a new instance of dnssec name.""" self.this = _ldns.ldns_dnssec_name_new() if not self.this: raise Exception("Can't create dnssec name instance") __swig_destroy__ = _ldns.ldns_dnssec_name_free def print_to_file(self,file): """Prints the RRs in the dnssec name structure to the given file descriptor. :param file: file pointer """ _ldns.ldns_dnssec_name_print(file, self) #parameters: FILE *,ldns_dnssec_name *, @staticmethod def new_frm_rr(raiseException=True): """Create a new instace of dnssec name for the given RR. :returns: (ldns_dnssec_name) instance """ name = _ldns.ldns_dnssec_name_new_frm_rr(self) if (not name) and (raiseException): raise Exception("Can't create dnssec name") return name #LDNS_DNSSEC_NAME_METHODS_# def add_rr(self,rr): """Inserts the given rr at the right place in the current dnssec_name No checking is done whether the name matches. :param rr: The RR to add :returns: (ldns_status) LDNS_STATUS_OK on success, error code otherwise """ return _ldns.ldns_dnssec_name_add_rr(self,rr) #parameters: ldns_dnssec_name *,ldns_rr *, #retvals: ldns_status def find_rrset(self,atype): """Find the RRset with the given type in within this name structure. :param atype: :returns: (ldns_dnssec_rrsets \*) the RRset, or NULL if not present """ return _ldns.ldns_dnssec_name_find_rrset(self,atype) #parameters: ldns_dnssec_name *,ldns_rr_type, #retvals: ldns_dnssec_rrsets * def name(self): """Returns the domain name of the given dnssec_name structure. :returns: (ldns_rdf \*) the domain name """ return _ldns.ldns_dnssec_name_name(self) #parameters: ldns_dnssec_name *, #retvals: ldns_rdf * def set_name(self,dname): """Sets the domain name of the given dnssec_name structure. :param dname: the domain name to set it to. This data is *not* copied. """ _ldns.ldns_dnssec_name_set_name(self,dname) #parameters: ldns_dnssec_name *,ldns_rdf *, #retvals: def set_nsec(self,nsec): """Sets the NSEC(3) RR of the given dnssec_name structure. :param nsec: the nsec rr to set it to. This data is *not* copied. """ _ldns.ldns_dnssec_name_set_nsec(self,nsec) #parameters: ldns_dnssec_name *,ldns_rr *, #retvals: #_LDNS_DNSSEC_NAME_METHODS# %} } // ================================================================================ // DNNSEC ZONE // ================================================================================ %nodefaultctor ldns_dnssec_zone; //no default constructor & destructor %nodefaultdtor ldns_dnssec_zone; %newobject ldns_dnssec_zone_new; %delobject ldns_dnssec_zone_free; %inline %{ ldns_status ldns_dnssec_zone_sign_defcb(ldns_dnssec_zone *zone, ldns_rr_list *new_rrs, ldns_key_list *key_list, int cbtype) { if (cbtype == 0) return ldns_dnssec_zone_sign(zone, new_rrs, key_list, ldns_dnssec_default_add_to_signatures, NULL); if (cbtype == 1) return ldns_dnssec_zone_sign(zone, new_rrs, key_list, ldns_dnssec_default_leave_signatures, NULL); if (cbtype == 2) return ldns_dnssec_zone_sign(zone, new_rrs, key_list, ldns_dnssec_default_delete_signatures, NULL); return ldns_dnssec_zone_sign(zone, new_rrs, key_list, ldns_dnssec_default_replace_signatures, NULL); } ldns_status ldns_dnssec_zone_add_rr_(ldns_dnssec_zone *zone, ldns_rr *rr) { ldns_rr *new_rr; ldns_status status; new_rr = ldns_rr_clone(rr); /* * A clone of the RR is created to be stored in the DNSSEC zone. * The Python engine frees a RR object as soon it's reference count * reaches zero. The code must avoid double freeing or accessing of freed * memory. */ status = ldns_dnssec_zone_add_rr(zone, new_rr); if (status != LDNS_STATUS_OK) { ldns_rr_free(new_rr); } return status; } %} %extend ldns_dnssec_zone { %pythoncode %{ def __init__(self): """Creates a new dnssec_zone instance""" self.this = _ldns.ldns_dnssec_zone_new() if not self.this: raise Exception("Can't create dnssec zone instance") __swig_destroy__ = _ldns.ldns_dnssec_zone_free def print_to_file(self,file): """Prints the complete zone to the given file descriptor. :param file: file pointer """ _ldns.ldns_dnssec_zone_print(file, self) #parameters: FILE *, ldns_dnssec_zone *, #retvals: def create_nsec3s(self,new_rrs,algorithm,flags,iterations,salt_length,salt): """Adds NSEC3 records to the zone. :param new_rrs: :param algorithm: :param flags: :param iterations: :param salt_length: :param salt: :returns: (ldns_status) """ return _ldns.ldns_dnssec_zone_create_nsec3s(self,new_rrs,algorithm,flags,iterations,salt_length,salt) #parameters: ldns_dnssec_zone *,ldns_rr_list *,uint8_t,uint8_t,uint16_t,uint8_t,uint8_t *, #retvals: ldns_status def create_nsecs(self,new_rrs): """Adds NSEC records to the given dnssec_zone. :param new_rrs: ldns_rr's created by this function are added to this rr list, so the caller can free them later :returns: (ldns_status) LDNS_STATUS_OK on success, an error code otherwise """ return _ldns.ldns_dnssec_zone_create_nsecs(self,new_rrs) #parameters: ldns_dnssec_zone *,ldns_rr_list *, #retvals: ldns_status def create_rrsigs(self,new_rrs,key_list,func,arg): """Adds signatures to the zone. :param new_rrs: the RRSIG RRs that are created are also added to this list, so the caller can free them later :param key_list: list of keys to sign with. :param func: Callback function to decide what keys to use and what to do with old signatures :param arg: Optional argument for the callback function :returns: (ldns_status) LDNS_STATUS_OK on success, error otherwise """ return _ldns.ldns_dnssec_zone_create_rrsigs(self,new_rrs,key_list,func,arg) #parameters: ldns_dnssec_zone *,ldns_rr_list *,ldns_key_list *,int(*)(ldns_rr *, void *),void *, #retvals: ldns_status def sign_cb(self,new_rrs,key_list,func,arg): """signs the given zone with the given keys (with callback function) :param new_rrs: newly created resource records are added to this list, to free them later :param key_list: the list of keys to sign the zone with :param func: callback function that decides what to do with old signatures. This function takes an ldns_rr and an optional arg argument, and returns one of four values: * LDNS_SIGNATURE_LEAVE_ADD_NEW - leave the signature and add a new one for the corresponding key * LDNS_SIGNATURE_REMOVE_ADD_NEW - remove the signature and replace is with a new one from the same key * LDNS_SIGNATURE_LEAVE_NO_ADD - leave the signature and do not add a new one with the corresponding key * LDNS_SIGNATURE_REMOVE_NO_ADD - remove the signature and do not replace :param arg: optional argument for the callback function :returns: (ldns_status) LDNS_STATUS_OK on success, an error code otherwise """ return _ldns.ldns_dnssec_zone_sign(self,new_rrs,key_list,func,arg) #parameters: ldns_dnssec_zone *,ldns_rr_list *,ldns_key_list *,int(*)(ldns_rr *, void *),void *, #retvals: ldns_status def sign(self,new_rrs,key_list, cbtype=3): """signs the given zone with the given keys :param new_rrs: newly created resource records are added to this list, to free them later :param key_list: the list of keys to sign the zone with :param cb_type: specifies how to deal with old signatures, possible values: * 0 - ldns_dnssec_default_add_to_signatures, * 1 - ldns_dnssec_default_leave_signatures, * 2 - ldns_dnssec_default_delete_signatures, * 3 - ldns_dnssec_default_replace_signatures :returns: (ldns_status) LDNS_STATUS_OK on success, an error code otherwise """ return _ldns.ldns_dnssec_zone_sign_defcb(self,new_rrs,key_list, cbtype) #parameters: ldns_dnssec_zone *,ldns_rr_list *,ldns_key_list *, #retvals: ldns_status def sign_nsec3(self,new_rrs,key_list,func,arg,algorithm,flags,iterations,salt_length,salt): """signs the given zone with the given new zone, with NSEC3 :param new_rrs: newly created resource records are added to this list, to free them later :param key_list: the list of keys to sign the zone with :param func: callback function that decides what to do with old signatures :param arg: optional argument for the callback function :param algorithm: the NSEC3 hashing algorithm to use :param flags: NSEC3 flags :param iterations: the number of NSEC3 hash iterations to use :param salt_length: the length (in octets) of the NSEC3 salt :param salt: the NSEC3 salt data :returns: (ldns_status) LDNS_STATUS_OK on success, an error code otherwise """ return _ldns.ldns_dnssec_zone_sign_nsec3(self,new_rrs,key_list,func,arg,algorithm,flags,iterations,salt_length,salt) #parameters: ldns_dnssec_zone *,ldns_rr_list *,ldns_key_list *,int(*)(ldns_rr *, void *),void *,uint8_t,uint8_t,uint16_t,uint8_t,uint8_t *, #retvals: ldns_status #LDNS_DNSSEC_ZONE_METHODS_# def add_empty_nonterminals(self): """Adds explicit dnssec_name structures for the empty nonterminals in this zone. (this is needed for NSEC3 generation) :returns: (ldns_status) """ return _ldns.ldns_dnssec_zone_add_empty_nonterminals(self) #parameters: ldns_dnssec_zone *, #retvals: ldns_status def add_rr(self,rr): """Adds the given RR to the zone. It find whether there is a dnssec_name with that name present. If so, add it to that, if not create a new one. Special handling of NSEC and RRSIG provided. :param rr: The RR to add :returns: (ldns_status) LDNS_STATUS_OK on success, an error code otherwise """ return _ldns.ldns_dnssec_zone_add_rr_(self,rr) #parameters: ldns_dnssec_zone *,ldns_rr *, #retvals: ldns_status def find_rrset(self,dname,atype): """Find the RRset with the given name and type in the zone. :param dname: the domain name of the RRset to find :param atype: :returns: (ldns_dnssec_rrsets \*) the RRset, or NULL if not present """ return _ldns.ldns_dnssec_zone_find_rrset(self,dname,atype) #parameters: ldns_dnssec_zone *,ldns_rdf *,ldns_rr_type, #retvals: ldns_dnssec_rrsets * #_LDNS_DNSSEC_ZONE_METHODS# %} } ldns-1.6.17/contrib/python/ldns_zone.i0000664000175100017510000002701312264060151017244 0ustar willemwillem/****************************************************************************** * ldns_zone.i: LDNS zone class * * Copyright (c) 2009, Zdenek Vasicek (vasicek AT fit.vutbr.cz) * Karel Slany (slany AT fit.vutbr.cz) * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * Redistributions of source code must retain the above copyright notice, * this list of conditions and the following disclaimer. * * Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * Neither the name of the organization nor the names of its * contributors may be used to endorse or promote products derived from this * software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. ******************************************************************************/ %typemap(in,numinputs=0,noblock=1) (ldns_zone **) { ldns_zone *$1_zone; $1 = &$1_zone; } /* result generation */ %typemap(argout,noblock=1) (ldns_zone **) { $result = SWIG_Python_AppendOutput($result, SWIG_NewPointerObj(SWIG_as_voidptr($1_zone), SWIGTYPE_p_ldns_struct_zone, SWIG_POINTER_OWN | 0 )); } %nodefaultctor ldns_struct_zone; //no default constructor & destructor %nodefaultdtor ldns_struct_zone; %newobject ldns_zone_new_frm_fp; %newobject ldns_zone_new_frm_fp_l; %newobject ldns_zone_new; %delobject ldns_zone_free; %delobject ldns_zone_deep_free; %delobject ldns_zone_push_rr; %delobject ldns_zone_push_rr_list; %ignore ldns_struct_zone::_soa; %ignore ldns_struct_zone::_rrs; %rename(ldns_zone) ldns_struct_zone; #ifdef LDNS_DEBUG %rename(__ldns_zone_free) ldns_zone_free; %rename(__ldns_zone_deep_free) ldns_zone_deep_free; %inline %{ void _ldns_zone_free (ldns_zone* z) { printf("******** LDNS_ZONE free 0x%lX ************\n", (long unsigned int)z); ldns_zone_deep_free(z); } %} #else %rename(__ldns_zone_free) ldns_zone_free; %rename(_ldns_zone_free) ldns_zone_deep_free; #endif %feature("docstring") ldns_struct_zone "Zone definitions **Usage** This class is able to read and parse the content of zone file by doing: >>> import ldns >>> zone = ldns.ldns_zone.new_frm_fp(open(\"zone.txt\",\"r\"), None, 0, ldns.LDNS_RR_CLASS_IN) >>> print zone.soa() example. 600 IN SOA example. admin.example. 2008022501 28800 7200 604800 18000 >>> print zone.rrs() example. 600 IN MX 10 mail.example. example. 600 IN NS ns1.example. example. 600 IN NS ns2.example. example. 600 IN A 192.168.1.1 The ``zone.txt`` file contains the following records:: $ORIGIN example. $TTL 600 example. IN SOA example. admin.example. ( 2008022501 ; serial 28800 ; refresh (8 hours) 7200 ; retry (2 hours) 604800 ; expire (1 week) 18000 ; minimum (5 hours) ) @ IN MX 10 mail.example. @ IN NS ns1 @ IN NS ns2 @ IN A 192.168.1.1 " %extend ldns_struct_zone { %pythoncode %{ def __init__(self): self.this = _ldns.ldns_zone_new() if not self.this: raise Exception("Can't create zone.") __swig_destroy__ = _ldns._ldns_zone_free def __str__(self): return str(self.soa()) + "\n" + str(self.rrs()) def print_to_file(self,output): """Prints the data in the zone to the given file stream (in presentation format).""" _ldns.ldns_zone_print(output,self) #parameters: FILE *,const ldns_zone *, #LDNS_ZONE_CONSTRUCTORS_# @staticmethod def new_frm_fp(file, origin, ttl, rr_class=_ldns.LDNS_RR_CLASS_IN, raiseException=True): """Creates a new zone object from given file pointer :param file: a file object :param origin: (ldns_rdf) the zones' origin :param ttl: default ttl to use :param rr_class: efault class to use (IN) :param raiseException: if True, an exception occurs in case a zone instance can't be created :returns: zone instance or None. If an instance can't be created and raiseException is True, an exception occurs. """ status, zone = _ldns.ldns_zone_new_frm_fp(file, origin, ttl, rr_class) if status != LDNS_STATUS_OK: if (raiseException): raise Exception("Can't create zone, error: %s (%d)" % (_ldns.ldns_get_errorstr_by_id(status),status)) return None return zone @staticmethod def new_frm_fp_l(file, origin, ttl, rr_class, raiseException=True): """Create a new zone from a file, keep track of the line numbering :param file: a file object :param origin: (ldns_rdf) the zones' origin :param ttl: default ttl to use :param rr_class: efault class to use (IN) :param raiseException: if True, an exception occurs in case a zone instance can't be created :returns: * zone - zone instance or None. If an instance can't be created and raiseException is True, an exception occurs. * line - used for error msg, to get to the line number """ status, zone = _ldns.ldns_zone_new_frm_fp_l(file, line) if status != LDNS_STATUS_OK: if (raiseException): raise Exception("Can't create zone, error: %d" % status) return None return zone #_LDNS_ZONE_CONSTRUCTORS# def sign(self,key_list): """Signs the zone, and returns a newly allocated signed zone. :param key_list: list of keys to sign with :returns: (ldns_zone \*) signed zone """ return _ldns.ldns_zone_sign(self,key_list) #parameters: const ldns_zone *,ldns_key_list *, #retvals: ldns_zone * def sign_nsec3(self,key_list,algorithm,flags,iterations,salt_length,salt): """Signs the zone with NSEC3, and returns a newly allocated signed zone. :param key_list: list of keys to sign with :param algorithm: the NSEC3 hashing algorithm to use :param flags: NSEC3 flags :param iterations: the number of NSEC3 hash iterations to use :param salt_length: the length (in octets) of the NSEC3 salt :param salt: the NSEC3 salt data :returns: (ldns_zone \*) signed zone """ return _ldns.ldns_zone_sign_nsec3(self,key_list,algorithm,flags,iterations,salt_length,salt) #parameters: ldns_zone *,ldns_key_list *,uint8_t,uint8_t,uint16_t,uint8_t,uint8_t *, #retvals: ldns_zone * #LDNS_ZONE_METHODS_# def glue_rr_list(self): """Retrieve all resource records from the zone that are glue records. The resulting list does are pointer references to the zone's data. Due to the current zone implementation (as a list of rr's), this function is extremely slow. Another (probably better) way to do this is to use an ldns_dnssec_zone structure and the mark_glue function :returns: (ldns_rr_list \*) the rr_list with the glue """ return _ldns.ldns_zone_glue_rr_list(self) #parameters: const ldns_zone *, #retvals: ldns_rr_list * def push_rr(self,rr): """push an single rr to a zone structure. This function use pointer copying, so the rr_list structure inside z is modified! :param rr: the rr to add :returns: (bool) a true on succes otherwise falsed """ return _ldns.ldns_zone_push_rr(self,rr) #parameters: ldns_zone *,ldns_rr *, #retvals: bool def push_rr_list(self,list): """push an rrlist to a zone structure. This function use pointer copying, so the rr_list structure inside z is modified! :param list: the list to add :returns: (bool) a true on succes otherwise falsed """ return _ldns.ldns_zone_push_rr_list(self,list) #parameters: ldns_zone *,ldns_rr_list *, #retvals: bool def rr_count(self): """Returns the number of resource records in the zone, NOT counting the SOA record. :returns: (size_t) the number of rr's in the zone """ return _ldns.ldns_zone_rr_count(self) #parameters: const ldns_zone *, #retvals: size_t def rrs(self): """Get a list of a zone's content. Note that the SOA isn't included in this list. You need to get the with ldns_zone_soa. :returns: (ldns_rr_list \*) the rrs from this zone """ return _ldns.ldns_zone_rrs(self) #parameters: const ldns_zone *, #retvals: ldns_rr_list * def set_rrs(self,rrlist): """Set the zone's contents. :param rrlist: the rrlist to use """ _ldns.ldns_zone_set_rrs(self,rrlist) #parameters: ldns_zone *,ldns_rr_list *, #retvals: def set_soa(self,soa): """Set the zone's soa record. :param soa: the soa to set """ _ldns.ldns_zone_set_soa(self,soa) #parameters: ldns_zone *,ldns_rr *, #retvals: def soa(self): """Return the soa record of a zone. :returns: (ldns_rr \*) the soa record in the zone """ return _ldns.ldns_zone_soa(self) #parameters: const ldns_zone *, #retvals: ldns_rr * def sort(self): """Sort the rrs in a zone, with the current impl. this is slow """ _ldns.ldns_zone_sort(self) #parameters: ldns_zone *, #retvals: #_LDNS_ZONE_METHODS# %} } ldns-1.6.17/contrib/python/ldns_dname.i0000664000175100017510000006572612264060151017372 0ustar willemwillem/****************************************************************************** * ldns_dname.i: LDNS domain name class * * Copyright (c) 2009, Zdenek Vasicek (vasicek AT fit.vutbr.cz) * Karel Slany (slany AT fit.vutbr.cz) * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * Redistributions of source code must retain the above copyright notice, * this list of conditions and the following disclaimer. * * Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * Neither the name of the organization nor the names of its * contributors may be used to endorse or promote products derived from * this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. *****************************************************************************/ /* ========================================================================= */ /* SWIG setting and definitions. */ /* ========================================================================= */ /* * Not here (with the exception of functions defined in this C code sction), * must be set in ldns_rdf.i. */ /* ========================================================================= */ /* Debugging related code. */ /* ========================================================================= */ /* * Not here (with the exception of functions defined in this C code sction), * must be set in ldns_rdf.i. */ /* ========================================================================= */ /* Added C code. */ /* ========================================================================= */ /* None */ /* ========================================================================= */ /* Encapsulating Python code. */ /* ========================================================================= */ %pythoncode %{ class ldns_dname(ldns_rdf): """ Domain name. This class contains methods to read and manipulate domain name drfs. Domain names are stored in :class:`ldns_rdf` structures, with the type LDNS_RDF_TYPE_DNAME. This class encapsulates such rdfs. **Usage** >>> import ldns >>> dn1 = ldns.ldns_dname("test.nic.cz") >>> print dn1 test.nic.cz. >>> dn2 = ldns.ldns_dname("nic.cz") >>> if dn2.is_subdomain(dn1): print dn2, "is sub-domain of", dn1 >>> if dn1.is_subdomain(dn2): print dn1, "is sub-domain of", dn2 test.nic.cz. is sub-domain of nic.cz. The following two examples show the creation of :class:`ldns_dname` from :class:`ldns_rdf`. The first shows the creation of :class:`ldns_dname` instance which is independent of the original `rdf`. >>> import ldns >>> rdf = ldns.ldns_rdf.new_frm_str("a.ns.nic.cz", ldns.LDNS_RDF_TYPE_DNAME) >>> dn = ldns.ldns_dname(rdf) >>> print dn a.ns.nic.cz. The latter shows the wrapping of a :class:`ldns_rdf` onto a :class:`ldns_dname` without the creation of a copy. >>> import ldns >>> dn = ldns.ldns_dname(ldns.ldns_rdf.new_frm_str("a.ns.nic.cz", ldns.LDNS_RDF_TYPE_DNAME), clone=False) >>> print dn a.ns.nic.cz. """ def __init__(self, initialiser, clone=True): """ Creates a new dname rdf from a string or :class:`ldns_rdf`. :param initialiser: string or :class:`ldns_rdf` :type initialiser: string or :class:`ldns_rdf` containing a dname :param clone: Whether to clone or directly grab the parameter. :type clone: bool :throws TypeError: When `initialiser` of invalid type. """ if isinstance(initialiser, ldns_rdf) and \ (initialiser.get_type() == _ldns.LDNS_RDF_TYPE_DNAME): if clone == True: self.this = _ldns.ldns_rdf_clone(initialiser) else: self.this = initialiser else: self.this = _ldns.ldns_dname_new_frm_str(initialiser) # # LDNS_DNAME_CONSTRUCTORS_ # @staticmethod def new_frm_str(string): """ Creates a new dname rdf instance from a string. This static method is equivalent to using default :class:`ldns_dname` constructor. :param string: String to use. :type string: string :throws TypeError: When `string` not a string. :return: (:class:`ldns_dname`) dname rdf. """ return ldns_dname(string) @staticmethod def new_frm_rdf(rdf, clone=True): """ Creates a new dname rdf instance from a dname :class:`ldns_rdf`. This static method is equivalent to using the default :class:`ldns_dname` constructor. :param rdf: A dname :class:`ldns_rdf`. :type rdf: :class:`ldns_rdf` :throws TypeError: When `rdf` of inappropriate type. :param clone: Whether to create a clone or to wrap present instance. :type clone: bool :return: (:class:`ldns_dname`) dname rdf. """ return ldns_dname(rdf, clone=clone) # # _LDNS_DNAME_CONSTRUCTORS # def write_to_buffer(self, buffer): """ Copies the dname data to the buffer in wire format. :param buffer: Buffer to append the result to. :type param: :class:`ldns_buffer` :throws TypeError: When `buffer` of non-:class:`ldns_buffer` type. :return: (ldns_status) ldns_status """ return _ldns.ldns_dname2buffer_wire(buffer, self) #parameters: ldns_buffer *, const ldns_rdf *, #retvals: ldns_status # # LDNS_DNAME_METHODS_ # def absolute(self): """ Checks whether the given dname string is absolute (i.e., ends with a '.'). :return: (bool) True or False """ string = self.__str__() return _ldns.ldns_dname_str_absolute(string) != 0 def make_canonical(self): """ Put a dname into canonical format (i.e., convert to lower case). """ _ldns.ldns_dname2canonical(self) def __cmp__(self, other): """ Compares two dname rdf according to the algorithm for ordering in RFC4034 Section 6. :param other: The second dname rdf to compare. :type other: :class:`ldns_dname` :throws TypeError: When `other` of invalid type. :return: (int) -1, 0 or 1 if self comes before other, self is equal or self comes after other respectively. .. note:: The type checking of parameter `other` is benevolent. It allows also to pass a dname :class:`ldns_rdf` object. This will probably change in future. """ # # The wrapped function generates asserts instead of setting # error status. They cannot be caught from Python so a check # is necessary. # if (not isinstance(other, ldns_dname)) and \ isinstance(other, ldns_rdf) and \ other.get_type() == _ldns.LDNS_RDF_TYPE_DNAME: warnings.warn("The ldns_dname.__cmp__() method will" + " drop the possibility to compare ldns_rdf." + " Convert arguments to ldns_dname.", PendingDeprecationWarning, stacklevel=2) if not isinstance(other, ldns_rdf): raise TypeError("Parameter must be derived from ldns_rdf.") if (other.get_type() != _ldns.LDNS_RDF_TYPE_DNAME): raise Exception("Operands must be ldns_dname.") return _ldns.ldns_dname_compare(self, other) def __lt__(self, other): """ Compares two dname rdf according to the algorithm for ordering in RFC4034 Section 6. :param other: The second dname rdf to compare. :type other: :class:`ldns_dname` :throws TypeError: When `other` of invalid type. :return: (bool) True when `self` is less than 'other'. .. note:: The type checking of parameter `other` is benevolent. It allows also to pass a dname :class:`ldns_rdf` object. This will probably change in future. """ # # The wrapped function generates asserts instead of setting # error status. They cannot be caught from Python so a check # is necessary. # if (not isinstance(other, ldns_dname)) and \ isinstance(other, ldns_rdf) and \ other.get_type() == _ldns.LDNS_RDF_TYPE_DNAME: warnings.warn("The ldns_dname.__lt__() method will" + " drop the possibility to compare ldns_rdf." + " Convert arguments to ldns_dname.", PendingDeprecationWarning, stacklevel=2) if not isinstance(other, ldns_rdf): raise TypeError("Parameter must be derived from ldns_rdf.") if (other.get_type() != _ldns.LDNS_RDF_TYPE_DNAME): raise Exception("Operands must be ldns_dname.") return _ldns.ldns_dname_compare(self, other) == -1 def __le__(self, other): """ Compares two dname rdf according to the algorithm for ordering in RFC4034 Section 6. :param other: The second dname rdf to compare. :type other: :class:`ldns_dname` :throws TypeError: When `other` of invalid type. :return: (bool) True when `self` is less than or equal to 'other'. .. note:: The type checking of parameter `other` is benevolent. It allows also to pass a dname :class:`ldns_rdf` object. This will probably change in future. """ # # The wrapped function generates asserts instead of setting # error status. They cannot be caught from Python so a check # is necessary. # if (not isinstance(other, ldns_dname)) and \ isinstance(other, ldns_rdf) and \ other.get_type() == _ldns.LDNS_RDF_TYPE_DNAME: warnings.warn("The ldns_dname.__le__() method will" + " drop the possibility to compare ldns_rdf." + " Convert arguments to ldns_dname.", PendingDeprecationWarning, stacklevel=2) if not isinstance(other, ldns_rdf): raise TypeError("Parameter must be derived from ldns_rdf.") if (other.get_type() != _ldns.LDNS_RDF_TYPE_DNAME): raise Exception("Operands must be ldns_dname.") return _ldns.ldns_dname_compare(self, other) != 1 def __eq__(self, other): """ Compares two dname rdf according to the algorithm for ordering in RFC4034 Section 6. :param other: The second dname rdf to compare. :type other: :class:`ldns_dname` :throws TypeError: When `other` of invalid type. :return: (bool) True when `self` is equal to 'other'. .. note:: The type checking of parameter `other` is benevolent. It allows also to pass a dname :class:`ldns_rdf` object. This will probably change in future. """ # # The wrapped function generates asserts instead of setting # error status. They cannot be caught from Python so a check # is necessary. # if (not isinstance(other, ldns_dname)) and \ isinstance(other, ldns_rdf) and \ other.get_type() == _ldns.LDNS_RDF_TYPE_DNAME: warnings.warn("The ldns_dname.__eq__() method will" + " drop the possibility to compare ldns_rdf." + " Convert arguments to ldns_dname.", PendingDeprecationWarning, stacklevel=2) if not isinstance(other, ldns_rdf): raise TypeError("Parameter must be derived from ldns_rdf.") if (other.get_type() != _ldns.LDNS_RDF_TYPE_DNAME): raise Exception("Operands must be ldns_dname.") return _ldns.ldns_dname_compare(self, other) == 0 def __ne__(self, other): """ Compares two dname rdf according to the algorithm for ordering in RFC4034 Section 6. :param other: The second dname rdf to compare. :type other: :class:`ldns_dname` :throws TypeError: When `other` of invalid type. :return: (bool) True when `self` is not equal to 'other'. .. note:: The type checking of parameter `other` is benevolent. It allows also to pass a dname :class:`ldns_rdf` object. This will probably change in future. """ # # The wrapped function generates asserts instead of setting # error status. They cannot be caught from Python so a check # is necessary. # if (not isinstance(other, ldns_dname)) and \ isinstance(other, ldns_rdf) and \ other.get_type() == _ldns.LDNS_RDF_TYPE_DNAME: warnings.warn("The ldns_dname.__ne__() method will" + " drop the possibility to compare ldns_rdf." + " Convert arguments to ldns_dname.", PendingDeprecationWarning, stacklevel=2) if not isinstance(other, ldns_rdf): raise TypeError("Parameter must be derived from ldns_rdf.") if (other.get_type() != _ldns.LDNS_RDF_TYPE_DNAME): raise Exception("Operands must be ldns_dname.") return _ldns.ldns_dname_compare(self, other) != 0 def __gt__(self, other): """ Compares two dname rdf according to the algorithm for ordering in RFC4034 Section 6. :param other: The second dname rdf to compare. :type other: :class:`ldns_dname` :throws TypeError: When `other` of invalid type. :return: (bool) True when `self` is greater than 'other'. .. note:: The type checking of parameter `other` is benevolent. It allows also to pass a dname :class:`ldns_rdf` object. This will probably change in future. """ # # The wrapped function generates asserts instead of setting # error status. They cannot be caught from Python so a check # is necessary. # if (not isinstance(other, ldns_dname)) and \ isinstance(other, ldns_rdf) and \ other.get_type() == _ldns.LDNS_RDF_TYPE_DNAME: warnings.warn("The ldns_dname.__gt__() method will" + " drop the possibility to compare ldns_rdf." + " Convert arguments to ldns_dname.", PendingDeprecationWarning, stacklevel=2) if not isinstance(other, ldns_rdf): raise TypeError("Parameter must be derived from ldns_rdf.") if (other.get_type() != _ldns.LDNS_RDF_TYPE_DNAME): raise Exception("Operands must be ldns_dname.") return _ldns.ldns_dname_compare(self, other) == 1 def __ge__(self, other): """ Compares two dname rdf according to the algorithm for ordering in RFC4034 Section 6. :param other: The second dname rdf to compare. :type other: :class:`ldns_dname` :throws TypeError: When `other` of invalid type. :return: (bool) True when `self` is greater than or equal to 'other'. .. note:: The type checking of parameter `other` is benevolent. It allows also to pass a dname :class:`ldns_rdf` object. This will probably change in future. """ # # The wrapped function generates asserts instead of setting # error status. They cannot be caught from Python so a check # is necessary. # if (not isinstance(other, ldns_dname)) and \ isinstance(other, ldns_rdf) and \ other.get_type() == _ldns.LDNS_RDF_TYPE_DNAME: warnings.warn("The ldns_dname.__ge__() method will" + " drop the possibility to compare ldns_rdf." + " Convert arguments to ldns_dname.", PendingDeprecationWarning, stacklevel=2) if not isinstance(other, ldns_rdf): raise TypeError("Parameter must be derived from ldns_rdf.") if (other.get_type() != _ldns.LDNS_RDF_TYPE_DNAME): raise Exception("Operands must be ldns_dname.") return _ldns.ldns_dname_compare(self, other) != -1 def cat(self, rd2): """ Concatenates rd2 after this dname (`rd2` is copied, `this` dname is modified). :param rd2: The right-hand side. :type rd2: :class:`ldns_dname` :throws TypeError: When `rd2` of invalid type. :return: (ldns_status) LDNS_STATUS_OK on success .. note:: The type checking of parameter `rd2` is benevolent. It allows also to pass a dname :class:`ldns_rdf` object. This will probably change in future. """ if (not isinstance(rd2, ldns_dname)) and \ isinstance(rd2, ldns_rdf) and \ rd2.get_type() == _ldns.LDNS_RDF_TYPE_DNAME: warnings.warn("The ldns_dname.cat() method will" + " drop the support of ldns_rdf." + " Convert arguments to ldns_dname.", PendingDeprecationWarning, stacklevel=2) return _ldns.ldns_dname_cat(self, rd2) #parameters: ldns_rdf *, ldns_rdf *, #retvals: ldns_status def cat_clone(self, rd2): """ Concatenates two dnames together. :param rd2: The right-hand side. :type rd2: :class:`ldns_dname` :throws TypeError: When `rd2` of invalid type. :return: (:class:`ldns_dname`) A new rdf with left-hand side + right-hand side content None when error. .. note:: The type checking of parameter `rd2` is benevolent. It allows also to pass a dname :class:`ldns_rdf` object. This will probably change in future. """ if (not isinstance(rd2, ldns_dname)) and \ isinstance(rd2, ldns_rdf) and \ rd2.get_type() == _ldns.LDNS_RDF_TYPE_DNAME: warnings.warn("The ldns_dname.cat_clone() method will" + " drop the support of ldns_rdf." + " Convert arguments to ldns_dname.", PendingDeprecationWarning, stacklevel=2) ret = _ldns.ldns_dname_cat_clone(self, rd2) if ret != None: ret = ldns_dname(ret, clone=False) return ret #parameters: const ldns_rdf *, const ldns_rdf *, #retvals: ldns_rdf * def interval(self, middle, next): """ Check whether `middle` lays in the interval defined by `this` and `next` (`this` <= `middle` < `next`). This method is useful for nsec checking. :param middle: The dname to check. :type middle: :class:`ldns_dname` :param next: The boundary. :type next: :class:`ldns_dname` :throws TypeError: When `middle` or `next` of non-:class:`ldns_rdf` type. :throws Exception: When non-dname rdfs compared. :return: (int) 0 on error or unknown, -1 when middle is in the interval, 1 when not. .. note:: The type checking of parameters is benevolent. It allows also to pass a dname :class:`ldns_rdf` object. This will probably change in future. """ # # The wrapped function generates asserts instead of setting # error status. They cannot be caught from Python so a check # is necessary. # if (not isinstance(middle, ldns_rdf)) or \ (not isinstance(next, ldns_rdf)): raise TypeError("Parameters must be derived from ldns_dname.") if (self.get_type() != _ldns.LDNS_RDF_TYPE_DNAME) or \ (middle.get_type() != _ldns.LDNS_RDF_TYPE_DNAME) or \ (next.get_type() != _ldns.LDNS_RDF_TYPE_DNAME): raise Exception("All operands must be dname rdfs.") if (not isinstance(middle, ldns_dname)) or \ (not isinstance(next, ldns_dname)): warnings.warn("The ldns_dname.interval() method will" + " drop the possibility to compare ldns_rdf." + " Convert arguments to ldns_dname.", PendingDeprecationWarning, stacklevel=2) return _ldns.ldns_dname_interval(self, middle, next) #parameters: const ldns_rdf *, const ldns_rdf *, const ldns_rdf *, #retvals: int def is_subdomain(self, parent): """ Tests whether the name of the instance falls under `parent` (i.e., is a sub-domain of `parent`). This function will return false if the given dnames are equal. :param parent: The parent's name. :type parent: :class:`ldns_dname` :throws TypeError: When `parent` of non-:class:`ldns_rdf` or derived type. :return: (bool) True if `this` falls under `parent`, otherwise False. .. note:: The type checking of parameters is benevolent. It allows also to pass a dname :class:`ldns_rdf` object. This will probably change in future. """ if (not isinstance(parent, ldns_dname)) and \ isinstance(parent, ldns_rdf) and \ parent.get_type() == _ldns.LDNS_RDF_TYPE_DNAME: warnings.warn("The ldns_dname.is_subdomain() method will" + " drop the support of ldns_rdf." + " Convert arguments to ldns_dname.", PendingDeprecationWarning, stacklevel=2) return _ldns.ldns_dname_is_subdomain(self, parent) #parameters: const ldns_rdf *, const ldns_rdf *, #retvals: bool def label(self, labelpos): """ Look inside the rdf and retrieve a specific label. The labels are numbered starting from 0 (left most). :param labelpos: Index of the label. (Labels are numbered 0, which is the left most.) :type labelpos: integer :throws TypeError: When `labelpos` of non-integer type. :return: (:class:`ldns_dname`) A new rdf with the label as name or None on error. """ ret = _ldns.ldns_dname_label(self, labelpos) if ret != None: ret = ldns_dname(ret, clone=False) return ret #parameters: const ldns_rdf *, uint8_t, #retvals: ldns_rdf * def label_count(self): """ Counts the number of labels. :return: (uint8_t) the number of labels. Will return 0 if not a dname. """ return _ldns.ldns_dname_label_count(self) #parameters: const ldns_rdf *, #retvals: uint8_t def left_chop(self): """ Chop one label off the left side of a dname. (e.g., wwww.nlnetlabs.nl, becomes nlnetlabs.nl) :return: (:class:`ldns_dname`) The remaining dname or None when error. """ return ldns_dname(_ldns.ldns_dname_left_chop(self), clone=False) #parameters: const ldns_rdf *, #retvals: ldns_rdf * def reverse(self): """ Returns a clone of the given dname with the labels reversed. :return: (:class:`ldns_dname`) A clone of the dname with the labels reversed. """ return ldns_dname(_ldns.ldns_dname_reverse(self), clone=False) #parameters: const ldns_rdf *, #retvals: ldns_rdf * # # _LDNS_DNAME_METHODS # %} ldns-1.6.17/contrib/python/Makefile0000664000175100017510000001132112264060151016532 0ustar willemwillem# Makefile: compilation of sources and documentation, test environment # # Copyright (c) 2009, Zdenek Vasicek (vasicek AT fit.vutbr.cz) # Karel Slany (slany AT fit.vutbr.cz) # All rights reserved. # # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions are met: # # * Redistributions of source code must retain the above copyright notice, # this list of conditions and the following disclaimer. # * Redistributions in binary form must reproduce the above copyright # notice, this list of conditions and the following disclaimer in the # documentation and/or other materials provided with the distribution. # * Neither the name of the organization nor the names of its # contributors may be used to endorse or promote products derived from this # software without specific prior written permission. # # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" # AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE # IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE # ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE # LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR # CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF # SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS # INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN # CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) # ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE # POSSIBILITY OF SUCH DAMAGE. .PHONY: help clean testenv test doc te bw bw3 sw sw3 help: @echo "Please use \`make ' where is one of" @echo " testenv to make test environment and run bash " @echo " usefull in case you don't want to install ldns but want to test examples" @echo " doc to make documentation" @echo " clean clean all" ../../Makefile: ../../configure cd ../.. && ./configure --with-python _ldns.so: ../../Makefile $(MAKE) -C ../.. ../../.libs/libldns.so.1: ../../Makefile $(MAKE) -C ../.. clean: rm -rf examples/ldns rm -f _ldns.so ldns_wrapper.o $(MAKE) -C ../.. clean testenv: ../../.libs/libldns.so.1 _ldns.so rm -rf examples/ldns cd examples && mkdir ldns && ln -s ../../ldns.py ldns/__init__.py && ln -s ../../../../.libs/_ldns.so ldns/_ldns.so && ln -s ../../../../.libs/libldns.so.1 ldns/libldns.so.1 && ls -la @echo "Run a script by typing ./script_name.py" cd examples && LD_LIBRARY_PATH=ldns bash rm -rf examples/ldns test: ../../.libs/libldns.so.1 _ldns.so examples/test_buffer.py examples/test_rdf.py examples/test_dname.py examples/test_rr.py examples/test_pkt.py examples/test_resolver.py @rm -rf examples/ldns @cd examples && mkdir ldns && ln -s ../../ldns.py ldns/__init__.py && ln -s ../../../../.libs/_ldns.so ldns/_ldns.so && ln -s ../../../../.libs/libldns.so.1 ldns/libldns.so.1 @cd examples && LD_LIBRARY_PATH=ldns ./test_buffer.py 2>/dev/null @cd examples && LD_LIBRARY_PATH=ldns ./test_rdf.py 2>/dev/null @cd examples && LD_LIBRARY_PATH=ldns ./test_dname.py 2>/dev/null @cd examples && LD_LIBRARY_PATH=ldns ./test_rr.py 2>/dev/null @cd examples && LD_LIBRARY_PATH=ldns ./test_pkt.py 2>/dev/null @cd examples && LD_LIBRARY_PATH=ldns ./test_resolver.py 2>/dev/null @rm -rf examples/ldns doc: ../../.libs/libldns.so.1 _ldns.so echo @VERSION_MAJOR@ rm -f _ldns.so ln -s ../../.libs/_ldns.so $(MAKE) -C docs html rm -f _ldns.so # For development only: # Test environment, does not build the wrapper from dependencies. te: rm -rf examples/ldns cd examples && mkdir ldns && ln -s ../../ldns.py ldns/__init__.py && ln -s ../../../../.libs/_ldns.so ldns/_ldns.so && ln -s ../../../../.libs/libldns.so.1 ldns/libldns.so.1 && ls -la @echo "Run a script by typing ./script_name.py" cd examples && LD_LIBRARY_PATH=ldns bash rm -rf examples/ldns # Builds Python 2 wrapper from present wrapper C code. bw: gcc -c ldns_wrapper.c -O9 -fPIC -I../.. -I../../ldns -I/usr/include/python2.7 -I. -o ldns_wrapper.o mkdir -p ../../.libs ld -shared ldns_wrapper.o -L../../.libs -lldns -o ../../.libs/_ldns.so # Builds Python 3 wrapper from present wrapper C code. bw3: gcc -c ldns_wrapper.c -O9 -fPIC -I../.. -I../../ldns -I/usr/include/python3.2 -I. -o ldns_wrapper.o mkdir -p ../../.libs ld -shared ldns_wrapper.o -L../../.libs -ldns -o ../../.libs/_ldns.so # Builds Python 2 wrapper from interface file. sw: ldns.i swig -python -o ldns_wrapper.c -I../.. ldns.i $(MAKE) bw # Builds Python 3 wrapper from interface file. sw3: ldns.i swig -python -py3 -DPY3 -o ldns_wrapper.c -I../.. ldns.i $(MAKE) bw3 ldns-1.6.17/contrib/python/ldns_buffer.i0000664000175100017510000006266412264060151017555 0ustar willemwillem/****************************************************************************** * ldns_buffer.i: LDNS buffer class * * Copyright (c) 2009, Zdenek Vasicek (vasicek AT fit.vutbr.cz) * Karel Slany (slany AT fit.vutbr.cz) * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * Redistributions of source code must retain the above copyright notice, * this list of conditions and the following disclaimer. * * Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * Neither the name of the organization nor the names of its * contributors may be used to endorse or promote products derived from * this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. *****************************************************************************/ /* ========================================================================= */ /* SWIG setting and definitions. */ /* ========================================================================= */ /* Creates a temporary instance of (ldns_buffer *). */ %typemap(in, numinputs=0, noblock=1) (ldns_buffer **) { ldns_buffer *$1_buf; $1 = &$1_buf; } /* Result generation, appends (ldns_buffer *) after the result. */ %typemap(argout, noblock=1) (ldns_buffer **) { $result = SWIG_Python_AppendOutput($result, SWIG_NewPointerObj(SWIG_as_voidptr($1_buf), SWIGTYPE_p_ldns_struct_buffer, SWIG_POINTER_OWN | 0)); } /* * Limit the number of arguments to 2 and deal with variable * number of arguments in the Python way. */ %varargs(2, char *arg = NULL) ldns_buffer_printf; %nodefaultctor ldns_struct_buffer; /* No default constructor. */ %nodefaultdtor ldns_struct_buffer; /* No default destructor. */ %newobject ldns_buffer_new; %newobject ldns_dname_new_frm_data; %delobject ldns_buffer_free; %rename(ldns_buffer) ldns_struct_buffer; %ignore ldns_struct_buffer::_position; %ignore ldns_struct_buffer::_limit; %ignore ldns_struct_buffer::_capacity; %ignore ldns_struct_buffer::_data; %ignore ldns_struct_buffer::_fixed; %ignore ldns_struct_buffer::_status; %ignore ldns_buffer_new_frm_data; /* ========================================================================= */ /* Debugging related code. */ /* ========================================================================= */ #ifdef LDNS_DEBUG %rename(__ldns_buffer_free) ldns_buffer_free; %inline %{ /*! * @brief Frees the buffer and print a message. */ void _ldns_buffer_free (ldns_buffer* b) { printf("******** LDNS_BUFFER free 0x%lX ************\n", (long unsigned int) b); ldns_buffer_free(b); } %} #else /* !LDNS_DEBUG */ %rename(_ldns_buffer_free) ldns_buffer_free; #endif /* LDNS_DEBUG */ /* ========================================================================= */ /* Added C code. */ /* ========================================================================= */ /* None. */ /* ========================================================================= */ /* Encapsulating Python code. */ /* ========================================================================= */ %feature("docstring") "LDNS buffer." %extend ldns_struct_buffer { %pythoncode %{ def __init__(self, capacity): """ Creates a new buffer with the specified capacity. :param capacity: Number of bytes to allocate for the buffer. :type capacity: integer :throws TypeError: When `capacity` of non-integer type. :return: (:class:`ldns_buffer`) """ self.this = _ldns.ldns_buffer_new(capacity) __swig_destroy__ = _ldns._ldns_buffer_free def __str__(self): """ Returns the data in the buffer as a string. Buffer data must be char * type. :return: string """ return _ldns.ldns_buffer2str(self) def getc(self): """ Returns the next character from a buffer. Advances the position pointer with 1. When end of buffer is reached returns EOF. This is the buffer's equivalent for getc(). :return: (integer) EOF on failure otherwise return the character. """ return _ldns.ldns_bgetc(self) # # LDNS_BUFFER_METHODS_ # def at(self, at): """ Returns a pointer to the data at the indicated position. :param at: position :type at: positive integer :throws TypeError: When `at` of non-integer type. :return: (uint8_t \*) The pointer to the data. """ return _ldns.ldns_buffer_at(self, at) #parameters: const ldns_buffer *, size_t, #retvals: uint8_t * def available(self, count): """ Checks whether the buffer has count bytes available at the current position. :param count: How much is available. :type count: integer :throws TypeError: When `count` of non-integer type. :return: (bool) True or False. """ return _ldns.ldns_buffer_available(self, count) != 0 #parameters: ldns_buffer *, size_t, #retvals: int def available_at(self, at, count): """ Checks if the buffer has at least `count` more bytes available. Before reading or writing the caller needs to ensure that enough space is available! :param at: Indicated position. :type at: positive integer :param count: How much is available. :type count: positive integer :throws TypeError: When `at` or `count` of non-integer type. :return: (bool) True or False. """ return _ldns.ldns_buffer_available_at(self, at, count) != 0 #parameters: ldns_buffer *,size_t,size_t, #retvals: int def begin(self): """ Returns a pointer to the beginning of the buffer (the data at position 0). :return: (uint8_t \*) Pointer. """ return _ldns.ldns_buffer_begin(self) #parameters: const ldns_buffer *, #retvals: uint8_t * def capacity(self): """ Returns the number of bytes the buffer can hold. :return: (size_t) The number of bytes. """ return _ldns.ldns_buffer_capacity(self) #parameters: ldns_buffer *, #retvals: size_t def clear(self): """ Clears the buffer and make it ready for writing. The buffer's limit is set to the capacity and the position is set to 0. """ _ldns.ldns_buffer_clear(self) #parameters: ldns_buffer *, #retvals: def copy(self, bfrom): """ Copy contents of the other buffer to this buffer. Silently truncated if this buffer is too small. :param bfrom: Source buffer. :type bfrom: :class:`ldns_buffer` :throws TypeError: When `bfrom` of non-:class:`ldns_buffer` type. """ _ldns.ldns_buffer_copy(self, bfrom) #parameters: ldns_buffer *, ldns_buffer *, #retvals: def current(self): """ Returns a pointer to the data at the buffer's current position. :return: (uint8_t \*) A pointer. """ return _ldns.ldns_buffer_current(self) #parameters: ldns_buffer *, #retvals: uint8_t * def end(self): """ Returns a pointer to the end of the buffer (the data at the buffer's limit). :return: (uint8_t \*) Pointer. """ return _ldns.ldns_buffer_end(self) #parameters: ldns_buffer *, #retvals: uint8_t * def export(self): """ Makes the buffer fixed and returns a pointer to the data. The caller is responsible for freeing the result. :return: (void \*) Void pointer. """ return _ldns.ldns_buffer_export(self) #parameters: ldns_buffer *, #retvals: void * def flip(self): """ Makes the buffer ready for reading the data that has been written to the buffer. The buffer's limit is set to the current position and the position is set to 0. """ _ldns.ldns_buffer_flip(self) #parameters: ldns_buffer *, def invariant(self): """ Performs no action. In debugging mode this method performs a buffer settings check. It asserts if something is wrong. """ _ldns.ldns_buffer_invariant(self) #parameters: ldns_buffer *, def limit(self): """ Returns the maximum size of the buffer. :return: (size_t) The size. """ return _ldns.ldns_buffer_limit(self) #parameters: ldns_buffer *, #retvals: size_t def position(self): """ Returns the current position in the buffer (as a number of bytes). :return: (size_t) The current position. """ return _ldns.ldns_buffer_position(self) #parameters: ldns_buffer *, #retvals: size_t def printf(self, string, *args): """ Prints to the buffer, increasing the capacity if required using buffer_reserve(). The buffer's position is set to the terminating '\0'. Returns the number of characters written (not including the terminating '\0') or -1 on failure. :param string: A string to be written. :type string: string :throws: TypeError when `string` not a string. :return: (int) Number of written characters or -1 on failure. """ data = string % args return _ldns.ldns_buffer_printf(self, data) #parameters: ldns_buffer *, const char *, ... #retvals: int def read(self, data, count): """ Copies count bytes of data at the current position to the given `data`-array :param data: Target buffer to copy to. :type data: void \* :param count: The length of the data to copy. :type count: size_t """ _ldns.ldns_buffer_read(self,data,count) #parameters: ldns_buffer *, void *, size_t, #retvals: def read_at(self, at, data, count): """ Copies count bytes of data at the given position to the given `data`-array. :param at: The position in the buffer to start reading. :type at: size_t :param data: Target buffer to copy to. :type data: void \* :param count: The length of the data to copy. :type count: size_t """ _ldns.ldns_buffer_read_at(self,at,data,count) #parameters: ldns_buffer *, size_t, void *, size_t, #retvals: def read_u16(self): """ Returns the 2-byte integer value at the current position from the buffer. :return: (uint16_t) Word. """ return _ldns.ldns_buffer_read_u16(self) #parameters: ldns_buffer *, #retvals: uint16_t def read_u16_at(self, at): """ Returns the 2-byte integer value at the given position from the buffer. :param at: Position in the buffer. :type at: positive integer :throws TypeError: When `at` of non-integer type. :return: (uint16_t) Word. """ return _ldns.ldns_buffer_read_u16_at(self, at) #parameters: ldns_buffer *, size_t, #retvals: uint16_t def read_u32(self): """ Returns the 4-byte integer value at the current position from the buffer. :return: (uint32_t) Double-word. """ return _ldns.ldns_buffer_read_u32(self) #parameters: ldns_buffer *, #retvals: uint32_t def read_u32_at(self, at): """ Returns the 4-byte integer value at the given position from the buffer. :param at: Position in the buffer. :type at: positive integer :throws TypeError: When `at` of non-integer type. :return: (uint32_t) Double-word. """ return _ldns.ldns_buffer_read_u32_at(self, at) #parameters: ldns_buffer *, size_t, #retvals: uint32_t def read_u8(self): """ Returns the byte value at the current position from the buffer. :return: (uint8_t) A byte (not a character). """ return _ldns.ldns_buffer_read_u8(self) #parameters: ldns_buffer *, #retvals: uint8_t def read_u8_at(self, at): """ Returns the byte value at the given position from the buffer. :param at: The position in the buffer. :type at: positive integer :throws TypeError: When `at` of non-integer type. :return: (uint8_t) Byte value. """ return _ldns.ldns_buffer_read_u8_at(self, at) #parameters: ldns_buffer *, size_t, #retvals: uint8_t def remaining(self): """ Returns the number of bytes remaining between the buffer's position and limit. :return: (size_t) The number of bytes. """ return _ldns.ldns_buffer_remaining(self) #parameters: ldns_buffer *, #retvals: size_t def remaining_at(self, at): """ Returns the number of bytes remaining between the indicated position and the limit. :param at: Indicated position. :type at: positive integer :throws TypeError: When `at` of non-integer type. :return: (size_t) number of bytes """ return _ldns.ldns_buffer_remaining_at(self, at) #parameters: ldns_buffer *,size_t, #retvals: size_t def reserve(self, amount): """ Ensures that the buffer can contain at least `amount` more bytes. The buffer's capacity is increased if necessary using buffer_set_capacity(). The buffer's limit is always set to the (possibly increased) capacity. :param amount: Amount to use. :type amount: positive integer :throws TypeError: When `amount` of non-integer type. :return: (bool) hether this failed or succeeded. """ return _ldns.ldns_buffer_reserve(self, amount) #parameters: ldns_buffer *, size_t, #retvals: bool def rewind(self): """ Make the buffer ready for re-reading the data. The buffer's position is reset to 0. """ _ldns.ldns_buffer_rewind(self) #parameters: ldns_buffer *, #retvals: def set_capacity(self, capacity): """ Changes the buffer's capacity. The data is reallocated so any pointers to the data may become invalid. The buffer's limit is set to the buffer's new capacity. :param capacity: The capacity to use. :type capacity: positive integer :throws TypeError: When `capacity` of non-integer type. :return: (bool) whether this failed or succeeded """ return _ldns.ldns_buffer_set_capacity(self, capacity) #parameters: ldns_buffer *, size_t, #retvals: bool def set_limit(self, limit): """ Changes the buffer's limit. If the buffer's position is greater than the new limit then the position is set to the limit. :param limit: The new limit. :type limit: positive integer :throws TypeError: When `limit` of non-integer type. """ _ldns.ldns_buffer_set_limit(self, limit) #parameters: ldns_buffer *, size_t, #retvals: def set_position(self,mark): """ Sets the buffer's position to `mark`. The position must be less than or equal to the buffer's limit. :param mark: The mark to use. :type mark: positive integer :throws TypeError: When `mark` of non-integer type. """ _ldns.ldns_buffer_set_position(self,mark) #parameters: ldns_buffer *,size_t, #retvals: def skip(self, count): """ Changes the buffer's position by `count` bytes. The position must not be moved behind the buffer's limit or before the beginning of the buffer. :param count: The count to use. :type count: integer :throws TypeError: When `count` of non-integer type. """ _ldns.ldns_buffer_skip(self, count) #parameters: ldns_buffer *, ssize_t, #retvals: def status(self): """ Returns the status of the buffer. :return: (ldns_status) The status. """ return _ldns.ldns_buffer_status(self) #parameters: ldns_buffer *, #retvals: ldns_status def status_ok(self): """ Returns True if the status of the buffer is LDNS_STATUS_OK, False otherwise. :return: (bool) True or False. """ return _ldns.ldns_buffer_status_ok(self) #parameters: ldns_buffer *, #retvals: bool def write(self, data, count): """ Writes count bytes of data to the current position of the buffer. :param data: The data to write. :type data: void \* :param count: The length of the data to write. :type count: size_t """ _ldns.ldns_buffer_write(self, data, count) #parameters: ldns_buffer *, const void *, size_t, #retvals: def write_at(self, at, data, count): """ Writes the given data to the buffer at the specified position by `at`. :param at: The position (in number of bytes) to write the data at. :param data: Pointer to the data to write to the buffer. :param count: The number of bytes of data to write. """ _ldns.ldns_buffer_write_at(self, at, data, count) #parameters: ldns_buffer *, size_t, const void *, size_t, #retvals: def write_string(self, string): """ Copies the given (null-delimited) string to the current position into the buffer. :param string: The string to write. :type string: string :throws TypeError: When `string` not a string. """ _ldns.ldns_buffer_write_string(self,string) #parameters: ldns_buffer *,const char *, #retvals: def write_string_at(self, at, string): """ Copies the given (null-delimited) string to the specified position `at` into the buffer. :param at: The position in the buffer. :type at: positive integer :param string: The string to write. :type string: string :throws TypeError: When types mismatch. """ _ldns.ldns_buffer_write_string_at(self, at, string) #parameters: ldns_buffer *, size_t, const char *, #retvals: def write_u16(self, data): """Writes the given 2 byte integer at the current position in the buffer. :param data: The word to write. :type data: uint16_t :throws TypeError: When `data` of non-integer type. """ _ldns.ldns_buffer_write_u16(self, data) #parameters: ldns_buffer *, uint16_t, #retvals: def write_u16_at(self, at, data): """ Writes the given 2 byte integer at the given position in the buffer. :param at: The position in the buffer. :type at: positive integer :param data: The word to write. :type data: uint16_t :throws TypeError: When `at` or `data` of non-integer type. """ _ldns.ldns_buffer_write_u16_at(self,at,data) #parameters: ldns_buffer *,size_t,uint16_t, #retvals: def write_u32(self, data): """ Writes the given 4 byte integer at the current position in the buffer. :param data: The double-word to write. :type data: uint32_t :throws TypeError: When `data` of non-integer type. """ _ldns.ldns_buffer_write_u32(self, data) #parameters: ldns_buffer *, uint32_t, #retvals: def write_u32_at(self, at, data): """ Writes the given 4 byte integer at the given position in the buffer. :param at: The position in the buffer. :type at: positive integer :param data: The double-word to write. :type data: uint32_t :throws TypeError: When `at` or `data` of non-integer type. """ _ldns.ldns_buffer_write_u32_at(self, at, data) #parameters: ldns_buffer *,size_t,uint32_t, #retvals: def write_u8(self, data): """ Writes the given byte of data at the current position in the buffer. :param data: The byte to write. :type data: uint8_t :throws TypeError: When `data` of non-integer type. """ _ldns.ldns_buffer_write_u8(self, data) #parameters: ldns_buffer *, uint8_t, #retvals: def write_u8_at(self,at,data): """ Writes the given byte of data at the given position in the buffer. :param at: The position in the buffer. :type at: positive integer :param data: The byte to write. :type data: uint8_t :throws TypeError: When `at` or `data` of non-integer type. """ _ldns.ldns_buffer_write_u8_at(self,at,data) #parameters: ldns_buffer *,size_t,uint8_t, #retvals: # # _LDNS_BUFFER_METHODS # %} } ldns-1.6.17/contrib/python/examples/0000775000175100017510000000000012264060151016712 5ustar willemwillemldns-1.6.17/contrib/python/examples/ldns-newpkt.py0000775000175100017510000000073212264060151021537 0ustar willemwillem#!/usr/bin/python import ldns pkt = ldns.ldns_pkt.new_query_frm_str("www.google.com",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_QR | ldns.LDNS_AA) rra = ldns.ldns_rr.new_frm_str("www.google.com. IN A 192.168.1.1",300) rrb = ldns.ldns_rr.new_frm_str("www.google.com. IN TXT Some\ Description",300) list = ldns.ldns_rr_list() if (rra): list.push_rr(rra) if (rrb): list.push_rr(rrb) pkt.push_rr_list(ldns.LDNS_SECTION_ANSWER, list) print "Packet:" print pkt ldns-1.6.17/contrib/python/examples/test_dname.py0000775000175100017510000002560212264060151021417 0ustar willemwillem#!/usr/bin/env python # # ldns_dname testing script. # # Do not use constructs that differ between Python 2 and 3. # Use write on stdout or stderr. # import ldns import sys import os import inspect class_name = "ldns_dname" method_name = None error_detected = False temp_fname = "tmp_dname.txt" def set_error(): """ Writes an error message and sets error flag. """ global class_name global method_name global error_detected error_detected = True sys.stderr.write("(line %d): malfunctioning method %s.\n" % \ (inspect.currentframe().f_back.f_lineno, method_name)) #if not error_detected: if True: method_name = class_name + ".__init__()" rdf1 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "test.nic.cz.") rdf2 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_A, "217.31.205.50") try: dname = ldns.ldns_dname("www.nic.cz.") if not isinstance(dname, ldns.ldns_dname): set_error() except: set_error() # # Error when printing a dname wich was created fron an empty string. # Must find out why. # try: dname = ldns.ldns_dname(rdf1) if not isinstance(dname, ldns.ldns_dname): set_error() except: set_error() # Test whether rdf1 and dname independent. dname.cat(dname) if dname.__str__() == rdf1.__str__(): set_error() # Test whether rdf1 and dname are dependent. dname = ldns.ldns_dname(rdf1, clone=False) dname.cat(dname) if dname.__str__() != rdf1.__str__(): set_error() # Test whether constructs from non-dname rdfs. try: dname = ldns.ldns_dname(rdf2) set_error() except TypeError: pass except: set_error() try: dname = ldns.ldns_dname(1) set_error() except TypeError: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".[comparison operators]" dn1 = ldns.ldns_dname("a.test") dn2 = ldns.ldns_dname("b.test") try: ret = dn1 < dn2 if not isinstance(ret, bool): set_error() if ret != True: set_error() except: set_error() try: ret = dn2 < dn1 if not isinstance(ret, bool): set_error() if ret != False: set_error() except: set_error() try: ret = dn1 <= dn2 if not isinstance(ret, bool): set_error() if ret != True: set_error() except: set_error() try: ret = dn2 <= dn1 if not isinstance(ret, bool): set_error() if ret != False: set_error() except: set_error() try: ret = dn1 == dn2 if not isinstance(ret, bool): set_error() if ret != False: set_error() except: set_error() try: ret = dn1 == dn1 if not isinstance(ret, bool): set_error() if ret != True: set_error() except: set_error() try: ret = dn1 != dn2 if not isinstance(ret, bool): set_error() if ret != True: set_error() except: set_error() try: ret = dn1 != dn1 if not isinstance(ret, bool): set_error() if ret != False: set_error() except: set_error() try: ret = dn1 > dn2 if not isinstance(ret, bool): set_error() if ret != False: set_error() except: set_error() try: ret = dn2 > dn1 if not isinstance(ret, bool): set_error() if ret != True: set_error() except: set_error() try: ret = dn1 >= dn2 if not isinstance(ret, bool): set_error() if ret != False: set_error() except: set_error() try: ret = dn2 >= dn1 if not isinstance(ret, bool): set_error() if ret != True: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".absolute()" dname = ldns.ldns_dname("www.nic.cz.") try: ret = dname.absolute() if not isinstance(ret, bool): set_error() if ret != True: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".cat()" rdf1 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "test.nic.cz.") rdf2 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_A, "217.31.205.50") dname = ldns.ldns_dname("www.nic.cz.") try: ret = dname.cat(dname) if ret != ldns.LDNS_STATUS_OK: set_error() if dname.__str__() != "www.nic.cz.www.nic.cz.": set_error() except: set_error() try: ret = dname.cat(rdf1) if ret != ldns.LDNS_STATUS_OK: set_error() if dname.__str__() != "www.nic.cz.www.nic.cz.test.nic.cz.": set_error() except: set_error() try: ret = dname.cat(rdf2) if ret == ldns.LDNS_STATUS_OK: set_error() except: set_error() try: ret = dname.cat("") set_error() except TypeError: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".cat_clone()" rdf1 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "test.nic.cz.") rdf2 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_A, "217.31.205.50") dname = ldns.ldns_dname("www.nic.cz.") try: ret = dname.cat_clone(dname) if not isinstance(ret, ldns.ldns_dname): set_error() if ret.__str__() != "www.nic.cz.www.nic.cz.": set_error() except: set_error() try: ret = dname.cat_clone(rdf1) if not isinstance(ret, ldns.ldns_dname): set_error() if ret.__str__() != "www.nic.cz.test.nic.cz.": set_error() except: set_error() try: ret = dname.cat_clone(rdf2) if ret != None: set_error() except: set_error() try: ret = dname.cat_clone("") except TypeError: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".interval()" dn1 = ldns.ldns_dname("a.ns.nic.cz.") dn2 = ldns.ldns_dname("b.ns.nic.cz.") dn3 = ldns.ldns_dname("c.ns.nic.cz.") try: ret = dn1.interval(dn2, dn3) if ret != -1: set_error() except: set_error() try: ret = dn2.interval(dn1, dn3) if ret != 1: set_error() except: set_error() rdf4 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "d.ns.nic.cz.") rdf5 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_A, "194.0.12.1") try: ret = dn1.interval(dn2, rdf4) if ret != -1: set_error() except: set_error() try: ret = dn2.interval(dn1, rdf4) if ret != 1: set_error() except: set_error() try: ret = dn1.interval(dn2, rdf5) set_error() except Exception: pass except: set_error() try: ret = dn1.interval(dn2, "") set_error() except TypeError: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".is_subdomain()" dn1 = ldns.ldns_dname("nic.cz.") dn2 = ldns.ldns_dname("www.nic.cz.") rdf3 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "www.nic.cz.") try: ret = dn1.is_subdomain(dn2) if not isinstance(ret, bool): set_error() if ret == True: set_error() ret = dn2.is_subdomain(dn1) if ret != True: set_error() except: set_error() try: ret = dn1.is_subdomain(rdf3) if not isinstance(ret, bool): set_error() if ret == True: set_error() except: set_error() rdf4 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_A, "194.0.12.1") try: ret = dn1.is_subdomain(rdf4) if ret != False: set_error() except: set_error() try: ret = dn1.is_subdomain("") set_error() except TypeError: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".label()" dn = ldns.ldns_dname("nic.cz.") try: ret = dn.label(0) if not isinstance(ret, ldns.ldns_dname): set_error() except: set_error() try: ret = dn.label(10) if ret != None: set_error() except: set_error() try: ret = dn.label("") except TypeError: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".label_count()" dn = ldns.ldns_dname("www.nic.cz.") try: ret = dn.label_count() if (not isinstance(ret, int)) and (not isinstance(ret, long)): set_error() if ret != 3: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".left_chop()" dn = ldns.ldns_dname("www.nic.cz.") try: ret = dn.left_chop() if not isinstance(ret, ldns.ldns_dname): set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".make_canonical()" dn = ldns.ldns_dname("WWW.NIC.CZ.") try: dn.make_canonical() if dn.__str__() != "www.nic.cz.": set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".new_frm_rdf()" # Tested via constructor call. #if not error_detected: if True: method_name = class_name + ".new_frm_str()" # Tested via constructor call. #if not error_detected: if True: method_name = class_name + ".reverse()" dn = ldns.ldns_dname("www.nic.cz.") try: ret = dn.reverse() if not isinstance(ret, ldns.ldns_dname): set_error() if ret.__str__() != "cz.nic.www.": set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".write_to_buffer()" dn = ldns.ldns_dname("www.nic.cz.") buf = ldns.ldns_buffer(1024) try: ret = dn.write_to_buffer(buf) if ret != ldns.LDNS_STATUS_OK: set_error() if buf.position() != 12: set_error() except: set_error() try: ret = dn.write_to_buffer("") except TypeError: pass except: set_error() if not error_detected: sys.stdout.write("%s: passed.\n" % (os.path.basename(__file__))) else: sys.stdout.write("%s: errors detected.\n" % (os.path.basename(__file__))) sys.exit(1) ldns-1.6.17/contrib/python/examples/python3/0000775000175100017510000000000012264060151020316 5ustar willemwillemldns-1.6.17/contrib/python/examples/python3/ldns-newpkt.py0000775000175100017510000000073412264060151023145 0ustar willemwillem#!/usr/bin/python import ldns pkt = ldns.ldns_pkt.new_query_frm_str("www.google.com",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_QR | ldns.LDNS_AA) rra = ldns.ldns_rr.new_frm_str("www.google.com. IN A 192.168.1.1",300) rrb = ldns.ldns_rr.new_frm_str("www.google.com. IN TXT Some\ Description",300) list = ldns.ldns_rr_list() if (rra): list.push_rr(rra) if (rrb): list.push_rr(rrb) pkt.push_rr_list(ldns.LDNS_SECTION_ANSWER, list) print("Packet:") print(pkt) ldns-1.6.17/contrib/python/examples/python3/ldns-mx2.py0000775000175100017510000000106212264060151022336 0ustar willemwillem#!/usr/bin/python # # MX is a small program that prints out the mx records for a particular domain # import ldns resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") pkt = resolver.query("nic.cz", ldns.LDNS_RR_TYPE_MX,ldns.LDNS_RR_CLASS_IN) if (pkt) and (pkt.answer()): for rr in pkt.answer().rrs(): if (rr.get_type() != ldns.LDNS_RR_TYPE_MX): continue rdf = rr.owner() print(rdf," ",rr.ttl()," ",rr.get_class_str()," ",rr.get_type_str()," ", end=" ") print(" ".join(str(rdf) for rdf in rr.rdfs())) ldns-1.6.17/contrib/python/examples/python3/ldns-higher.py0000775000175100017510000000175312264060151023105 0ustar willemwillem#!/usr/bin/python import ldns resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") dnn = ldns.ldns_dname("www.google.com") print(dnn.get_type_str(), dnn) dna = ldns.ldns_rdf.new_frm_str("74.125.43.99",ldns.LDNS_RDF_TYPE_A) print(dna.get_type_str(), dna) name = resolver.get_name_by_addr(dna) if (not name): raise Exception("Can't retrieve server name") for rr in name.rrs(): print(rr) name = resolver.get_name_by_addr("74.125.43.99") if (not name): raise Exception("Can't retrieve server name") for rr in name.rrs(): print(rr) addr = resolver.get_addr_by_name(dnn) if (not addr): raise Exception("Can't retrieve server address") for rr in addr.rrs(): print(rr) addr = resolver.get_addr_by_name("www.google.com") if (not addr): raise Exception("Can't retrieve server address") for rr in addr.rrs(): print(rr) hosts = ldns.ldns_rr_list.new_frm_file("/etc/hosts") if (not hosts): raise Exception("Can't retrieve the content of file") for rr in hosts.rrs(): print(rr) ldns-1.6.17/contrib/python/examples/python3/ldns-signzone.py0000775000175100017510000000312312264060151023464 0ustar willemwillem#!/usr/bin/python # This example shows how to sign a given zone file with private key import ldns import sys, os, time #private key TAG which identifies the private key #use ldns-keygen.py in order to obtain private key keytag = 30761 # Read zone file #------------------------------------------------------------- zone = ldns.ldns_zone.new_frm_fp(open("zone.txt","r"), None, 0, ldns.LDNS_RR_CLASS_IN) soa = zone.soa() origin = soa.owner() # Prepare keys #------------------------------------------------------------- #Read private key from file keyfile = open("key-%s-%d.private" % (origin, keytag), "r"); key = ldns.ldns_key.new_frm_fp(keyfile) #Read public key from file pubfname = "key-%s-%d.key" % (origin, keytag) pubkey = None if os.path.isfile(pubfname): pubkeyfile = open(pubfname, "r"); pubkey,_,_,_ = ldns.ldns_rr.new_frm_fp(pubkeyfile) if not pubkey: #Create new public key pubkey = key.key_to_rr() #Set key expiration key.set_expiration(int(time.time()) + 365*60*60*24) #365 days #Set key owner (important step) key.set_pubkey_owner(origin) #Insert DNSKEY RR zone.push_rr(pubkey) # Sign zone #------------------------------------------------------------- #Create keylist and push private key keys = ldns.ldns_key_list() keys.push_key(key) #Add SOA signed_zone = ldns.ldns_dnssec_zone() signed_zone.add_rr(soa) #Add RRs for rr in zone.rrs().rrs(): print("RR:", str(rr), end=" ") signed_zone.add_rr(rr) added_rrs = ldns.ldns_rr_list() status = signed_zone.sign(added_rrs, keys) if (status == ldns.LDNS_STATUS_OK): signed_zone.print_to_file(open("zone_signed.txt","w")) ldns-1.6.17/contrib/python/examples/python3/ldns_rr_new_frm_fp_l.demo.py0000664000175100017510000000231012264060151025767 0ustar willemwillemimport ldns import sys if len(sys.argv) <= 1: print("Usage: %s zone_file" % sys.argv[0]) sys.exit() inp = open(sys.argv[1],"r"); # variables that preserve the parsers state my_ttl = 3600; my_origin = None my_prev = None # additional state variables last_pos = 0 line_nr = 0 while True: ret = ldns.ldns_rr_new_frm_fp_l_(inp, my_ttl, my_origin, my_prev) s, rr, line_inc, new_ttl, new_origin, new_prev = ret # unpack the result line_nr += line_inc # increase number of parsed lines my_prev = new_prev # update ref to previous owner if s == ldns.LDNS_STATUS_SYNTAX_TTL: my_ttl = new_ttl # update default TTL print("$TTL:", my_ttl) elif s == ldns.LDNS_STATUS_SYNTAX_ORIGIN: my_origin = new_origin # update reference to origin print("$ORIGIN:", my_origin) elif s == ldns.LDNS_STATUS_SYNTAX_EMPTY: if last_pos == inp.tell(): break # no advance since last read - EOF last_pos = inp.tell() elif s != ldns.LDNS_STATUS_OK: print("! parse error in line", line_nr) else: # we are sure to have LDNS_STATUS_OK print(rr) inp.close() print("--------------------") print("Read %d lines" % line_nr) ldns-1.6.17/contrib/python/examples/python3/ldns-mx1.py0000775000175100017510000000066112264060151022341 0ustar willemwillem#!/usr/bin/python # # MX is a small program that prints out the mx records for a particular domain # import ldns dname = ldns.ldns_dname("nic.cz") print(dname) resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") pkt = resolver.query(dname, ldns.LDNS_RR_TYPE_MX,ldns.LDNS_RR_CLASS_IN) if (pkt): mx = pkt.rr_list_by_type(ldns.LDNS_RR_TYPE_MX, ldns.LDNS_SECTION_ANSWER) if (mx): mx.sort() print(mx) ldns-1.6.17/contrib/python/examples/python3/ldns_rr_iter_frm_fp_l.demo.py0000664000175100017510000000031712264060151026146 0ustar willemwillemimport ldns import sys if len(sys.argv) <= 1: print("Usage: %s zone_file" % sys.argv[0]) sys.exit() inp = open(sys.argv[1],"r"); for rr in ldns.ldns_rr_iter_frm_fp_l(inp): print(rr) inp.close() ldns-1.6.17/contrib/python/examples/python3/ldns-mx.py0000775000175100017510000000060412264060151022255 0ustar willemwillem#!/usr/bin/python # # MX is a small program that prints out the mx records for a particular domain # import ldns resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") pkt = resolver.query("nic.cz", ldns.LDNS_RR_TYPE_MX,ldns.LDNS_RR_CLASS_IN) if (pkt): mx = pkt.rr_list_by_type(ldns.LDNS_RR_TYPE_MX, ldns.LDNS_SECTION_ANSWER) if (mx): mx.sort() print(mx) ldns-1.6.17/contrib/python/examples/python3/ldns-keygen.py0000775000175100017510000000176612264060151023125 0ustar willemwillem#!/usr/bin/python # # This example shows how to generate public/private key pair # import ldns algorithm = ldns.LDNS_SIGN_DSA bits = 512 ldns.ldns_init_random(open("/dev/random","rb"), (bits+7)//8) domain = ldns.ldns_dname("example.") #generate a new key key = ldns.ldns_key.new_frm_algorithm(algorithm, bits); print(key) #set owner key.set_pubkey_owner(domain) #create the public from the ldns_key pubkey = key.key_to_rr() #previous command is equivalent to # pubkey = ldns.ldns_key2rr(key) print(pubkey) #calculate and set the keytag key.set_keytag(ldns.ldns_calc_keytag(pubkey)) #build the DS record ds = ldns.ldns_key_rr2ds(pubkey, ldns.LDNS_SHA1) print(ds) owner, tag = pubkey.owner(), key.keytag() #write public key to .key file fw = open("key-%s-%d.key" % (owner,tag), "wb") pubkey.print_to_file(fw) #write private key to .priv file fw = open("key-%s-%d.private" % (owner,tag), "wb") key.print_to_file(fw) #write DS to .ds file fw = open("key-%s-%d.ds" % (owner,tag), "wb") ds.print_to_file(fw) ldns-1.6.17/contrib/python/examples/python3/ldns-buf.py0000775000175100017510000000014312264060151022403 0ustar willemwillem#!/usr/bin/python import ldns buf = ldns.ldns_buffer(1024) buf.printf("Test buffer") print(buf) ldns-1.6.17/contrib/python/examples/python3/ldns-axfr.py0000775000175100017510000000332412264060151022573 0ustar willemwillem#!/usr/bin/python # vim:fileencoding=utf-8 # # AXFR client with IDN (Internationalized Domain Names) support # import ldns import encodings.idna def utf2name(name): return '.'.join([encodings.idna.ToASCII(a).decode("utf-8") for a in name.split('.')]) def name2utf(name): return '.'.join([encodings.idna.ToUnicode(a) for a in name.split('.')]) resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") #addr = ldns.ldns_get_rr_list_addr_by_name(resolver, "zone.nic.cz", ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD); addr = resolver.get_addr_by_name("zone.nic.cz", ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD); if (not addr): raise Exception("Can't retrieve server address") print("Addr_by_name:",str(addr).replace("\n","; ")) #remove all nameservers while resolver.pop_nameserver(): pass #insert server addr for rr in addr.rrs(): resolver.push_nameserver_rr(rr) #AXFR transfer status = resolver.axfr_start(utf2name("háÄkyÄárky.cz"), ldns.LDNS_RR_CLASS_IN) if status != ldns.LDNS_STATUS_OK: raise Exception("Can't start AXFR. Error: %s" % ldns.ldns_get_errorstr_by_id(status)) #Print results while True: rr = resolver.axfr_next() if not rr: break rdf = rr.owner() if (rdf.get_type() == ldns.LDNS_RDF_TYPE_DNAME): print("RDF owner: type=",rdf.get_type_str(),"data=",name2utf(str(rdf))) else: print("RDF owner: type=",rdf.get_type_str(),"data=",str(rdf)) print(" RR type=", rr.get_type_str()," ttl=",rr.ttl()) for rdf in rr.rdfs(): if (rdf.get_type() == ldns.LDNS_RDF_TYPE_DNAME): print(" RDF: type=",rdf.get_type_str(),"data=",name2utf(str(rdf))) else: print(" RDF: type=",rdf.get_type_str(),"data=",str(rdf)) print() ldns-1.6.17/contrib/python/examples/python3/ldns-dnssec.py0000775000175100017510000000215712264060151023115 0ustar willemwillem#!/usr/bin/python # -*- coding: utf-8 -*- import ldns import sys debug = True # Check args argc = len(sys.argv) name = "www.nic.cz" if argc < 2: print("Usage:", sys.argv[0], "domain [resolver_addr]") sys.exit(1) else: name = sys.argv[1] # Create resolver resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") resolver.set_dnssec(True) # Custom resolver if argc > 2: # Clear previous nameservers ns = resolver.pop_nameserver() while ns != None: ns = resolver.pop_nameserver() ip = ldns.ldns_rdf.new_frm_str(sys.argv[2], ldns.LDNS_RDF_TYPE_A) resolver.push_nameserver(ip) # Resolve DNS name pkt = resolver.query(name, ldns.LDNS_RR_TYPE_A, ldns.LDNS_RR_CLASS_IN) if pkt and pkt.answer(): # Debug if debug: print("NS returned:", pkt.get_rcode(), "(AA: %d AD: %d)" % ( pkt.ad(), pkt.ad() )) # SERVFAIL indicated bogus name if pkt.get_rcode() is ldns.LDNS_RCODE_SERVFAIL: print(name, "is bogus") # Check AD (Authenticated) bit if pkt.get_rcode() is ldns.LDNS_RCODE_NOERROR: if pkt.ad(): print(name, "is secure") else: print(name, "is insecure") ldns-1.6.17/contrib/python/examples/python3/ldns-zone.py0000775000175100017510000000041212264060151022601 0ustar willemwillem#!/usr/bin/python import ldns #Read zone from file zone = ldns.ldns_zone.new_frm_fp(open("../zone.txt","r"), None, 0, ldns.LDNS_RR_CLASS_IN) print(zone) print("SOA:", zone.soa()) for r in zone.rrs().rrs(): print("RR:", r) zone = ldns.ldns_zone() #print zone ldns-1.6.17/contrib/python/examples/ldns-mx2.py0000775000175100017510000000105012264060151020727 0ustar willemwillem#!/usr/bin/python # # MX is a small program that prints out the mx records for a particular domain # import ldns resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") pkt = resolver.query("nic.cz", ldns.LDNS_RR_TYPE_MX,ldns.LDNS_RR_CLASS_IN) if (pkt) and (pkt.answer()): for rr in pkt.answer().rrs(): if (rr.get_type() != ldns.LDNS_RR_TYPE_MX): continue rdf = rr.owner() print rdf," ",rr.ttl()," ",rr.get_class_str()," ",rr.get_type_str()," ", print " ".join(str(rdf) for rdf in rr.rdfs()) ldns-1.6.17/contrib/python/examples/ldns-higher.py0000775000175100017510000000174412264060151021501 0ustar willemwillem#!/usr/bin/python import ldns resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") dnn = ldns.ldns_dname("www.google.com") print dnn.get_type_str(), dnn dna = ldns.ldns_rdf.new_frm_str("74.125.43.99",ldns.LDNS_RDF_TYPE_A) print dna.get_type_str(), dna name = resolver.get_name_by_addr(dna) if (not name): raise Exception("Can't retrieve server name") for rr in name.rrs(): print rr name = resolver.get_name_by_addr("74.125.43.99") if (not name): raise Exception("Can't retrieve server name") for rr in name.rrs(): print rr addr = resolver.get_addr_by_name(dnn) if (not addr): raise Exception("Can't retrieve server address") for rr in addr.rrs(): print rr addr = resolver.get_addr_by_name("www.google.com") if (not addr): raise Exception("Can't retrieve server address") for rr in addr.rrs(): print rr hosts = ldns.ldns_rr_list.new_frm_file("/etc/hosts") if (not hosts): raise Exception("Can't retrieve the content of file") for rr in hosts.rrs(): print rr ldns-1.6.17/contrib/python/examples/ldns-signzone.py0000775000175100017510000000311112264060151022055 0ustar willemwillem#!/usr/bin/python # This example shows how to sign a given zone file with private key import ldns import sys, os, time #private key TAG which identifies the private key #use ldns-keygen.py in order to obtain private key keytag = 30761 # Read zone file #------------------------------------------------------------- zone = ldns.ldns_zone.new_frm_fp(open("zone.txt","r"), None, 0, ldns.LDNS_RR_CLASS_IN) soa = zone.soa() origin = soa.owner() # Prepare keys #------------------------------------------------------------- #Read private key from file keyfile = open("key-%s-%d.private" % (origin, keytag), "r"); key = ldns.ldns_key.new_frm_fp(keyfile) #Read public key from file pubfname = "key-%s-%d.key" % (origin, keytag) pubkey = None if os.path.isfile(pubfname): pubkeyfile = open(pubfname, "r"); pubkey,_,_,_ = ldns.ldns_rr.new_frm_fp(pubkeyfile) if not pubkey: #Create new public key pubkey = key.key_to_rr() #Set key expiration key.set_expiration(int(time.time()) + 365*60*60*24) #365 days #Set key owner (important step) key.set_pubkey_owner(origin) #Insert DNSKEY RR zone.push_rr(pubkey) # Sign zone #------------------------------------------------------------- #Create keylist and push private key keys = ldns.ldns_key_list() keys.push_key(key) #Add SOA signed_zone = ldns.ldns_dnssec_zone() signed_zone.add_rr(soa) #Add RRs for rr in zone.rrs().rrs(): print "RR:",str(rr), signed_zone.add_rr(rr) added_rrs = ldns.ldns_rr_list() status = signed_zone.sign(added_rrs, keys) if (status == ldns.LDNS_STATUS_OK): signed_zone.print_to_file(open("zone_signed.txt","w")) ldns-1.6.17/contrib/python/examples/ldns_rr_new_frm_fp_l.demo.py0000664000175100017510000000227212264060151024372 0ustar willemwillemimport ldns import sys if len(sys.argv) <= 1: print "Usage: %s zone_file" % sys.argv[0] sys.exit() inp = open(sys.argv[1],"r"); # variables that preserve the parsers state my_ttl = 3600; my_origin = None my_prev = None # additional state variables last_pos = 0 line_nr = 0 while True: ret = ldns.ldns_rr_new_frm_fp_l_(inp, my_ttl, my_origin, my_prev) s, rr, line_inc, new_ttl, new_origin, new_prev = ret # unpack the result line_nr += line_inc # increase number of parsed lines my_prev = new_prev # update ref to previous owner if s == ldns.LDNS_STATUS_SYNTAX_TTL: my_ttl = new_ttl # update default TTL print "$TTL:", my_ttl elif s == ldns.LDNS_STATUS_SYNTAX_ORIGIN: my_origin = new_origin # update reference to origin print "$ORIGIN:", my_origin elif s == ldns.LDNS_STATUS_SYNTAX_EMPTY: if last_pos == inp.tell(): break # no advance since last read - EOF last_pos = inp.tell() elif s != ldns.LDNS_STATUS_OK: print "! parse error in line", line_nr else: # we are sure to have LDNS_STATUS_OK print rr inp.close() print "--------------------" print "Read %d lines" % line_nr ldns-1.6.17/contrib/python/examples/test_rdf.py0000775000175100017510000004714412264060151021113 0ustar willemwillem#!/usr/bin/env python # # ldns_rdf testing script. # # Do not use constructs that differ between Python 2 and 3. # Use write on stdout or stderr. # import ldns import sys import os import inspect class_name = "ldns_rdf" method_name = None error_detected = False temp_fname = "tmp_rdf.txt" def set_error(): """ Writes an error message and sets error flag. """ global class_name global method_name global error_detected error_detected = True sys.stderr.write("(line %d): malfunctioning method %s.\n" % \ (inspect.currentframe().f_back.f_lineno, method_name)) #if not error_detected: if True: method_name = class_name + ".__init__()" try: # Should raise an Exception rdf = ldns.ldns_rdf() set_error() except Exception as e: pass #if not error_detected: if True: method_name = class_name + ".[comparison operators]" rdf1 = ldns.ldns_rdf.new_frm_str("0.0.0.0", ldns.LDNS_RDF_TYPE_A) rdf2 = ldns.ldns_rdf.new_frm_str("1.1.1.1", ldns.LDNS_RDF_TYPE_A) try: ret = rdf1 < rdf2 if not isinstance(ret, bool): set_error() if ret != True: set_error() except: set_error() try: ret = rdf2 < rdf1 if not isinstance(ret, bool): set_error() if ret != False: set_error() except: set_error() try: ret = rdf1 <= rdf2 if not isinstance(ret, bool): set_error() if ret != True: set_error() except: set_error() try: ret = rdf2 <= rdf1 if not isinstance(ret, bool): set_error() if ret != False: set_error() except: set_error() try: ret = rdf1 == rdf2 if not isinstance(ret, bool): set_error() if ret != False: set_error() except: set_error() try: ret = rdf1 == rdf1 if not isinstance(ret, bool): set_error() if ret != True: set_error() except: set_error() try: ret = rdf1 != rdf2 if not isinstance(ret, bool): set_error() if ret != True: set_error() except: set_error() try: ret = rdf1 != rdf1 if not isinstance(ret, bool): set_error() if ret != False: set_error() except: set_error() try: ret = rdf1 > rdf2 if not isinstance(ret, bool): set_error() if ret != False: set_error() except: set_error() try: ret = rdf2 > rdf1 if not isinstance(ret, bool): set_error() if ret != True: set_error() except: set_error() try: ret = rdf1 >= rdf2 if not isinstance(ret, bool): set_error() if ret != False: set_error() except: set_error() try: ret = rdf2 >= rdf1 if not isinstance(ret, bool): set_error() if ret != True: set_error() except: set_error() #if not error_detected: if True: method_name = "ldns_rdf_new()" sys.stderr.write("%s not tested.\n" % (method_name)) #if not error_detected: if True: method_name = "ldns_rdf_new_frm_data()" sys.stderr.write("%s not tested.\n" % (method_name)) #if not error_detected: if True: method_name = "ldns_rdf_new_frm_str()" try: rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "www.nic.cz") except: set_error() try: rdf = ldns.ldns_rdf_new_frm_str("", "www.nic.cz") et_error() except TypeError: pass except: set_error() try: rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, 1) except TypeError: pass except: set_error() #if not error_detected: if True: method_name = "ldns_rdf_new_frm_fp()" f = open(temp_fname, "w") f.write("217.31.205.50") f.close() f = open(temp_fname, "r") try: status, rdf = ldns.ldns_rdf_new_frm_fp(ldns.LDNS_RDF_TYPE_A, f) if status != ldns.LDNS_STATUS_OK: set_error() if rdf == None: set_error() except: set_error() try: # Reading past file end. status, rdf = ldns.ldns_rdf_new_frm_fp(ldns.LDNS_RDF_TYPE_AAAA, f) if status == ldns.LDNS_STATUS_OK: set_error() if rdf != None: set_error() except: set_error() f.close() f = open(temp_fname, "r") try: status, rdf = ldns.ldns_rdf_new_frm_fp(ldns.LDNS_RDF_TYPE_AAAA, f) if status != ldns.LDNS_STATUS_OK: set_error() if rdf != None: set_error() except: set_error() f.close() os.remove(temp_fname) try: status, rdf = ldns.ldns_rdf_new_frm_fp("", f) except TypeError: pass except: set_error() try: status, rdf = ldns.ldns_rdf_new_frm_fp(ldns.LDNS_RDF_TYPE_AAAA, "") except TypeError: pass except: set_error() #if not error_detected: if True: method_name = "ldns_rdf_new_frm_fp_l()" f = open(temp_fname, "w") f.write("217.31.205.50\n194.0.12.1") f.close() f = open(temp_fname, "r") try: status, rdf, line = ldns.ldns_rdf_new_frm_fp_l(ldns.LDNS_RDF_TYPE_A, f) if status != ldns.LDNS_STATUS_OK: set_error() if rdf == None: set_error() except: set_error() try: status, rdf, line = ldns.ldns_rdf_new_frm_fp_l(ldns.LDNS_RDF_TYPE_A, f) if status != ldns.LDNS_STATUS_OK: set_error() if rdf == None: set_error() except: set_error() try: # Reading past file end. status, rdf, line = ldns.ldns_rdf_new_frm_fp_l(ldns.LDNS_RDF_TYPE_A, f) if status == ldns.LDNS_STATUS_OK: set_error() if rdf != None: set_error() except: set_error() f.close() os.remove(temp_fname) try: status, rdf = ldns.ldns_rdf_new_frm_fp_l("", f) except TypeError: pass except: set_error() try: status, rdf = ldns.ldns_rdf_new_frm_fp_l(ldns.LDNS_RDF_TYPE_AAAA, "") except TypeError: pass except: set_error() #if not error_detected: if True: method_name = "ldns_drf.absolute()" rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "www.nic.cz.") try: ret = rdf.absolute() if not isinstance(ret, bool): set_error() if not ret: set_error() except: set_error() #if not error_detected: if True: method_name = "ldns_rdf.address_reverse()" rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_A, "194.0.12.1") try: ret = rdf.address_reverse() if ret == None: set_error() except: set_error() rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_AAAA, "::1") try: ret = rdf.address_reverse() if ret == None: set_error() except: set_error() rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "www.nic.cz.") try: ret = rdf.address_reverse() if ret != None: set_error() except: set_error() #if not error_detected: if True: method_name = "ldns_rdf.cat()" rdf1 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "www.nic") rdf2 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "cz.") try: ret = rdf1.cat(rdf2) if ret != ldns.LDNS_STATUS_OK: set_error() except: set_error() rdf1 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "www.nic.") rdf2 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_A, "127.0.0.1") try: ret = rdf1.cat(rdf2) if ret == ldns.LDNS_STATUS_OK: set_error() except: set_error() try: ret = rdf2.cat(rdf1) if ret == ldns.LDNS_STATUS_OK: set_error() except: set_error() try: ret = rdf2.cat("") set_error() except TypeError: pass except: set_error() #if not error_detected: if True: method_name = "ldns_rdf.cat_clone()" rdf1 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "www.nic") rdf2 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "cz.") try: ret = rdf1.cat_clone(rdf2) if ret == None: set_error() except: set_error() rdf1 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "www.nic.") rdf2 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_A, "127.0.0.1") try: ret = rdf1.cat_clone(rdf2) if ret != None: set_error() except: set_error() try: ret = rdf2.cat_clone(rdf1) if ret != None: set_error() except: set_error() try: ret = rdf2.cat_clone("") set_error() except TypeError: pass except: set_error() #if not error_detected: if True: method_name = "ldns_rdf.clone()" rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "www.nic.cz.") try: ret = rdf.clone() except: set_error() #if not error_detected: if True: method_name = "ldns_rdf.data()" rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "www.nic.cz.") try: ret = rdf.data() except: set_error() #if not error_detected: if True: method_name = "ldns_rdf.data_as_bytearray()" rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "www.nic.cz.") try: ret = rdf.data_as_bytearray() if not isinstance(ret, bytearray): set_error() if len(ret) != 12: set_error() except: set_error() #if not error_detected: if True: method_name = "ldns_rdf.dname_compare()" rdf1 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "www.nic.cz.") rdf2 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "nic.cz.") try: ret = rdf1.dname_compare(rdf2) if ret != 1: set_error() except: set_error() try: ret = rdf2.dname_compare(rdf1) if ret != -1: set_error() except: set_error() try: ret = rdf1.dname_compare(rdf1) if ret != 0: set_error() except: set_error() rdf1 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "www.nic.cz.") rdf2 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_A, "127.0.0.1") try: ret = rdf1.dname_compare(rdf2) set_error() except Exception: pass except: set_error() #if not error_detected: if True: method_name = "ldns_rdf.dname_new_frm_str()" try: rdf = ldns.ldns_rdf.dname_new_frm_str("www.nic.cz.") if rdf == None: set_error() except: set_error() try: rdf = ldns.ldns_rdf.dname_new_frm_str("") if rdf != None: set_error() except: set_error() try: rdf = ldns.ldns_rdf.dname_new_frm_str(1) set_error() except TypeError: pass except: set_error() #if not error_detected: if True: method_name = "ldns_rdf.get_type()" rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "www.nic.cz.") try: ret = rdf.get_type() if not isinstance(ret, int): set_error() if ret != ldns.LDNS_RDF_TYPE_DNAME: set_error() except: set_error() #if not error_detected: if True: method_name = "ldns_rdf.get_type_str()" rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "www.nic.cz.") try: ret = rdf.get_type_str() if not isinstance(ret, str): set_error() except: set_error() #if not error_detected: if True: method_name = "ldns_rdf.interval()" rdf1 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "a.ns.nic.cz.") rdf2 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "b.ns.nic.cz.") rdf3 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "c.ns.nic.cz.") try: ret = rdf1.interval(rdf2, rdf3) if ret != -1: set_error() except: set_error() try: ret = rdf2.interval(rdf1, rdf3) if ret != 1: set_error() except: set_error() rdf1 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_A, "194.0.12.1") rdf2 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "b.ns.nic.cz.") rdf3 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "c.ns.nic.cz.") try: ret = rdf1.interval(rdf2, rdf3) set_error() except Exception: pass except: set_error() try: ret = rdf2.interval("", rdf3) set_error() except TypeError: pass except: set_error() #if not error_detected: if True: method_name = "ldns_rdf.is_subdomain()" rdf1 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "nic.cz.") rdf2 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "www.nic.cz.") try: ret = rdf1.is_subdomain(rdf2) if not isinstance(ret, bool): set_error() if ret == True: set_error() ret = rdf2.is_subdomain(rdf1) if ret != True: set_error() except: set_error() rdf1 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_A, "194.0.12.1") rdf2 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "www.nic.cz.") try: ret = rdf1.is_subdomain(rdf2) if ret != False: set_error() except: set_error() try: ret = rdf2.is_subdomain(rdf1) if ret != False: set_error() except: set_error() try: ret = rdf2.is_subdomain("") set_error() except TypeError: pass except: set_error() #if not error_detected: if True: method_name = "ldns_rdf.label()" rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "www.nic.cz.") try: ret = rdf.label(0) if not isinstance(ret, ldns.ldns_rdf): set_error() except: set_error() try: ret = rdf.label(10) if ret != None: set_error() except: set_error() try: ret = rdf.label("") except TypeError: pass except: set_error() rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_A, "127.0.0.1") try: ret = rdf.label(0) if ret != None: set_error() except: set_error() #if not error_detected: if True: method_name = "ldns_rdf.label_count()" rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "www.nic.cz.") try: ret = rdf.label_count() if (not isinstance(ret, int)) and (not isinstance(ret, long)): set_error() if ret != 3: set_error() except: set_error() rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_A, "127.0.0.1") try: ret = rdf.label_count() if (not isinstance(ret, int)) and (not isinstance(ret, long)): set_error() if ret != 0: set_error() except: set_error() #if not error_detected: if True: method_name = "ldns_rdf.left_chop()" rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "www.nic.cz.") try: ret = rdf.left_chop() if not isinstance(ret, ldns.ldns_rdf): set_error() except: set_error() rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_A, "127.0.0.1") try: ret = rdf.left_chop() if ret != None: set_error() except: set_error() #if not error_detected: if True: method_name = "ldns_rdf.make_canonical()" rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "WWW.NIC.CZ.") try: rdf.make_canonical() if rdf.__str__() != "www.nic.cz.": set_error() except: set_error() rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_A, "127.0.0.1") try: rdf.make_canonical() except: set_error() #if not error_detected: if True: method_name = "ldns_rdf.new_frm_str()" try: rdf = ldns.ldns_rdf.new_frm_str("www.nic.cz.", ldns.LDNS_RDF_TYPE_DNAME) except: set_error() try: rdf = ldns.ldns_rdf.new_frm_str("www.nic.cz.", ldns.LDNS_RDF_TYPE_AAAA) set_error() except Exception: pass except: set_error() try: rdf = ldns.ldns_rdf.new_frm_str("www.nic.cz.", ldns.LDNS_RDF_TYPE_AAAA, raiseException = False) if rdf != None: set_error() except: set_error() try: rdf = ldns.ldns_rdf.new_frm_str("", "www.nic.cz") et_error() except TypeError: pass except: set_error() try: rdf = ldns.ldns_rdf.new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, 1) except TypeError: pass except: set_error() #if not error_detected: if True: rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_A, "127.0.0.1") f = open(temp_fname, "w") try: rdf.print_to_file(f) except: set_error() f.close() f = open(temp_fname, "r") if f.read() != "127.0.0.1": set_error() f.close() os.remove(temp_fname) #if not error_detected: if True: rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "www.nic.cz.") try: ret = rdf.reverse() if not isinstance(ret, ldns.ldns_rdf): set_error() if ret.__str__() != "cz.nic.www.": set_error() except: set_error() rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_A, "127.0.0.1") try: ret = rdf.reverse() set_error() except Exception: pass except: set_error() #if not error_detected: if True: method_name = "ldns_rdf.set_data()" sys.stderr.write("%s not tested.\n" % (method_name)) #if not error_detected: if True: method_name = "ldns_rdf.set_size()" sys.stderr.write("%s not tested.\n" % (method_name)) #if not error_detected: if True: method_name = "ldns_rdf.set_type()" sys.stderr.write("%s not tested.\n" % (method_name)) #if not error_detected: if True: method_name = "ldns_rdf.size()" rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "www.nic.cz.") try: ret = rdf.size() if ret != 12: set_error() except: set_error() #if not error_detected: if True: method_name = "ldns_rdf.write_to_buffer()" rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "www.nic.cz.") buf = ldns.ldns_buffer(1024) try: ret = rdf.write_to_buffer(buf) if ret != ldns.LDNS_STATUS_OK: set_error() if buf.position() != 12: set_error() except: set_error() try: ret = rdf.write_to_buffer("") except TypeError: pass except: set_error() #if not error_detected: if True: method_name = "ldns_rdf.write_to_buffer_canonical()" rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "WWW.NIC.CZ.") buf = ldns.ldns_buffer(1024) try: ret = rdf.write_to_buffer_canonical(buf) if ret != ldns.LDNS_STATUS_OK: set_error() if buf.position() != 12: set_error() except: set_error() try: ret = rdf.write_to_buffer_canonical("") except TypeError: pass except: set_error() if not error_detected: sys.stdout.write("%s: passed.\n" % (os.path.basename(__file__))) else: sys.stdout.write("%s: errors detected.\n" % (os.path.basename(__file__))) sys.exit(1) ldns-1.6.17/contrib/python/examples/ldns-mx1.py0000775000175100017510000000065712264060151020742 0ustar willemwillem#!/usr/bin/python # # MX is a small program that prints out the mx records for a particular domain # import ldns dname = ldns.ldns_dname("nic.cz") print dname resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") pkt = resolver.query(dname, ldns.LDNS_RR_TYPE_MX,ldns.LDNS_RR_CLASS_IN) if (pkt): mx = pkt.rr_list_by_type(ldns.LDNS_RR_TYPE_MX, ldns.LDNS_SECTION_ANSWER) if (mx): mx.sort() print mx ldns-1.6.17/contrib/python/examples/ldns_rr_iter_frm_fp_l.demo.py0000664000175100017510000000032412264060151024540 0ustar willemwillemimport ldns import sys if len(sys.argv) <= 1: print "Usage: %s zone_file" % sys.argv[0] sys.exit() inp = open(sys.argv[1],"r"); for rr in ldns.ldns_rr_iter_frm_fp_l(inp): print rr inp.close() ldns-1.6.17/contrib/python/examples/ldns-mx.py0000775000175100017510000000060312264060151020650 0ustar willemwillem#!/usr/bin/python # # MX is a small program that prints out the mx records for a particular domain # import ldns resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") pkt = resolver.query("nic.cz", ldns.LDNS_RR_TYPE_MX,ldns.LDNS_RR_CLASS_IN) if (pkt): mx = pkt.rr_list_by_type(ldns.LDNS_RR_TYPE_MX, ldns.LDNS_SECTION_ANSWER) if (mx): mx.sort() print mx ldns-1.6.17/contrib/python/examples/test_pkt.py0000775000175100017510000014166412264060151021140 0ustar willemwillem#!/usr/bin/env python # # ldns_pkt testing script. # # Do not use constructs that differ between Python 2 and 3. # Use write on stdout or stderr. # import ldns import sys import os import inspect class_name = "ldns_pkt" method_name = None error_detected = False temp_fname = "tmp_pkt.txt" def set_error(): """ Writes an error message and sets error flag. """ global class_name global method_name global error_detected error_detected = True sys.stderr.write("(line %d): malfunctioning method %s.\n" % \ (inspect.currentframe().f_back.f_lineno, method_name)) #if not error_detected: if True: method_name = class_name + ".aa()" pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_QR | ldns.LDNS_AA) try: ret = pkt.aa() if not isinstance(ret, bool): set_error() if ret != True: set_error() except: set_error() pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_QR) try: ret = pkt.aa() if not isinstance(ret, bool): set_error() if ret != False: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".ad()" pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_QR | ldns.LDNS_AD) try: ret = pkt.ad() if not isinstance(ret, bool): set_error() if ret != True: set_error() except: set_error() pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_QR) try: ret = pkt.ad() if not isinstance(ret, bool): set_error() if ret != False: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".additional()" pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_QR | ldns.LDNS_AD) try: ret = pkt.additional() if not isinstance(ret, ldns.ldns_rr_list): set_error() if ret.rr_count() != 0: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".algorithm2str()" try: ret = ldns.ldns_pkt.algorithm2str(ldns.LDNS_DSA) if not isinstance(ret, str): set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".all()" pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_QR | ldns.LDNS_AD) try: ret = pkt.all() if not isinstance(ret, ldns.ldns_rr_list): set_error() if ret.rr_count() != 1: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".all_noquestion()" pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_QR | ldns.LDNS_AD) try: ret = pkt.all_noquestion() if not isinstance(ret, ldns.ldns_rr_list): set_error() if ret.rr_count() != 0: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".ancount()" pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_QR | ldns.LDNS_AD) try: ret = pkt.ancount() if (not isinstance(ret, int)) and (not isinstance(ret, long)): set_error() if ret != 0: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".answer()" pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_QR | ldns.LDNS_AD) try: ret = pkt.answer() if not isinstance(ret, ldns.ldns_rr_list): set_error() if ret.rr_count() != 0: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".answerfrom()" pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_QR | ldns.LDNS_AD) try: ret = pkt.answerfrom() if ret != None: set_error() except: set_error() resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") pkt = resolver.query("www.nic.cz", ldns.LDNS_RR_TYPE_A, ldns.LDNS_RR_CLASS_IN) try: ret = pkt.answerfrom() if not isinstance(ret, ldns.ldns_rdf): set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".arcount()" pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_QR | ldns.LDNS_AD) try: ret = pkt.arcount() if (not isinstance(ret, int)) and (not isinstance(ret, long)): set_error() if ret != 0: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".authority()" pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_QR | ldns.LDNS_AD) try: ret = pkt.authority() if not isinstance(ret, ldns.ldns_rr_list): set_error() if ret.rr_count() != 0: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".cd()" pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_CD) try: ret = pkt.cd() if not isinstance(ret, bool): set_error() if ret != True: set_error() except: set_error() pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_QR) try: ret = pkt.cd() if not isinstance(ret, bool): set_error() if ret != False: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".cert_algorithm2str()" try: ret = ldns.ldns_pkt.cert_algorithm2str(ldns.LDNS_CERT_PGP) if not isinstance(ret, str): set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".clone()" pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_QR | ldns.LDNS_AD) try: ret = pkt.clone() if not isinstance(ret, ldns.ldns_pkt): set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".ends()" pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD | ldns.LDNS_AD) try: ret = pkt.edns() if not isinstance(ret, bool): set_error() if ret != False: set_error() except: set_error() resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") resolver.set_dnssec(True) pkt = resolver.query("www.nic.cz", ldns.LDNS_RR_TYPE_A, ldns.LDNS_RR_CLASS_IN) try: ret = pkt.edns() if not isinstance(ret, bool): set_error() if ret != True: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".ends_data()" pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD | ldns.LDNS_AD) try: ret = pkt.edns_data() if ret != None: set_error() except: set_error() #resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") #resolver.set_dnssec(True) #pkt = resolver.query("www.nic.cz", ldns.LDNS_RR_TYPE_A, ldns.LDNS_RR_CLASS_IN) #try: # ret = pkt.edns_data() # print ret # if not isinstance(ret, ldns.ldns_rdf): # set_error() # if ret != True: # set_error() #except: # set_error() #if not error_detected: if True: method_name = class_name + ".edns_do()" pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD | ldns.LDNS_AD) try: ret = pkt.edns_do() if not isinstance(ret, bool): set_error() if ret != False: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".edns_extended_rcode()" pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD | ldns.LDNS_AD) try: ret = pkt.edns_extended_rcode() if (not isinstance(ret, int)) and (not isinstance(ret, long)): set_error() if ret != 0: set_error() except: set_error() #resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") #resolver.set_dnssec(True) #pkt = resolver.query("www.nic.cz", ldns.LDNS_RR_TYPE_A, ldns.LDNS_RR_CLASS_IN) #try: # ret = pkt.edns_extended_rcode() # if (not isinstance(ret, int)) and (not isinstance(ret, long)): # set_error() # if ret != 0: # set_error() #except: # set_error() #if not error_detected: if True: method_name = class_name + ".edns_udp_size()" pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD | ldns.LDNS_AD) try: ret = pkt.edns_udp_size() if (not isinstance(ret, int)) and (not isinstance(ret, long)): set_error() if ret != 0: set_error() except: set_error() resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") resolver.set_dnssec(True) pkt = resolver.query("www.nic.cz", ldns.LDNS_RR_TYPE_A, ldns.LDNS_RR_CLASS_IN) try: ret = pkt.edns_udp_size() if (not isinstance(ret, int)) and (not isinstance(ret, long)): set_error() if ret == 0: # Don't know the actual size, but must be greater than 0. set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".edns_version()" pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD | ldns.LDNS_AD) try: ret = pkt.edns_version() if (not isinstance(ret, int)) and (not isinstance(ret, long)): set_error() if ret != 0: set_error() except: set_error() #resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") #resolver.set_dnssec(True) #pkt = resolver.query("www.nic.cz", ldns.LDNS_RR_TYPE_A, ldns.LDNS_RR_CLASS_IN) #try: # ret = pkt.edns_version() # if (not isinstance(ret, int)) and (not isinstance(ret, long)): # set_error() # if ret != 0: # set_error() #except: # set_error() #if not error_detected: if True: method_name = class_name + ".edns_z()" pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD | ldns.LDNS_AD) try: ret = pkt.edns_z() if (not isinstance(ret, int)) and (not isinstance(ret, long)): set_error() if ret != 0: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".empty()" pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD | ldns.LDNS_AD) try: ret = pkt.empty() if not isinstance(ret, bool): set_error() if ret != False: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".get_opcode()" pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD | ldns.LDNS_AD) try: ret = pkt.get_opcode() if (not isinstance(ret, int)) and (not isinstance(ret, long)): set_error() if ret != ldns.LDNS_PACKET_QUERY: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".get_rcode()" pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD | ldns.LDNS_AD) try: ret = pkt.get_rcode() if (not isinstance(ret, int)) and (not isinstance(ret, long)): set_error() if ret != ldns.LDNS_RCODE_NOERROR: set_error() except: set_error() resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") resolver.set_dnssec(True) pkt = resolver.query("nonexistent_domain.nic.cz", ldns.LDNS_RR_TYPE_A, ldns.LDNS_RR_CLASS_IN) try: ret = pkt.get_rcode() if (not isinstance(ret, int)) and (not isinstance(ret, long)): set_error() if ret != ldns.LDNS_RCODE_NXDOMAIN: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".get_section_clone()" pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD | ldns.LDNS_AD) try: ret = pkt.get_section_clone(ldns.LDNS_SECTION_ANY) if not isinstance(ret, ldns.ldns_rr_list): set_error() except: set_error() try: ret = pkt.get_section_clone(ldns.LDNS_SECTION_ANSWER) if not isinstance(ret, ldns.ldns_rr_list): set_error() except: set_error() try: ret = pkt.get_section_clone("bad argument") set_error() except TypeError as e: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".id()" pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD | ldns.LDNS_AD) try: ret = pkt.id() if (not isinstance(ret, int)) and (not isinstance(ret, long)): set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".new()" try: pkt = ldns.ldns_pkt.new() if not isinstance(pkt, ldns.ldns_pkt): set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".new_query()" dname = ldns.ldns_dname("test.nic.cz.") try: pkt = ldns.ldns_pkt.new_query(dname, ldns.LDNS_RR_TYPE_A, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_QR | ldns.LDNS_RD) if not isinstance(pkt, ldns.ldns_pkt): set_error() except: set_error() rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "test.nic.cz.") try: pkt = ldns.ldns_pkt.new_query(rdf, ldns.LDNS_RR_TYPE_A, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_QR | ldns.LDNS_RD) if not isinstance(pkt, ldns.ldns_pkt): set_error() except: set_error() try: pkt = ldns.ldns_pkt.new_query("bad argument", ldns.LDNS_RR_TYPE_A, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_QR | ldns.LDNS_RD) set_error() except TypeError as e: pass except: set_error() try: pkt = ldns.ldns_pkt.new_query(dname, "bad argument", ldns.LDNS_RR_CLASS_IN, ldns.LDNS_QR | ldns.LDNS_RD) set_error() except TypeError as e: pass except: set_error() try: pkt = ldns.ldns_pkt.new_query(dname, ldns.LDNS_RR_TYPE_A, "bad argument", ldns.LDNS_QR | ldns.LDNS_RD) set_error() except TypeError as e: pass except: set_error() try: pkt = ldns.ldns_pkt.new_query(dname, ldns.LDNS_RR_TYPE_A, ldns.LDNS_RR_CLASS_IN, "bad argument") set_error() except TypeError as e: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".new_query_frm_str()" try: pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz", ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_QR | ldns.LDNS_AA) except: set_error() try: pkt = ldns.ldns_pkt.new_query_frm_str(pkt, ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_QR | ldns.LDNS_AA) set_error() except TypeError as e: pass except: set_error() try: pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz", "bad argument", ldns.LDNS_RR_CLASS_IN, ldns.LDNS_QR | ldns.LDNS_AA) set_error() except TypeError as e: pass except: set_error() try: pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz", ldns.LDNS_RR_TYPE_ANY, "bad argument", ldns.LDNS_QR | ldns.LDNS_AA) set_error() except TypeError as e: pass except: set_error() try: pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz", ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, "bad argument") set_error() except TypeError as e: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".nscount()" pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD | ldns.LDNS_AD) try: ret = pkt.nscount() if (not isinstance(ret, int)) and (not isinstance(ret, long)): set_error() if ret != 0: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".opcode2str()" pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD | ldns.LDNS_AD) try: ret = pkt.opcode2str() if not isinstance(ret, str): set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".print_to_file()" pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD | ldns.LDNS_AD) f = open(temp_fname, "w") try: pkt.print_to_file(f) except: set_error() f.close() f = open(temp_fname, "r") if len(f.readlines()) != 14: set_error() f.close() os.remove(temp_fname) #if not error_detected: if True: method_name = class_name + ".push_rr()" pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD | ldns.LDNS_AD) rr = ldns.ldns_rr.new_frm_str("test1 600 IN A 0.0.0.0") try: ret = pkt.push_rr(ldns.LDNS_SECTION_ANSWER, rr) if not isinstance(ret, bool): set_error() if ret != True: set_error() except: set_error() try: ret = pkt.push_rr("bad argument", rr) set_error() except TypeError as e: pass except: set_error() try: ret = pkt.push_rr(ldns.LDNS_SECTION_ANSWER, "bad argument") set_error() except TypeError as e: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".push_rr_list()" pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD | ldns.LDNS_AD) rrl = ldns.ldns_rr_list.new() rr = ldns.ldns_rr.new_frm_str("test1 600 IN A 0.0.0.0") rrl.push_rr(rr) rrl.push_rr(rr) try: ret = pkt.push_rr_list(ldns.LDNS_SECTION_ANSWER, rrl) if not isinstance(ret, bool): set_error() if ret != True: set_error() except: set_error() try: ret = pkt.push_rr_list("bad argument", rrl) set_error() except TypeError as e: pass except: set_error() try: ret = pkt.push_rr_list(ldns.LDNS_SECTION_ANSWER, "bad argument") set_error() except TypeError as e: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".qdcount()" pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_QR | ldns.LDNS_AD) try: ret = pkt.qdcount() if (not isinstance(ret, int)) and (not isinstance(ret, long)): set_error() if ret != 1: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".qr()" pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_QR | ldns.LDNS_AA) try: ret = pkt.qr() if not isinstance(ret, bool): set_error() if ret != True: set_error() except: set_error() pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_AA) try: ret = pkt.qr() if not isinstance(ret, bool): set_error() if ret != False: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".querytime()" pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_QR | ldns.LDNS_AD) try: ret = pkt.querytime() if (not isinstance(ret, int)) and (not isinstance(ret, long)): set_error() if ret != 0: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".question()" pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_QR | ldns.LDNS_AD) try: ret = pkt.question() if not isinstance(ret, ldns.ldns_rr_list): set_error() if ret.rr_count() != 1: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".ra()" pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_QR | ldns.LDNS_RA) try: ret = pkt.ra() if not isinstance(ret, bool): set_error() if ret != True: set_error() except: set_error() pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_QR) try: ret = pkt.ra() if not isinstance(ret, bool): set_error() if ret != False: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".rcode2str()" pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_QR | ldns.LDNS_RA) try: ret = pkt.rcode2str() if not isinstance(ret, str): set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".rd()" pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_QR | ldns.LDNS_RD) try: ret = pkt.rd() if not isinstance(ret, bool): set_error() if ret != True: set_error() except: set_error() pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_QR) try: ret = pkt.rd() if not isinstance(ret, bool): set_error() if ret != False: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".reply_type()" pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_QR | ldns.LDNS_RD) try: ret = pkt.reply_type() if ret != ldns.LDNS_PACKET_ANSWER: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".rr()" pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz", ldns.LDNS_RR_TYPE_A, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_QR | ldns.LDNS_RD) rr = ldns.ldns_rr.new_frm_str("test1 600 IN A 0.0.0.0") pkt.push_rr(ldns.LDNS_SECTION_ANSWER, rr) try: ret = pkt.rr(ldns.LDNS_SECTION_ANSWER, rr) if not isinstance(ret, bool): set_error() if ret != True: set_error() except: set_error() try: ret = pkt.rr(ldns.LDNS_SECTION_QUESTION, rr) if not isinstance(ret, bool): set_error() if ret != False: set_error() except: set_error() try: ret = pkt.rr("bad argument", rr) set_error() except TypeError as e: pass except: set_error() try: ret = pkt.rr(ldns.LDNS_SECTION_QUESTION, "bad argument") set_error() except TypeError as e: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".rr_list_by_name()" pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz", ldns.LDNS_RR_TYPE_A, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_QR | ldns.LDNS_RD) rr = ldns.ldns_rr.new_frm_str("test1 600 IN A 0.0.0.0") pkt.push_rr(ldns.LDNS_SECTION_ANSWER, rr) rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "test1") try: ret = pkt.rr_list_by_name(rdf, ldns.LDNS_SECTION_ANSWER) if not isinstance(ret, ldns.ldns_rr_list): set_error() except: set_error() try: ret = pkt.rr_list_by_name(rdf, ldns.LDNS_SECTION_QUESTION) if ret != None: set_error() except: set_error() try: ret = pkt.rr_list_by_name("bad argument", ldns.LDNS_SECTION_ANSWER) set_error() except TypeError as e: pass except: set_error() try: ret = pkt.rr_list_by_name(rdf, "bad argument") set_error() except TypeError as e: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".rr_list_by_name_and_type()" pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz.", ldns.LDNS_RR_TYPE_A, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_QR | ldns.LDNS_RD) rr = ldns.ldns_rr.new_frm_str("test1 600 IN A 0.0.0.0") pkt.push_rr(ldns.LDNS_SECTION_ANSWER, rr) rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "test1") try: ret = pkt.rr_list_by_name_and_type(rdf, ldns.LDNS_RR_TYPE_A, ldns.LDNS_SECTION_ANSWER) if not isinstance(ret, ldns.ldns_rr_list): set_error() except: set_error() try: ret = pkt.rr_list_by_name_and_type(rdf, ldns.LDNS_RR_TYPE_AAAA, ldns.LDNS_SECTION_ANSWER) if ret != None: set_error() except: set_error() #try: # ret = pkt.rr_list_by_name_and_type("bad argument", ldns.LDNS_RR_TYPE_A, ldns.LDNS_SECTION_ANSWER) # set_error() #except TypeError as e: # pass #except: # set_error() try: ret = pkt.rr_list_by_name_and_type(rdf, "bad argument", ldns.LDNS_SECTION_ANSWER) set_error() except TypeError as e: pass except: set_error() try: ret = pkt.rr_list_by_name_and_type(rdf, ldns.LDNS_RR_TYPE_A, "bad argument") set_error() except TypeError as e: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".rr_list_by_type()" pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz.", ldns.LDNS_RR_TYPE_A, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_QR | ldns.LDNS_RD) rr = ldns.ldns_rr.new_frm_str("test1 600 IN A 0.0.0.0") pkt.push_rr(ldns.LDNS_SECTION_ANSWER, rr) try: ret = pkt.rr_list_by_type(ldns.LDNS_RR_TYPE_A, ldns.LDNS_SECTION_ANSWER) if not isinstance(ret, ldns.ldns_rr_list): set_error() except: set_error() try: ret = pkt.rr_list_by_type(ldns.LDNS_RR_TYPE_AAAA, ldns.LDNS_SECTION_ANSWER) if ret != None: set_error() except: set_error() try: ret = pkt.rr_list_by_type("bad argument", ldns.LDNS_SECTION_ANSWER) set_error() except TypeError as e: pass except: set_error() try: ret = pkt.rr_list_by_type(ldns.LDNS_RR_TYPE_A, "bad argument") set_error() except TypeError as e: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".safe_push_rr()" pkt = ldns.ldns_pkt.new() rr = ldns.ldns_rr.new_frm_str("test1 600 IN A 0.0.0.0") try: ret = pkt.safe_push_rr(ldns.LDNS_SECTION_ANSWER, rr) if not isinstance(ret, bool): set_error() if ret != True: set_error() except: set_error() try: ret = pkt.safe_push_rr(ldns.LDNS_SECTION_ANSWER, rr) if not isinstance(ret, bool): set_error() if ret != False: set_error() except: set_error() try: ret = pkt.safe_push_rr("bad argument", rr) set_error() except TypeError as e: pass except: set_error() try: ret = pkt.safe_push_rr(ldns.LDNS_SECTION_ANSWER, "bad argument") set_error() except TypeError as e: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".safe_push_rr_list()" pkt = ldns.ldns_pkt.new() rrl = ldns.ldns_rr_list.new() rr = ldns.ldns_rr.new_frm_str("test1 600 IN A 0.0.0.0") rrl.push_rr(rr) try: ret = pkt.safe_push_rr_list(ldns.LDNS_SECTION_ANSWER, rrl) if not isinstance(ret, bool): set_error() if ret != True: set_error() except: set_error() try: ret = pkt.safe_push_rr_list(ldns.LDNS_SECTION_ANSWER, rrl) if not isinstance(ret, bool): set_error() if ret != False: set_error() except: set_error() try: ret = pkt.safe_push_rr_list("bad argument", rrl) set_error() except TypeError as e: pass except: set_error() try: ret = pkt.safe_push_rr_list(ldns.LDNS_SECTION_ANSWER, "bad argument") set_error() except TypeError as e: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".set_aa()" pkt = ldns.ldns_pkt.new() try: pkt.set_aa(True) if pkt.aa() != True: set_error() except: set_error() try: pkt.set_aa(False) if pkt.aa() != False: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".set_ad()" pkt = ldns.ldns_pkt.new() try: pkt.set_ad(True) if pkt.ad() != True: set_error() except: set_error() try: pkt.set_ad(False) if pkt.ad() != False: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".set_additional()" pkt = ldns.ldns_pkt.new() rrl = ldns.ldns_rr_list.new() rr = ldns.ldns_rr.new_frm_str("test1 600 IN A 0.0.0.0") rrl.push_rr(rr) try: pkt.set_additional(rrl) if not isinstance(pkt.additional() , ldns.ldns_rr_list): set_error() if pkt.additional() != rrl: set_error() except: set_error() try: pkt.set_additional("bad argument") set_error() except TypeError as e: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".set_ancount()" pkt = ldns.ldns_pkt.new() try: pkt.set_ancount(1) ret = pkt.ancount() if ret != 1: set_error() except: set_error() try: pkt.set_ancount("bad argument") set_error() except TypeError as e: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".set_answer()" pkt = ldns.ldns_pkt.new() rrl = ldns.ldns_rr_list.new() rr = ldns.ldns_rr.new_frm_str("test1 600 IN A 0.0.0.0") rrl.push_rr(rr) try: pkt.set_answer(rrl) if not isinstance(pkt.additional() , ldns.ldns_rr_list): set_error() if pkt.answer() != rrl: set_error() except: set_error() try: pkt.set_answer("bad argument") set_error() except TypeError as e: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".set_answerfrom()" pkt = ldns.ldns_pkt.new() rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_A, "127.0.0.1") try: pkt.set_answerfrom(rdf) ret = pkt.answerfrom() if ret != rdf: set_error() except: set_error() try: pkt.set_answerfrom("bad argument") set_error() except TypeError as e: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".set_arcount()" pkt = ldns.ldns_pkt.new() try: pkt.set_arcount(1) ret = pkt.arcount() if ret != 1: set_error() except: set_error() try: pkt.set_arcount("bad argument") set_error() except TypeError as e: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".set_authority()" pkt = ldns.ldns_pkt.new() rrl = ldns.ldns_rr_list.new() rr = ldns.ldns_rr.new_frm_str("test1 600 IN A 0.0.0.0") rrl.push_rr(rr) try: pkt.set_authority(rrl) if not isinstance(pkt.additional() , ldns.ldns_rr_list): set_error() if pkt.authority() != rrl: set_error() except: set_error() try: pkt.set_authority("bad argument") set_error() except TypeError as e: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".set_cd()" pkt = ldns.ldns_pkt.new() try: pkt.set_cd(True) if pkt.cd() != True: set_error() except: set_error() try: pkt.set_cd(False) if pkt.cd() != False: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".set_edns_data()" pkt = ldns.ldns_pkt.new() rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_A, "127.0.0.1") try: pkt.set_edns_data(rdf) ret = pkt.edns_data() if ret != rdf: set_error() except: set_error() try: pkt.set_edns_data("bad argument") set_error() except TypeError as e: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".set_edns_do()" pkt = ldns.ldns_pkt.new() try: pkt.set_edns_do(True) if pkt.edns_do() != True: set_error() except: set_error() try: pkt.set_edns_do(False) if pkt.edns_do() != False: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".set_edns_extended_rcode()" pkt = ldns.ldns_pkt.new() try: pkt.set_edns_extended_rcode(8) ret = pkt.edns_extended_rcode() if ret != 8: set_error() except: set_error() try: pkt.set_edns_extended_rcode("bad argument") set_error() except TypeError as e: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".set_edns_udp_size()" pkt = ldns.ldns_pkt.new() try: pkt.set_edns_udp_size(4096) ret = pkt.edns_udp_size() if ret != 4096: set_error() except: set_error() try: pkt.set_edns_udp_size("bad argument") set_error() except TypeError as e: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".set_edns_version()" pkt = ldns.ldns_pkt.new() try: pkt.set_edns_version(8) ret = pkt.edns_version() if ret != 8: set_error() except: set_error() try: pkt.set_edns_version("bad argument") set_error() except TypeError as e: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".set_edns_z()" pkt = ldns.ldns_pkt.new() try: pkt.set_edns_z(4096) ret = pkt.edns_z() if ret != 4096: set_error() except: set_error() try: pkt.set_edns_z("bad argument") set_error() except TypeError as e: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".set_flags()" pkt = ldns.ldns_pkt.new() try: ret = pkt.set_flags(ldns.LDNS_AA | ldns.LDNS_AD) if not isinstance(ret, bool): set_error() if ret != True: set_error() except: set_error() try: pkt.set_flags("bad argument") set_error() except TypeError as e: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".set_id()" pkt = ldns.ldns_pkt.new() try: pkt.set_id(4096) ret = pkt.id() if ret != 4096: set_error() except: set_error() try: pkt.set_id("bad argument") set_error() except TypeError as e: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".set_nscount()" pkt = ldns.ldns_pkt.new() try: pkt.set_nscount(1) ret = pkt.nscount() if ret != 1: set_error() except: set_error() try: pkt.set_nscount("bad argument") set_error() except TypeError as e: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".set_opcode()" pkt = ldns.ldns_pkt.new() try: pkt.set_opcode(ldns.LDNS_PACKET_QUERY) ret = pkt.get_opcode() if ret != ldns.LDNS_PACKET_QUERY: set_error() except: set_error() try: pkt.set_opcode("bad argument") set_error() except TypeError as e: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".set_qdcount()" pkt = ldns.ldns_pkt.new() try: pkt.set_qdcount(10) ret = pkt.qdcount() if ret != 10: set_error() except: set_error() try: pkt.set_qdcount("bad argument") set_error() except TypeError as e: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".set_qr()" pkt = ldns.ldns_pkt.new() try: pkt.set_qr(True) if pkt.qr() != True: set_error() except: set_error() try: pkt.set_qr(False) if pkt.qr() != False: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".set_querytime()" pkt = ldns.ldns_pkt.new() try: pkt.set_querytime(65536) ret = pkt.querytime() if ret != 65536: set_error() except: set_error() try: pkt.set_querytime("bad argument") set_error() except TypeError as e: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".set_question()" pkt = ldns.ldns_pkt.new() rrl = ldns.ldns_rr_list.new() rr = ldns.ldns_rr.new_frm_str("test1 600 IN A 0.0.0.0") rrl.push_rr(rr) try: pkt.set_question(rrl) if not isinstance(pkt.additional() , ldns.ldns_rr_list): set_error() if pkt.question() != rrl: set_error() except: set_error() try: pkt.set_question("bad argument") set_error() except TypeError as e: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".set_ra()" pkt = ldns.ldns_pkt.new() try: pkt.set_ra(True) if pkt.ra() != True: set_error() except: set_error() try: pkt.set_ra(False) if pkt.ra() != False: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".set_random_id()" pkt = ldns.ldns_pkt.new() try: pkt.set_random_id() except: set_error() #if not error_detected: if True: method_name = class_name + ".set_rcode()" pkt = ldns.ldns_pkt.new() try: pkt.set_rcode(127) ret = pkt.get_rcode() if ret != 127: set_error() except: set_error() try: pkt.set_rcode("bad argument") set_error() except TypeError as e: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".set_rd()" pkt = ldns.ldns_pkt.new() try: pkt.set_rd(True) if pkt.rd() != True: set_error() except: set_error() try: pkt.set_rd(False) if pkt.rd() != False: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".set_section_count()" pkt = ldns.ldns_pkt.new() try: pkt.set_section_count(ldns.LDNS_PACKET_QUESTION, 4096) ret = pkt.qdcount() if ret != 4096: set_error() except: set_error() try: pkt.set_section_count("bad argument", 4096) set_error() except TypeError as e: pass except: set_error() try: pkt.set_section_count(ldns.LDNS_PACKET_QUESTION, "bad argument") set_error() except TypeError as e: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".set_size()" pkt = ldns.ldns_pkt.new() try: pkt.set_size(512) ret = pkt.size() if ret != 512: set_error() except: set_error() try: pkt.set_size("bad argument") set_error() except TypeError as e: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".set_tc()" pkt = ldns.ldns_pkt.new() try: pkt.set_tc(True) if pkt.tc() != True: set_error() except: set_error() try: pkt.set_tc(False) if pkt.tc() != False: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".set_timestamp()" sys.stderr.write("%s not tested.\n" % (method_name)) #if not error_detected: if True: method_name = class_name + ".set_tsig()" pkt = ldns.ldns_pkt.new() rr = ldns.ldns_rr.new_frm_str("test1 600 IN A 0.0.0.0") try: pkt.set_tsig(rr) ret = pkt.tsig() if ret != rr: set_error() except: set_error() try: pkt.set_tsig("bad argument") set_error() except TypeError as e: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".size()" pkt = ldns.ldns_pkt.new() pkt.set_size(512) try: ret = pkt.size() if (not isinstance(ret, int)) and (not isinstance(ret, long)): set_error() if ret != 512: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".tc()" pkt = ldns.ldns_pkt.new() pkt.set_tc(True) try: ret = pkt.tc() if not isinstance(ret, bool): set_error() if ret != True: set_error() except: set_error() pkt.set_tc(False) try: ret = pkt.tc() if not isinstance(ret, bool): set_error() if ret != False: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".timestamp()" sys.stderr.write("%s not tested.\n" % (method_name)) #if not error_detected: if True: method_name = class_name + ".tsig()" pkt = ldns.ldns_pkt.new() try: ret = pkt.tsig() if ret != None: set_error() except: set_error() rr = ldns.ldns_rr.new_frm_str("test1 600 IN A 0.0.0.0") pkt.set_tsig(rr) try: ret = pkt.tsig() if not isinstance(ret, ldns.ldns_rr): set_error() if ret != rr: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".update_pkt_tsig_add()" pkt = ldns.ldns_pkt.new() resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") try: ret = pkt.update_pkt_tsig_add(resolver) if ret != ldns.LDNS_STATUS_OK: set_error() except: set_error() try: ret = pkt.update_pkt_tsig_add("bad argument") set_error() except TypeError as e: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".update_prcount()" pkt = ldns.ldns_pkt.new() try: ret = pkt.update_prcount() if (not isinstance(ret, int)) and (not isinstance(ret, long)): set_error() if ret != 0: set_error() except: set_error() pkt.update_set_prcount(127) try: ret = pkt.update_prcount() if (not isinstance(ret, int)) and (not isinstance(ret, long)): set_error() if ret != 127: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".update_set_adcount()" pkt = ldns.ldns_pkt.new() try: pkt.update_set_adcount(4096) ret = pkt.update_ad() if ret != 4096: set_error() except: set_error() try: pkt.update_set_adcount("bad argument") set_error() except TypeError as e: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".update_set_prcount()" pkt = ldns.ldns_pkt.new() try: pkt.update_set_prcount(4096) ret = pkt.update_prcount() if ret != 4096: set_error() except: set_error() try: pkt.update_set_prcount("bad argument") set_error() except TypeError as e: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".update_set_upcount()" pkt = ldns.ldns_pkt.new() try: pkt.update_set_upcount(4096) ret = pkt.update_upcount() if ret != 4096: set_error() except: set_error() try: pkt.update_set_upcount("bad argument") set_error() except TypeError as e: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".update_set_zo()" pkt = ldns.ldns_pkt.new() try: pkt.update_set_zo(4096) ret = pkt.update_zocount() if ret != 4096: set_error() except: set_error() try: pkt.update_set_zo("bad argument") set_error() except TypeError as e: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".update_upcount()" pkt = ldns.ldns_pkt.new() try: ret = pkt.update_upcount() if (not isinstance(ret, int)) and (not isinstance(ret, long)): set_error() if ret != 0: set_error() except: set_error() pkt.update_set_upcount(127) try: ret = pkt.update_upcount() if (not isinstance(ret, int)) and (not isinstance(ret, long)): set_error() if ret != 127: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".update_zocount()" pkt = ldns.ldns_pkt.new() try: ret = pkt.update_zocount() if (not isinstance(ret, int)) and (not isinstance(ret, long)): set_error() if ret != 0: set_error() except: set_error() pkt.update_set_zo(127) try: ret = pkt.update_zocount() if (not isinstance(ret, int)) and (not isinstance(ret, long)): set_error() if ret != 127: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".write_to_buffer()" pkt = pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_QR | ldns.LDNS_AA) buf = buf = ldns.ldns_buffer(4096) try: ret = pkt.write_to_buffer(buf) if ret != ldns.LDNS_STATUS_OK: set_error() except: set_error() if not error_detected: sys.stdout.write("%s: passed.\n" % (os.path.basename(__file__))) else: sys.stdout.write("%s: errors detected.\n" % (os.path.basename(__file__))) sys.exit(1) ldns-1.6.17/contrib/python/examples/ldns-keygen.py0000775000175100017510000000176412264060151021517 0ustar willemwillem#!/usr/bin/python # # This example shows how to generate public/private key pair # import ldns algorithm = ldns.LDNS_SIGN_DSA bits = 512 ldns.ldns_init_random(open("/dev/urandom","rb"), (bits+7)//8) domain = ldns.ldns_dname("example.") #generate a new key key = ldns.ldns_key.new_frm_algorithm(algorithm, bits); print key #set owner key.set_pubkey_owner(domain) #create the public from the ldns_key pubkey = key.key_to_rr() #previous command is equivalent to # pubkey = ldns.ldns_key2rr(key) print pubkey #calculate and set the keytag key.set_keytag(ldns.ldns_calc_keytag(pubkey)) #build the DS record ds = ldns.ldns_key_rr2ds(pubkey, ldns.LDNS_SHA1) print ds owner, tag = pubkey.owner(), key.keytag() #write public key to .key file fw = open("key-%s-%d.key" % (owner,tag), "wb") pubkey.print_to_file(fw) #write private key to .priv file fw = open("key-%s-%d.private" % (owner,tag), "wb") key.print_to_file(fw) #write DS to .ds file fw = open("key-%s-%d.ds" % (owner,tag), "wb") ds.print_to_file(fw) ldns-1.6.17/contrib/python/examples/test_rr.py0000775000175100017510000017524012264060151020762 0ustar willemwillem#!/usr/bin/env python # # ldns_rr and ldns_rr_list testing script. # # Do not use constructs that differ between Python 2 and 3. # Use write on stdout or stderr. # import ldns import sys import os import inspect class_name = "ldns_rr" method_name = None error_detected = False temp_fname = "tmp_rr.txt" def set_error(): """ Writes an error message and sets error flag. """ global class_name global method_name global error_detected error_detected = True sys.stderr.write("(line %d): malfunctioning method %s.\n" % \ (inspect.currentframe().f_back.f_lineno, method_name)) #if not error_detected: if True: method_name = class_name + ".[comparison operators]" rr1 = ldns.ldns_rr.new_frm_str("test1 600 IN A 0.0.0.0") rr2 = ldns.ldns_rr.new_frm_str("test2 600 IN A 1.1.1.1") try: ret = rr1 < rr2 if not isinstance(ret, bool): set_error() if ret != True: set_error() except: set_error() try: ret = rr2 < rr1 if not isinstance(ret, bool): set_error() if ret != False: set_error() except: set_error() try: ret = rr1 <= rr2 if not isinstance(ret, bool): set_error() if ret != True: set_error() except: set_error() try: ret = rr2 <= rr1 if not isinstance(ret, bool): set_error() if ret != False: set_error() except: set_error() try: ret = rr1 == rr2 if not isinstance(ret, bool): set_error() if ret != False: set_error() except: set_error() try: ret = rr1 == rr1 if not isinstance(ret, bool): set_error() if ret != True: set_error() except: set_error() try: ret = rr1 != rr2 if not isinstance(ret, bool): set_error() if ret != True: set_error() except: set_error() try: ret = rr1 != rr1 if not isinstance(ret, bool): set_error() if ret != False: set_error() except: set_error() try: ret = rr1 > rr2 if not isinstance(ret, bool): set_error() if ret != False: set_error() except: set_error() try: ret = rr2 > rr1 if not isinstance(ret, bool): set_error() if ret != True: set_error() except: set_error() try: ret = rr1 >= rr2 if not isinstance(ret, bool): set_error() if ret != False: set_error() except: set_error() try: ret = rr2 >= rr1 if not isinstance(ret, bool): set_error() if ret != True: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + "__init__()" try: rr = ldns.ldns_rr() set_error() except Exception: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".a_address()" rr = ldns.ldns_rr.new_frm_str("www.nic.cz 600 IN A 217.31.205.50") try: address = rr.a_address() if not isinstance(address, ldns.ldns_rdf): set_error() if address == None: set_error() except: set_error() rr = ldns.ldns_rr.new_frm_str("www.nic.cz 600 IN AAAA 2002:d91f:cd32::1") try: address = rr.a_address() if not isinstance(address, ldns.ldns_rdf): set_error() if address == None: set_error() except: set_error() rr = ldns.ldns_rr.new_frm_str("www.nic.cz 600 IN TXT text") try: address = rr.a_address() if isinstance(address, ldns.ldns_rdf): set_error() if address != None: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".a_set_address()" rdf = ldns.ldns_rdf.new_frm_str("127.0.0.1", ldns.LDNS_RDF_TYPE_A) rr = ldns.ldns_rr.new_frm_str("test 600 IN A 0.0.0.0") try: ret = rr.a_set_address(rdf) if not isinstance(ret, bool): set_error() if ret != True: set_error() except: set_error() rdf = ldns.ldns_rdf.new_frm_str("::1", ldns.LDNS_RDF_TYPE_AAAA) rr = ldns.ldns_rr.new_frm_str("test 600 IN AAAA ::") try: ret = rr.a_set_address(rdf) if not isinstance(ret, bool): set_error() if ret != True: set_error() except: set_error() try: ret = rr.a_set_address("") set_error() except TypeError: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".class_by_name()" try: ret = ldns.ldns_rr.class_by_name("IN") if not isinstance(ret, int): set_error() if ret != ldns.LDNS_RR_CLASS_IN: set_error() except: set_error() method_name = class_name + ".class_by_name()" try: ret = ldns.ldns_rr.class_by_name("AA") if not isinstance(ret, int): set_error() if ret != 0: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".clone()" rr = ldns.ldns_rr.new_frm_str("test 600 IN TXT text") try: ret = rr.clone() if not isinstance(ret, ldns.ldns_rr): set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".compare_ds()" pubkey1 = ldns.ldns_rr.new_frm_str("example1. 3600 IN DNSKEY 256 3 3 APw7tG8Nf7MYXjt2Y6DmyWUVxVy73bRKvKbKoGXhAXJx2vbcGGxfXsScT0i4FIC2wsJ/8zy/otB5vymm3JHBf2+7cQvRdp12UMLAnzlfrbgZUpvV36D+q6ch7kbmFzaBfwRjOKhnZkRLCcMYPAdX1SrgKVNXaOzAl9KytbzGQs5MKEHU+a0PAwKfIvEsS/+pW6gKgBnL0uy4Gr5cYJ5rk48iwFXOlZ/B30gUS5dD+rNRJuR0ZgEkxtVIPVxxhQPtEI53JhlJ2nEy0CqNW88nYLmX402b ;{id = 34898 (zsk), size = 512b}") pubkey2 = ldns.ldns_rr.new_frm_str("example2. 3600 IN DNSKEY 256 3 3 ALBoD2+1xYpzrE7gjU5EwwBHG2HNiD1977LDZGh+8VNifMGjixMpgUN6xRhFjvRSsC/seMVXmUGq+msUDF2pHnUHbW/dbQbBxVMAqx2jT0LTvAx5wUPGltHHsa92K8VdzD8ynTFwPvjmk7g3hqRRzt4UTQIeK7DYgrOOgvDv+DYWVQctLwYP0ktm85b4cMtIUNRIf/N+K25pfK6BM/tHN8HOm4ECvm2U9zqHHfnxJFdiNK2PydkNeJZZGUOubSFVvaOMhZoEeAgkm3q5QcwXHsLAhacZ ;{id = 30944 (zsk), size = 512b}") ds1 = ldns.ldns_key_rr2ds(pubkey1, ldns.LDNS_SHA1) ds2 = ldns.ldns_key_rr2ds(pubkey2, ldns.LDNS_SHA1) try: ret = pubkey1.compare_ds(pubkey1) if not isinstance(ret, bool): set_error() if ret != True: set_error() except: set_error() try: ret = pubkey1.compare_ds(pubkey2) if not isinstance(ret, bool): set_error() if ret != False: set_error() except: set_error() try: ret = pubkey1.compare_ds(ds1) if not isinstance(ret, bool): set_error() if ret != True: set_error() except: set_error() try: ret = pubkey1.compare_ds(ds2) if not isinstance(ret, bool): set_error() if ret != False: set_error() except: set_error() try: pubkey1.compare_ds("") set_error() except TypeError: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".compare_no_rdata()" rr1 = ldns.ldns_rr.new_frm_str("test 600 IN A 0.0.0.0") rr2 = ldns.ldns_rr.new_frm_str("test 600 IN AAAA ::") try: ret = rr1.compare_no_rdata(rr2) if not isinstance(ret, int): set_error() if ret != -27: set_error() except: set_error() try: rr1.compare_no_rdata("") set_error() except TypeError: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".dnskey_algorithm()" pubkey = ldns.ldns_rr.new_frm_str("example1. 3600 IN DNSKEY 256 3 3 APw7tG8Nf7MYXjt2Y6DmyWUVxVy73bRKvKbKoGXhAXJx2vbcGGxfXsScT0i4FIC2wsJ/8zy/otB5vymm3JHBf2+7cQvRdp12UMLAnzlfrbgZUpvV36D+q6ch7kbmFzaBfwRjOKhnZkRLCcMYPAdX1SrgKVNXaOzAl9KytbzGQs5MKEHU+a0PAwKfIvEsS/+pW6gKgBnL0uy4Gr5cYJ5rk48iwFXOlZ/B30gUS5dD+rNRJuR0ZgEkxtVIPVxxhQPtEI53JhlJ2nEy0CqNW88nYLmX402b ;{id = 34898 (zsk), size = 512b}") try: ret = pubkey.dnskey_algorithm() if not isinstance(ret, ldns.ldns_rdf): set_error() except: set_error() rr = ldns.ldns_rr.new_frm_str("test 600 IN A 0.0.0.0") try: ret = rr.dnskey_algorithm() if isinstance(ret, ldns.ldns_rdf): set_error() if ret != None: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".dnskey_flags()" pubkey = ldns.ldns_rr.new_frm_str("example1. 3600 IN DNSKEY 256 3 3 APw7tG8Nf7MYXjt2Y6DmyWUVxVy73bRKvKbKoGXhAXJx2vbcGGxfXsScT0i4FIC2wsJ/8zy/otB5vymm3JHBf2+7cQvRdp12UMLAnzlfrbgZUpvV36D+q6ch7kbmFzaBfwRjOKhnZkRLCcMYPAdX1SrgKVNXaOzAl9KytbzGQs5MKEHU+a0PAwKfIvEsS/+pW6gKgBnL0uy4Gr5cYJ5rk48iwFXOlZ/B30gUS5dD+rNRJuR0ZgEkxtVIPVxxhQPtEI53JhlJ2nEy0CqNW88nYLmX402b ;{id = 34898 (zsk), size = 512b}") try: ret = pubkey.dnskey_flags() if not isinstance(ret, ldns.ldns_rdf): set_error() except: set_error() rr = ldns.ldns_rr.new_frm_str("test 600 IN A 0.0.0.0") try: ret = rr.dnskey_flags() if isinstance(ret, ldns.ldns_rdf): set_error() if ret != None: set_error() except: set_errror() #if not error_detected: if True: method_name = class_name + ".dnskey_key()" pubkey = ldns.ldns_rr.new_frm_str("example1. 3600 IN DNSKEY 256 3 3 APw7tG8Nf7MYXjt2Y6DmyWUVxVy73bRKvKbKoGXhAXJx2vbcGGxfXsScT0i4FIC2wsJ/8zy/otB5vymm3JHBf2+7cQvRdp12UMLAnzlfrbgZUpvV36D+q6ch7kbmFzaBfwRjOKhnZkRLCcMYPAdX1SrgKVNXaOzAl9KytbzGQs5MKEHU+a0PAwKfIvEsS/+pW6gKgBnL0uy4Gr5cYJ5rk48iwFXOlZ/B30gUS5dD+rNRJuR0ZgEkxtVIPVxxhQPtEI53JhlJ2nEy0CqNW88nYLmX402b ;{id = 34898 (zsk), size = 512b}") try: ret = pubkey.dnskey_key() if not isinstance(ret, ldns.ldns_rdf): set_error() except: set_error() rr = ldns.ldns_rr.new_frm_str("test 600 IN A 0.0.0.0") try: ret = rr.dnskey_key() if isinstance(ret, ldns.ldns_rdf): set_error() if ret != None: set_error() except: set_errror() #if not error_detected: if True: method_name = class_name + ".dnskey_key_size()" pubkey = ldns.ldns_rr.new_frm_str("example1. 3600 IN DNSKEY 256 3 3 APw7tG8Nf7MYXjt2Y6DmyWUVxVy73bRKvKbKoGXhAXJx2vbcGGxfXsScT0i4FIC2wsJ/8zy/otB5vymm3JHBf2+7cQvRdp12UMLAnzlfrbgZUpvV36D+q6ch7kbmFzaBfwRjOKhnZkRLCcMYPAdX1SrgKVNXaOzAl9KytbzGQs5MKEHU+a0PAwKfIvEsS/+pW6gKgBnL0uy4Gr5cYJ5rk48iwFXOlZ/B30gUS5dD+rNRJuR0ZgEkxtVIPVxxhQPtEI53JhlJ2nEy0CqNW88nYLmX402b ;{id = 34898 (zsk), size = 512b}") try: ret = pubkey.dnskey_key_size() if (not isinstance(ret, int)) and (not isinstance(ret, long)): set_error() if ret != 512: set_error() except: set_error() rr = ldns.ldns_rr.new_frm_str("test 600 IN A 0.0.0.0") try: ret = rr.dnskey_key_size() if (not isinstance(ret, int)) and (not isinstance(ret, long)): set_error() if ret != 0: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".dnskey_key_size_raw()" sys.stderr.write("%s not tested.\n" % (method_name)) #if not error_detected: if True: method_name = class_name + ".dnskey_protocol()" pubkey = ldns.ldns_rr.new_frm_str("example1. 3600 IN DNSKEY 256 3 3 APw7tG8Nf7MYXjt2Y6DmyWUVxVy73bRKvKbKoGXhAXJx2vbcGGxfXsScT0i4FIC2wsJ/8zy/otB5vymm3JHBf2+7cQvRdp12UMLAnzlfrbgZUpvV36D+q6ch7kbmFzaBfwRjOKhnZkRLCcMYPAdX1SrgKVNXaOzAl9KytbzGQs5MKEHU+a0PAwKfIvEsS/+pW6gKgBnL0uy4Gr5cYJ5rk48iwFXOlZ/B30gUS5dD+rNRJuR0ZgEkxtVIPVxxhQPtEI53JhlJ2nEy0CqNW88nYLmX402b ;{id = 34898 (zsk), size = 512b}") try: ret = pubkey.dnskey_protocol() if not isinstance(ret, ldns.ldns_rdf): set_error() except: set_error() rr = ldns.ldns_rr.new_frm_str("test 600 IN A 0.0.0.0") try: ret = rr.dnskey_protocol() if isinstance(ret, ldns.ldns_rdf): set_error() if ret != None: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".dnskey_set_algorithm()" pubkey = ldns.ldns_rr.new_frm_str("example1. 3600 IN DNSKEY 256 3 3 APw7tG8Nf7MYXjt2Y6DmyWUVxVy73bRKvKbKoGXhAXJx2vbcGGxfXsScT0i4FIC2wsJ/8zy/otB5vymm3JHBf2+7cQvRdp12UMLAnzlfrbgZUpvV36D+q6ch7kbmFzaBfwRjOKhnZkRLCcMYPAdX1SrgKVNXaOzAl9KytbzGQs5MKEHU+a0PAwKfIvEsS/+pW6gKgBnL0uy4Gr5cYJ5rk48iwFXOlZ/B30gUS5dD+rNRJuR0ZgEkxtVIPVxxhQPtEI53JhlJ2nEy0CqNW88nYLmX402b ;{id = 34898 (zsk), size = 512b}") rdf = ldns.ldns_rdf.new_frm_str("3", ldns.LDNS_RDF_TYPE_ALG) try: ret = pubkey.dnskey_set_algorithm(rdf) if not isinstance(ret, bool): set_error() if ret != True: set_error() except: set_error() # rdf = ldns.ldns_rdf.new_frm_str("0.0.0.0", ldns.LDNS_RDF_TYPE_A) # try: # ret = pubkey.dnskey_set_algorithm(rdf) # if not isinstance(ret, bool): # set_error() # if ret != False: # set_error() # except: # set_error() try: ret = pubkey.dnskey_set_algorithm("") set_error() except TypeError: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".dnskey_set_flags()" pubkey = ldns.ldns_rr.new_frm_str("example1. 3600 IN DNSKEY 256 3 3 APw7tG8Nf7MYXjt2Y6DmyWUVxVy73bRKvKbKoGXhAXJx2vbcGGxfXsScT0i4FIC2wsJ/8zy/otB5vymm3JHBf2+7cQvRdp12UMLAnzlfrbgZUpvV36D+q6ch7kbmFzaBfwRjOKhnZkRLCcMYPAdX1SrgKVNXaOzAl9KytbzGQs5MKEHU+a0PAwKfIvEsS/+pW6gKgBnL0uy4Gr5cYJ5rk48iwFXOlZ/B30gUS5dD+rNRJuR0ZgEkxtVIPVxxhQPtEI53JhlJ2nEy0CqNW88nYLmX402b ;{id = 34898 (zsk), size = 512b}") rdf = ldns.ldns_rdf.new_frm_str("256", ldns.LDNS_RDF_TYPE_INT16) try: ret = pubkey.dnskey_set_flags(rdf) if not isinstance(ret, bool): set_error() if ret != True: set_error() except: set_error() # rdf = ldns.ldns_rdf.new_frm_str("0.0.0.0", ldns.LDNS_RDF_TYPE_A) # try: # ret = pubkey.dnskey_set_flags(rdf) # if not isinstance(ret, bool): # set_error() # if ret != False: # set_error() # except: # set_error() try: ret = pubkey.dnskey_set_flags("") set_error() except TypeError: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".dnskey_set_key()" pubkey = ldns.ldns_rr.new_frm_str("example1. 3600 IN DNSKEY 256 3 3 APw7tG8Nf7MYXjt2Y6DmyWUVxVy73bRKvKbKoGXhAXJx2vbcGGxfXsScT0i4FIC2wsJ/8zy/otB5vymm3JHBf2+7cQvRdp12UMLAnzlfrbgZUpvV36D+q6ch7kbmFzaBfwRjOKhnZkRLCcMYPAdX1SrgKVNXaOzAl9KytbzGQs5MKEHU+a0PAwKfIvEsS/+pW6gKgBnL0uy4Gr5cYJ5rk48iwFXOlZ/B30gUS5dD+rNRJuR0ZgEkxtVIPVxxhQPtEI53JhlJ2nEy0CqNW88nYLmX402b ;{id = 34898 (zsk), size = 512b}") rdf = ldns.ldns_rdf.new_frm_str("AMLdYflByPu1GEPCnu9qPTqbnC8n5mftFmFVTFQI10aefiDqp5DLpjBdTxdmz/GACMZh1+YG/iLj0QYX7qRVIl0rR00iREozqj44YwUILHo3cASSRSeAzyidvlGT8QSMKOlOsD33ygtETpzW0XDmzWhyU3bv0O7lnGpbtqdzP/nsZDbdtf5XI0YBdi91HftqtQpIlMtCg+zIzATO4+QWGt0oDX/+jdB7Y/vBahxnz13stNYeGYslGBSZNgpB7HBKlTwB70sprZ8XmNGhj/NixqB6Bzae", ldns.LDNS_RDF_TYPE_B64) try: ret = pubkey.dnskey_set_key(rdf) if not isinstance(ret, bool): set_error() if ret != True: set_error() except: set_error() # rdf = ldns.ldns_rdf.new_frm_str("0.0.0.0", ldns.LDNS_RDF_TYPE_A) # try: # ret = pubkey.dnskey_set_key(rdf) # if not isinstance(ret, bool): # set_error() # if ret != False: # set_error() # except: # set_error() try: ret = pubkey.dnskey_set_key("") set_error() except TypeError: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".dnskey_set_protocol()" pubkey = ldns.ldns_rr.new_frm_str("example1. 3600 IN DNSKEY 256 3 3 APw7tG8Nf7MYXjt2Y6DmyWUVxVy73bRKvKbKoGXhAXJx2vbcGGxfXsScT0i4FIC2wsJ/8zy/otB5vymm3JHBf2+7cQvRdp12UMLAnzlfrbgZUpvV36D+q6ch7kbmFzaBfwRjOKhnZkRLCcMYPAdX1SrgKVNXaOzAl9KytbzGQs5MKEHU+a0PAwKfIvEsS/+pW6gKgBnL0uy4Gr5cYJ5rk48iwFXOlZ/B30gUS5dD+rNRJuR0ZgEkxtVIPVxxhQPtEI53JhlJ2nEy0CqNW88nYLmX402b ;{id = 34898 (zsk), size = 512b}") rdf = ldns.ldns_rdf.new_frm_str("3", ldns.LDNS_RDF_TYPE_INT8) try: ret = pubkey.dnskey_set_protocol(rdf) if not isinstance(ret, bool): set_error() if ret != True: set_error() except: set_error() # rdf = ldns.ldns_rdf.new_frm_str("0.0.0.0", ldns.LDNS_RDF_TYPE_A) # try: # ret = pubkey.dnskey_set_protocol(rdf) # if not isinstance(ret, bool): # set_error() # if ret != False: # set_error() # except: # set_error() try: ret = pubkey.dnskey_set_protocol("") set_error() except TypeError: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".get_class()" rr = ldns.ldns_rr.new_frm_str("test IN A 0.0.0.0", 600) try: ret = rr.get_class() if not isinstance(ret, int): set_error() if ret != ldns.LDNS_RR_CLASS_IN: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".get_class_str()" rr = ldns.ldns_rr.new_frm_str("test CH A 0.0.0.0", 600) try: ret = rr.get_class_str() if not isinstance(ret, str): set_error() if ret != "CH": set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".get_type()" rr = ldns.ldns_rr.new_frm_str("test IN A 0.0.0.0", 600) try: ret = rr.get_type() if not isinstance(ret, int): set_error() if ret != 1: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".get_type_str()" rr = ldns.ldns_rr.new_frm_str("test IN A 0.0.0.0", 600) try: ret = rr.get_type_str() if not isinstance(ret, str): set_error() if ret != "A": set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".is_question()" rr = ldns.ldns_rr.new_frm_str("test IN A 0.0.0.0", 600) try: ret = rr.is_question() if not isinstance(ret, bool): set_error() if ret != False: set_error() except: set_error() rr.set_question(True) try: ret = rr.is_question() if not isinstance(ret, bool): set_error() if ret != True: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".label_count()" rr = ldns.ldns_rr.new_frm_str("test.dom. IN A 0.0.0.0", 600) try: ret = rr.label_count() if (not isinstance(ret, int)) and (not isinstance(ret, long)): set_error() if ret != 2: set_error() except: set_error() rr = ldns.ldns_rr.new_frm_str(". IN A 0.0.0.0", 600) try: ret = rr.label_count() if (not isinstance(ret, int)) and (not isinstance(ret, long)): set_error(string) if ret != 0: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".mx_exchange()" rr = ldns.ldns_rr.new_frm_str("nic.cz. IN MX 15 mail4.nic.cz.", 600) try: ret = rr.mx_exchange() if not isinstance(ret, ldns.ldns_rdf): set_error() except: set_error() rr = ldns.ldns_rr.new_frm_str("test 600 IN A 0.0.0.0") try: ret = rr.mx_exchange() if isinstance(ret, ldns.ldns_rdf): set_error() if ret != None: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".mx_preference()" rr = ldns.ldns_rr.new_frm_str("nic.cz. IN MX 15 mail4.nic.cz.", 600) try: ret = rr.mx_preference() if not isinstance(ret, ldns.ldns_rdf): set_error() except: set_error() rr = ldns.ldns_rr.new_frm_str("test 600 IN A 0.0.0.0") try: ret = rr.mx_preference() if isinstance(ret, ldns.ldns_rdf): set_error() if ret != None: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".new_frm_fp()" f = open(temp_fname, "w") f.write("test 600 IN A 0.0.0.0") f.close() f = open(temp_fname, "r") rr, ttl, origin, prev = ldns.ldns_rr.new_frm_fp(f, origin=ldns.ldns_dname("nic.cz")) try: # Reading past file end. ret = ldns.ldns_rr.new_frm_fp(f, raiseException=False) if ret != None: set_error() except: set_error() try: # Reading past file end. rr, ttl, origin, prev = ldns.ldns_rr.new_frm_fp(f) set_error() except Exception: pass except: set_error() f.close() os.remove(temp_fname) #if not error_detected: if True: method_name = class_name + ".new_frm_fp_l()" f = open(temp_fname, "w") f.write("test 600 IN A 0.0.0.0") f.close() f = open(temp_fname, "r") rr, line, ttl, origin, prev = ldns.ldns_rr.new_frm_fp_l(f, origin=ldns.ldns_dname("nic.cz")) try: # Reading past file end. ret = ldns.ldns_rr.new_frm_fp_l(f, raiseException=False) if ret != None: set_error() except: set_error() try: # Reading past file end. rr, ttl, origin, prev = ldns.ldns_rr.new_frm_fp_l(f) set_error() except Exception: pass except: set_error() f.close() os.remove(temp_fname) #if not error_detected: if True: method_name = class_name + ".new_frm_str()" try: rr = ldns.ldns_rr.new_frm_str("test IN A 0.0.0.0", 600, origin=ldns.ldns_dname("nic.cz")) if not isinstance(rr, ldns.ldns_rr): set_error() except: set_error() try: rr = ldns.ldns_rr.new_frm_str(10) set_error() except TypeError: pass except: set_error() try: rr = ldns.ldns_rr.new_frm_str("") set_error() except Exception: pass except: set_error() try: rr = ldns.ldns_rr.new_frm_str("", raiseException=False) if rr != None: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".new_frm_str_prev()" try: rr, prev = ldns.ldns_rr.new_frm_str_prev("test IN A 0.0.0.0", 600, origin=ldns.ldns_dname("nic.cz")) if not isinstance(rr, ldns.ldns_rr): set_error() # if prev != None: # set_error() except: set_error() try: rr = ldns.ldns_rr.new_frm_str_prev(10) set_error() except TypeError: pass except: set_error() try: rr = ldns.ldns_rr.new_frm_str_prev("") set_error() except Exception: pass except: set_error() try: rr = ldns.ldns_rr.new_frm_str_prev("", raiseException=False) if rr != None: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".new_question_frm_str()" try: rr = ldns.ldns_rr.new_question_frm_str("test IN A", 600, origin=ldns.ldns_dname("nic.cz")) if not isinstance(rr, ldns.ldns_rr): set_error() except: set_error() try: rr = ldns.ldns_rr.new_question_frm_str(10) set_error() except TypeError: pass except: set_error() try: rr = ldns.ldns_rr.new_question_frm_str("") set_error() except Exception: pass except: set_error() try: rr = ldns.ldns_rr.new_question_frm_str("", raiseException=False) if rr != None: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".ns_nsdname()" rr = ldns.ldns_rr.new_frm_str("nic.cz. 1800 IN NS a.ns.nic.cz.") try: ret = rr.ns_nsdname() if not isinstance(ret, ldns.ldns_rdf): set_error() except: set_error() rr = ldns.ldns_rr.new_frm_str("test 600 IN A 0.0.0.0") try: ret = rr.ns_nsdname() if isinstance(ret, ldns.ldns_rdf): set_error() if ret != None: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".owner()" rr = ldns.ldns_rr.new_frm_str("nic.cz. 1800 IN NS a.ns.nic.cz.") try: ret = rr.owner() if not isinstance(ret, ldns.ldns_dname): set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".pop_rdf()" rr = ldns.ldns_rr.new_frm_str("test 600 IN A 0.0.0.0") try: ret = rr.pop_rdf() if not isinstance(ret, ldns.ldns_rdf): set_error() if ret.get_type() != ldns.LDNS_RDF_TYPE_A: set_error() except: set_error() try: ret = rr.pop_rdf() if isinstance(ret, ldns.ldns_rdf): set_error() if ret != None: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".print_to_file()" rr = ldns.ldns_rr.new_frm_str("test 600 IN A 0.0.0.0") f = open(temp_fname, "w") try: rr.print_to_file(f) except: set_error() f.close() f = open(temp_fname, "r") if not f.readline(): set_error() f.close() os.remove(temp_fname) #if not error_detected: if True: method_name = class_name + ".push_rdf()" rr = ldns.ldns_rr.new_frm_str("test 600 IN A 0.0.0.0") rdf = ldns.ldns_rdf.new_frm_str("1.1.1.1", ldns.LDNS_RDF_TYPE_A) try: ret = rr.push_rdf(rdf) if not isinstance(ret, bool): set_error() if ret != True: set_error() except: set_error() try: ret = rr.push_rdf("") set_error() except TypeError: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".rd_count()" rr = ldns.ldns_rr.new_frm_str("test 600 IN A 0.0.0.0") try: ret = rr.rd_count() if (not isinstance(ret, int)) and (not isinstance(ret, long)): set_error() if ret != 1: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".rdf()" rr = ldns.ldns_rr.new_frm_str("test 600 IN A 0.0.0.0") try: ret = rr.rdf(0) if not isinstance(ret, ldns.ldns_rdf): set_error() except: set_error() try: ret = rr.rdf(1) if isinstance(ret, ldns.ldns_rdf): set_error() if ret != None: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".rdfs()" rr = ldns.ldns_rr.new_frm_str("test 600 IN A 0.0.0.0") try: ret = rr.rdfs() if len(list(ret)) != 1: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".rrsig_algorithm()" rr = ldns.ldns_rr.new_frm_str("example. 600 IN RRSIG SOA 3 1 600 20130828153754 20120828153754 19031 example. AIoCFhwZJxIgYOBEyo3cxxWFZEsUPqkxnt38xEl1cFAHHC9iQN9mlEg=") try: ret = rr.rrsig_algorithm() if not isinstance(ret, ldns.ldns_rdf): set_error() except: set_error() rr = ldns.ldns_rr.new_frm_str("test 600 IN A 0.0.0.0") try: ret = rr.rrsig_algorithm() if isinstance(ret, ldns.ldns_rdf): set_error() if ret != None: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".rrsig_expiration()" rr = ldns.ldns_rr.new_frm_str("example. 600 IN RRSIG SOA 3 1 600 20130828153754 20120828153754 19031 example. AIoCFhwZJxIgYOBEyo3cxxWFZEsUPqkxnt38xEl1cFAHHC9iQN9mlEg=") try: ret = rr.rrsig_expiration() if not isinstance(ret, ldns.ldns_rdf): set_error() except: set_error() rr = ldns.ldns_rr.new_frm_str("test 600 IN A 0.0.0.0") try: ret = rr.rrsig_expiration() if isinstance(ret, ldns.ldns_rdf): set_error() if ret != None: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".rrsig_inception()" rr = ldns.ldns_rr.new_frm_str("example. 600 IN RRSIG SOA 3 1 600 20130828153754 20120828153754 19031 example. AIoCFhwZJxIgYOBEyo3cxxWFZEsUPqkxnt38xEl1cFAHHC9iQN9mlEg=") try: ret = rr.rrsig_inception() if not isinstance(ret, ldns.ldns_rdf): set_error() except: set_error() rr = ldns.ldns_rr.new_frm_str("test 600 IN A 0.0.0.0") try: ret = rr.rrsig_inception() if isinstance(ret, ldns.ldns_rdf): set_error() if ret != None: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".rrsig_keytag()" rr = ldns.ldns_rr.new_frm_str("example. 600 IN RRSIG SOA 3 1 600 20130828153754 20120828153754 19031 example. AIoCFhwZJxIgYOBEyo3cxxWFZEsUPqkxnt38xEl1cFAHHC9iQN9mlEg=") try: ret = rr.rrsig_keytag() if not isinstance(ret, ldns.ldns_rdf): set_error() except: set_error() rr = ldns.ldns_rr.new_frm_str("test 600 IN A 0.0.0.0") try: ret = rr.rrsig_keytag() if isinstance(ret, ldns.ldns_rdf): set_error() if ret != None: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".rrsig_labels()" rr = ldns.ldns_rr.new_frm_str("example. 600 IN RRSIG SOA 3 1 600 20130828153754 20120828153754 19031 example. AIoCFhwZJxIgYOBEyo3cxxWFZEsUPqkxnt38xEl1cFAHHC9iQN9mlEg=") try: ret = rr.rrsig_labels() if not isinstance(ret, ldns.ldns_rdf): set_error() except: set_error() rr = ldns.ldns_rr.new_frm_str("test 600 IN A 0.0.0.0") try: ret = rr.rrsig_labels() if isinstance(ret, ldns.ldns_rdf): set_error() if ret != None: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".rrsig_origttl()" rr = ldns.ldns_rr.new_frm_str("example. 600 IN RRSIG SOA 3 1 600 20130828153754 20120828153754 19031 example. AIoCFhwZJxIgYOBEyo3cxxWFZEsUPqkxnt38xEl1cFAHHC9iQN9mlEg=") try: ret = rr.rrsig_origttl() if not isinstance(ret, ldns.ldns_rdf): set_error() except: set_error() rr = ldns.ldns_rr.new_frm_str("test 600 IN A 0.0.0.0") try: ret = rr.rrsig_origttl() if isinstance(ret, ldns.ldns_rdf): set_error() if ret != None: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".rrsig_set_algorithm()" rr = ldns.ldns_rr.new_frm_str("example. 600 IN RRSIG SOA 3 1 600 20130828153754 20120828153754 19031 example. AIoCFhwZJxIgYOBEyo3cxxWFZEsUPqkxnt38xEl1cFAHHC9iQN9mlEg=") rdf = ldns.ldns_rdf.new_frm_str("3", ldns.LDNS_RDF_TYPE_ALG) try: ret = rr.rrsig_set_algorithm(rdf) if not isinstance(ret, bool): set_error() if ret != True: set_error() except: set_error() # rdf = ldns.ldns_rdf.new_frm_str("0.0.0.0", ldns.LDNS_RDF_TYPE_A) # try: # ret = rr.rrsig_set_algorithm(rdf) # if not isinstance(ret, bool): # set_error() # if ret != False: # set_error() # except: # set_error() try: ret = rr.rrsig_set_algorithm("") set_error() except TypeError: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".rrsig_set_expiration()" rr = ldns.ldns_rr.new_frm_str("example. 600 IN RRSIG SOA 3 1 600 20130828153754 20120828153754 19031 example. AIoCFhwZJxIgYOBEyo3cxxWFZEsUPqkxnt38xEl1cFAHHC9iQN9mlEg=") rdf = ldns.ldns_rdf.new_frm_str("20130928153754", ldns.LDNS_RDF_TYPE_TIME) try: ret = rr.rrsig_set_expiration(rdf) if not isinstance(ret, bool): set_error() if ret != True: set_error() except: set_error() # rdf = ldns.ldns_rdf.new_frm_str("0.0.0.0", ldns.LDNS_RDF_TYPE_A) # try: # ret = rr.rrsig_set_expiration(rdf) # if not isinstance(ret, bool): # set_error() # if ret != False: # set_error() # except: # set_error() try: ret = rr.rrsig_set_expiration("") set_error() except TypeError: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".rrsig_set_inception()" rr = ldns.ldns_rr.new_frm_str("example. 600 IN RRSIG SOA 3 1 600 20130828153754 20120828153754 19031 example. AIoCFhwZJxIgYOBEyo3cxxWFZEsUPqkxnt38xEl1cFAHHC9iQN9mlEg=") rdf = ldns.ldns_rdf.new_frm_str("20120728153754", ldns.LDNS_RDF_TYPE_TIME) try: ret = rr.rrsig_set_inception(rdf) if not isinstance(ret, bool): set_error() if ret != True: set_error() except: set_error() # rdf = ldns.ldns_rdf.new_frm_str("0.0.0.0", ldns.LDNS_RDF_TYPE_A) # try: # ret = rr.rrsig_set_inception(rdf) # if not isinstance(ret, bool): # set_error() # if ret != False: # set_error() # except: # set_error() try: ret = rr.rrsig_set_inception("") set_error() except TypeError: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".rrsig_set_keytag()" rr = ldns.ldns_rr.new_frm_str("example. 600 IN RRSIG SOA 3 1 600 20130828153754 20120828153754 19031 example. AIoCFhwZJxIgYOBEyo3cxxWFZEsUPqkxnt38xEl1cFAHHC9iQN9mlEg=") rdf = ldns.ldns_rdf.new_frm_str("19032", ldns.LDNS_RDF_TYPE_INT16) try: ret = rr.rrsig_set_keytag(rdf) if not isinstance(ret, bool): set_error() if ret != True: set_error() except: set_error() # rdf = ldns.ldns_rdf.new_frm_str("0.0.0.0", ldns.LDNS_RDF_TYPE_A) # try: # ret = rr.rrsig_set_keytag(rdf) # if not isinstance(ret, bool): # set_error() # if ret != False: # set_error() # except: # set_error() try: ret = rr.rrsig_set_keytag("") set_error() except TypeError: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".rrsig_set_labels()" rr = ldns.ldns_rr.new_frm_str("example. 600 IN RRSIG SOA 3 1 600 20130828153754 20120828153754 19031 example. AIoCFhwZJxIgYOBEyo3cxxWFZEsUPqkxnt38xEl1cFAHHC9iQN9mlEg=") rdf = ldns.ldns_rdf.new_frm_str("1", ldns.LDNS_RDF_TYPE_INT8) try: ret = rr.rrsig_set_labels(rdf) if not isinstance(ret, bool): set_error() if ret != True: set_error() except: set_error() # rdf = ldns.ldns_rdf.new_frm_str("0.0.0.0", ldns.LDNS_RDF_TYPE_A) # try: # ret = rr.rrsig_set_labels(rdf) # if not isinstance(ret, bool): # set_error() # if ret != False: # set_error() # except: # set_error() try: ret = rr.rrsig_set_labels("") set_error() except TypeError: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".rrsig_set_origttl()" rr = ldns.ldns_rr.new_frm_str("example. 600 IN RRSIG SOA 3 1 600 20130828153754 20120828153754 19031 example. AIoCFhwZJxIgYOBEyo3cxxWFZEsUPqkxnt38xEl1cFAHHC9iQN9mlEg=") rdf = ldns.ldns_rdf.new_frm_str("1", ldns.LDNS_RDF_TYPE_INT8) try: ret = rr.rrsig_set_origttl(rdf) if not isinstance(ret, bool): set_error() if ret != True: set_error() except: set_error() # rdf = ldns.ldns_rdf.new_frm_str("0.0.0.0", ldns.LDNS_RDF_TYPE_A) # try: # ret = rr.rrsig_set_origttl(rdf) # if not isinstance(ret, bool): # set_error() # if ret != False: # set_error() # except: # set_error() try: ret = rr.rrsig_set_origttl("") set_error() except TypeError: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".rrsig_set_sig()" rr = ldns.ldns_rr.new_frm_str("example. 600 IN RRSIG SOA 3 1 600 20130828153754 20120828153754 19031 example. AIoCFhwZJxIgYOBEyo3cxxWFZEsUPqkxnt38xEl1cFAHHC9iQN9mlEg=") rdf = ldns.ldns_rdf.new_frm_str("AIoCFhwZJxIgYOBEyo3cxxWFZEsUPqkxnt38xEl1cFAHHC9iQN9mlEg=", ldns.LDNS_RDF_TYPE_B64) try: ret = rr.rrsig_set_sig(rdf) if not isinstance(ret, bool): set_error() if ret != True: set_error() except: set_error() # rdf = ldns.ldns_rdf.new_frm_str("0.0.0.0", ldns.LDNS_RDF_TYPE_A) # try: # ret = rr.rrsig_set_sig(rdf) # if not isinstance(ret, bool): # set_error() # if ret != False: # set_error() # except: # set_error() try: ret = rr.rrsig_set_sig("") set_error() except TypeError: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".rrsig_set_signame()" rr = ldns.ldns_rr.new_frm_str("example. 600 IN RRSIG SOA 3 1 600 20130828153754 20120828153754 19031 example. AIoCFhwZJxIgYOBEyo3cxxWFZEsUPqkxnt38xEl1cFAHHC9iQN9mlEg=") rdf = ldns.ldns_rdf.new_frm_str("example.", ldns.LDNS_RDF_TYPE_DNAME) try: ret = rr.rrsig_set_signame(rdf) if not isinstance(ret, bool): set_error() if ret != True: set_error() except: set_error() # rdf = ldns.ldns_rdf.new_frm_str("0.0.0.0", ldns.LDNS_RDF_TYPE_A) # try: # ret = rr.rrsig_set_signame(rdf) # if not isinstance(ret, bool): # set_error() # if ret != False: # set_error() # except: # set_error() try: ret = rr.rrsig_set_signame("") set_error() except TypeError: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".rrsig_set_typecovered()" rr = ldns.ldns_rr.new_frm_str("example. 600 IN RRSIG SOA 3 1 600 20130828153754 20120828153754 19031 example. AIoCFhwZJxIgYOBEyo3cxxWFZEsUPqkxnt38xEl1cFAHHC9iQN9mlEg=") rdf = ldns.ldns_rdf.new_frm_str("SOA", ldns.LDNS_RDF_TYPE_TYPE) try: ret = rr.rrsig_set_typecovered(rdf) if not isinstance(ret, bool): set_error() if ret != True: set_error() except: set_error() # rdf = ldns.ldns_rdf.new_frm_str("0.0.0.0", ldns.LDNS_RDF_TYPE_A) # try: # ret = rr.rrsig_set_typecovered(rdf) # if not isinstance(ret, bool): # set_error() # if ret != False: # set_error() # except: # set_error() try: ret = rr.rrsig_set_typecovered("") set_error() except TypeError: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".rrsig_sig()" rr = ldns.ldns_rr.new_frm_str("example. 600 IN RRSIG SOA 3 1 600 20130828153754 20120828153754 19031 example. AIoCFhwZJxIgYOBEyo3cxxWFZEsUPqkxnt38xEl1cFAHHC9iQN9mlEg=") try: ret = rr.rrsig_sig() if not isinstance(ret, ldns.ldns_rdf): set_error() except: set_error() rr = ldns.ldns_rr.new_frm_str("test 600 IN A 0.0.0.0") try: ret = rr.rrsig_sig() if isinstance(ret, ldns.ldns_rdf): set_error() if ret != None: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".rrsig_signame()" rr = ldns.ldns_rr.new_frm_str("example. 600 IN RRSIG SOA 3 1 600 20130828153754 20120828153754 19031 example. AIoCFhwZJxIgYOBEyo3cxxWFZEsUPqkxnt38xEl1cFAHHC9iQN9mlEg=") try: ret = rr.rrsig_signame() if not isinstance(ret, ldns.ldns_rdf): set_error() except: set_error() rr = ldns.ldns_rr.new_frm_str("test 600 IN A 0.0.0.0") try: ret = rr.rrsig_signame() if isinstance(ret, ldns.ldns_rdf): set_error() if ret != None: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".rrsig_typecovered()" rr = ldns.ldns_rr.new_frm_str("example. 600 IN RRSIG SOA 3 1 600 20130828153754 20120828153754 19031 example. AIoCFhwZJxIgYOBEyo3cxxWFZEsUPqkxnt38xEl1cFAHHC9iQN9mlEg=") try: ret = rr.rrsig_typecovered() if not isinstance(ret, ldns.ldns_rdf): set_error() except: set_error() rr = ldns.ldns_rr.new_frm_str("test 600 IN A 0.0.0.0") try: ret = rr.rrsig_typecovered() if isinstance(ret, ldns.ldns_rdf): set_error() if ret != None: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".set_class()" rr = ldns.ldns_rr.new_frm_str("test 600 IN A 0.0.0.0") try: rr.set_class(ldns.LDNS_RR_CLASS_CH) except: set_error() try: rr.set_class("") set_error() except TypeError: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".set_owner()" rr = ldns.ldns_rr.new_frm_str("test 600 IN A 0.0.0.0") rdf = ldns.ldns_dname("test2") try: rr.set_owner(rdf) except: set_error() try: rr.set_owner("") set_error() except TypeError: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".set_question()" rr = ldns.ldns_rr.new_frm_str("test 600 IN A 0.0.0.0") try: rr.set_question(True) except: set_error() #if not error_detected: if True: method_name = class_name + ".set_rd_count()" rr = ldns.ldns_rr.new_frm_str("test 600 IN A 0.0.0.0") try: rr.set_rd_count(1) except: set_error() try: rr.set_rd_count("") set_error() except TypeError: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".set_rdf()" rr = ldns.ldns_rr.new_frm_str("test 600 IN A 0.0.0.0") rdf = ldns.ldns_rdf.new_frm_str("1.1.1.1", ldns.LDNS_RDF_TYPE_A) rr.push_rdf(rdf) try: ret = rr.set_rdf(rdf, 0) if not isinstance(ret, ldns.ldns_rdf): set_error() except: set_error() try: ret = rr.set_rdf(rdf, 2) if isinstance(ret, ldns.ldns_rdf): set_error() if ret != None: set_error() except: set_error() try: rr.set_rdf("", 1) set_error() except TypeError: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".set_ttl()" rr = ldns.ldns_rr.new_frm_str("test 600 IN A 0.0.0.0") try: rr.set_ttl(1) except: set_error() try: rr.set_ttl("") set_error() except TypeError: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".set_type()" rr = ldns.ldns_rr.new_frm_str("test 600 IN A 0.0.0.0") try: rr.set_type(ldns.LDNS_RR_TYPE_A) except: set_error() try: rr.set_type("") set_error() except TypeError: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".to_canonical()" rr = ldns.ldns_rr.new_frm_str("TEST 600 IN A 0.0.0.0") try: rr.to_canonical() except: set_error() #if not error_detected: if True: method_name = class_name + ".ttl()" rr = ldns.ldns_rr.new_frm_str("test 600 IN A 0.0.0.0") try: ret = rr.ttl() if not isinstance(ret, int): set_error() if ret != 600: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".type_by_name()" try: ret = ldns.ldns_rr.type_by_name("A") if not isinstance(ret, int): set_error() if ret != ldns.LDNS_RR_TYPE_A: set_error() except: set_error() try: ret = ldns.ldns_rr.type_by_name("AA") if not isinstance(ret, int): set_error() if ret != 0: set_error() except: set_error() try: ret = ldns.ldns_rr.type_by_name(1) set_error() except TypeError: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".uncompressed_size()" rr = ldns.ldns_rr.new_frm_str("test 600 IN A 0.0.0.0") try: ret = rr.uncompressed_size() if (not isinstance(ret, int)) and (not isinstance(ret, long)): set_error() if ret != 20: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".write_data_to_buffer()" sys.stderr.write("%s not tested.\n" % (method_name)) #if not error_detected: if True: method_name = class_name + ".write_rrsig_to_buffer()" sys.stderr.write("%s not tested.\n" % (method_name)) #if not error_detected: if True: method_name = class_name + ".write_to_buffer()" sys.stderr.write("%s not tested.\n" % (method_name)) #if not error_detected: if True: method_name = class_name + ".write_to_buffer_canonical()" sys.stderr.write("%s not tested.\n" % (method_name)) ############################################################################### ############################################################################### class_name = "ldns_rr_descriptor" method_name = None error_detected = False temp_fname = "tmp_rr_descriptor.txt" #if not error_detected: if True: method_name = class_name + ".field_type()" desc_a = ldns.ldns_rr_descriptor.ldns_rr_descriptor(ldns.LDNS_RR_TYPE_A) try: ret = desc_a.field_type(0) if not isinstance(ret, int): set_error() if ret != ldns.LDNS_RDF_TYPE_A: set_error() except: set_error() try: ret = desc_a.field_type("") set_error() except TypeError: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".ldns_rr_descriptor()" try: ret = ldns.ldns_rr_descriptor.ldns_rr_descriptor(ldns.LDNS_RR_TYPE_A) if not isinstance(ret, ldns.ldns_rr_descriptor): set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".maximum()" desc_a = ldns.ldns_rr_descriptor.ldns_rr_descriptor(ldns.LDNS_RR_TYPE_A) try: ret = desc_a.maximum() if (not isinstance(ret, int)) and (not isinstance(ret, long)): set_error() if ret != 1: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".minimum()" desc_a = ldns.ldns_rr_descriptor.ldns_rr_descriptor(ldns.LDNS_RR_TYPE_A) try: ret = desc_a.minimum() if (not isinstance(ret, int)) and (not isinstance(ret, long)): set_error() if ret != 1: set_error() except: set_error() ############################################################################### ############################################################################### class_name = "ldns_rr_list" method_name = None error_detected = False temp_fname = "tmp_rr_list.txt" #if not error_detected: if True: method_name = class_name + ".[comparison operators]" rrl1 = ldns.ldns_rr_list.new() rrl1.push_rr(ldns.ldns_rr.new_frm_str("test1 600 IN A 0.0.0.0")) rrl2 = ldns.ldns_rr_list.new() rrl2.push_rr(ldns.ldns_rr.new_frm_str("test2 600 IN A 1.1.1.1")) try: ret = rrl1 < rrl2 if not isinstance(ret, bool): set_error() if ret != True: set_error() except: set_error() try: ret = rrl2 < rrl1 if not isinstance(ret, bool): set_error() if ret != False: set_error() except: set_error() try: ret = rrl1 <= rrl2 if not isinstance(ret, bool): set_error() if ret != True: set_error() except: set_error() try: ret = rrl2 <= rrl1 if not isinstance(ret, bool): set_error() if ret != False: set_error() except: set_error() try: ret = rrl1 == rrl2 if not isinstance(ret, bool): set_error() if ret != False: set_error() except: set_error() try: ret = rrl1 == rrl1 if not isinstance(ret, bool): set_error() if ret != True: set_error() except: set_error() try: ret = rrl1 != rrl2 if not isinstance(ret, bool): set_error() if ret != True: set_error() except: set_error() try: ret = rrl1 != rrl1 if not isinstance(ret, bool): set_error() if ret != False: set_error() except: set_error() try: ret = rrl1 > rrl2 if not isinstance(ret, bool): set_error() if ret != False: set_error() except: set_error() try: ret = rrl2 > rrl1 if not isinstance(ret, bool): set_error() if ret != True: set_error() except: set_error() try: ret = rrl1 >= rrl2 if not isinstance(ret, bool): set_error() if ret != False: set_error() except: set_error() try: ret = rrl2 >= rrl1 if not isinstance(ret, bool): set_error() if ret != True: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".cat()" rrl1 = ldns.ldns_rr_list.new() rrl2 = ldns.ldns_rr_list.new() rrl1.push_rr(ldns.ldns_rr.new_frm_str("test1 600 IN A 0.0.0.0")) rrl2.push_rr(ldns.ldns_rr.new_frm_str("test2 600 IN A 1.1.1.1")) try: ret = rrl1.cat(rrl2) if not isinstance(ret, bool): set_error() if ret != True: set_error() except: set_error() try: ret = rrl2.cat("") set_error() except TypeError: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".cat_clone()" rrl1 = ldns.ldns_rr_list.new() rrl2 = ldns.ldns_rr_list.new() rrl1.push_rr(ldns.ldns_rr.new_frm_str("test1 600 IN A 0.0.0.0")) rrl2.push_rr(ldns.ldns_rr.new_frm_str("test2 600 IN A 1.1.1.1")) try: ret = rrl1.cat_clone(rrl2) if not isinstance(ret, ldns.ldns_rr_list): set_error() except: set_error() try: ret = rrl2.cat_clone("") set_error() except TypeError: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".clone()" rrl = ldns.ldns_rr_list.new() rrl.push_rr(ldns.ldns_rr.new_frm_str("test1 600 IN A 0.0.0.0")) try: ret = rrl.clone() if not isinstance(ret, ldns.ldns_rr_list): set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".contains_rr()" rrl = ldns.ldns_rr_list.new() rr1 = ldns.ldns_rr.new_frm_str("test1 600 IN A 0.0.0.0") rr2 = ldns.ldns_rr.new_frm_str("test2 600 IN A 1.1.1.1") rrl.push_rr(rr1) try: ret = rrl.contains_rr(rr1) if not isinstance(ret, bool): set_error() if ret != True: set_error() except: set_error() try: ret = rrl.contains_rr(rr2) if not isinstance(ret, bool): set_error() if ret != False: set_error() except: set_error() try: ret = rrl.contains_rr("") set_error() except TypeError: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".is_rrset()" rrl = ldns.ldns_rr_list.new() rr = ldns.ldns_rr.new_frm_str("test1 600 IN A 0.0.0.0") rrl.push_rr(rr) try: ret = rrl.is_rrset() if not isinstance(ret, bool): set_error() if ret != True: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".new()" try: ret = ldns.ldns_rr_list.new() if not isinstance(ret, ldns.ldns_rr_list): set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".new_frm_file()" try: ret = ldns.ldns_rr_list.new_frm_file() if not isinstance(ret, ldns.ldns_rr_list): set_error() except: set_error() try: ret = ldns.ldns_rr_list.new_frm_file("test") set_error() except Exception: pass except: set_error() try: ret = ldns.ldns_rr_list.new_frm_file("test", raiseException=False) if isinstance(ret, ldns.ldns_rr_list): set_error() if ret != None: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".owner()" rrl = ldns.ldns_rr_list.new() try: ret = rrl.owner() if isinstance(ret, ldns.ldns_rdf): set_error() if ret != None: set_error() except: set_error() rr = ldns.ldns_rr.new_frm_str("test1 600 IN A 0.0.0.0") rrl.push_rr(rr) try: ret = rrl.owner() if not isinstance(ret, ldns.ldns_dname): set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".pop_rr()" rrl = ldns.ldns_rr_list.new() rr = ldns.ldns_rr.new_frm_str("test1 600 IN A 0.0.0.0") rrl.push_rr(rr) try: ret = rrl.pop_rr() if not isinstance(ret, ldns.ldns_rr): set_error() except: set_error() try: ret = rrl.pop_rr() if isinstance(ret, ldns.ldns_rr): set_error() if ret != None: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".pop_rr_list()" rrl = ldns.ldns_rr_list.new() rr = ldns.ldns_rr.new_frm_str("test1 600 IN A 0.0.0.0") rrl.push_rr(rr) rrl.push_rr(rr) rrl.push_rr(rr) try: ret = rrl.pop_rr_list(2) if not isinstance(ret, ldns.ldns_rr_list): set_error() except: set_error() try: ret = rrl.pop_rr_list(2) if not isinstance(ret, ldns.ldns_rr_list): set_error() except: set_error() try: ret = rrl.pop_rr_list(2) if isinstance(ret, ldns.ldns_rr_list): set_error() if ret != None: set_error() except: set_error() try: ret = rrl.pop_rr_list("") set_error() except TypeError: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".pop_rrset()" rrl = ldns.ldns_rr_list.new() rr = ldns.ldns_rr.new_frm_str("test1 600 IN A 0.0.0.0") rrl.push_rr(rr) rrl.push_rr(rr) rrl.push_rr(rr) try: ret = rrl.pop_rrset() if not isinstance(ret, ldns.ldns_rr_list): set_error() except: set_error() try: ret = rrl.pop_rrset() if isinstance(ret, ldns.ldns_rr_list): set_error() if ret != None: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".print_to_file()" rrl = ldns.ldns_rr_list.new() rr = ldns.ldns_rr.new_frm_str("test1 600 IN A 0.0.0.0") rrl.push_rr(rr) rrl.push_rr(rr) rrl.push_rr(rr) f = open(temp_fname, "w") try: rrl.print_to_file(f) except: set_error() f.close() f = open(temp_fname, "r") if len(f.readlines()) != 3: set_error() f.close() os.remove(temp_fname) #if not error_detected: if True: method_name = class_name + ".push_rr()" rrl = ldns.ldns_rr_list.new() rr = ldns.ldns_rr.new_frm_str("test1 600 IN A 0.0.0.0") try: ret = rrl.push_rr(rr) if not isinstance(ret, bool): set_error() if ret != True: set_error() except: set_error() try: ret = rrl.push_rr("") set_error() except TypeError: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".push_rr_list()" rrl1 = ldns.ldns_rr_list.new() rr = ldns.ldns_rr.new_frm_str("test1 600 IN A 0.0.0.0") rrl1.push_rr(rr) rrl2 = rrl1.new() try: ret = rrl1.push_rr_list(rrl2) if not isinstance(ret, bool): set_error() if ret != True: set_error() except: set_error() try: ret = rrl.push_rr_list("") set_error() except TypeError: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".rr()" rrl = ldns.ldns_rr_list.new() rr = ldns.ldns_rr.new_frm_str("test1 600 IN A 0.0.0.0") rrl.push_rr(rr) try: ret = rrl.rr(0) if not isinstance(ret, ldns.ldns_rr): set_error() except: set_error() try: ret = rrl.rr(1) if isinstance(ret, ldns.ldns_rr): set_error() if ret != None: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".rr_count()" rrl = ldns.ldns_rr_list.new() try: ret = rrl.rr_count() if (not isinstance(ret, int)) and (not isinstance(ret, long)): set_error() if ret != 0: set_error() except: set_error() rr = ldns.ldns_rr.new_frm_str("test1 600 IN A 0.0.0.0") rrl.push_rr(rr) try: ret = rrl.rr_count() if (not isinstance(ret, int)) and (not isinstance(ret, long)): set_error() if ret != 1: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".rrs()" rrl = ldns.ldns_rr_list.new() rr = ldns.ldns_rr.new_frm_str("test1 600 IN A 0.0.0.0") rrl.push_rr(rr) rrl.push_rr(rr) try: ret = list(rrl.rrs()) if not isinstance(ret, list): set_error() if len(ret) != 2: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".set_rr()" rrl = ldns.ldns_rr_list.new() rr = ldns.ldns_rr.new_frm_str("test1 600 IN A 0.0.0.0") rrl.push_rr(rr) rr = ldns.ldns_rr.new_frm_str("test2 600 IN A 1.1.1.1") ret = rrl.set_rr(rr, 0) try: ret = rrl.set_rr(rr, 0) if not isinstance(ret, ldns.ldns_rr): set_error() except: set_error() try: ret = rrl.set_rr(rr, 1) if isinstance(ret, ldns.ldns_rr): set_error() if ret != None: set_error() except: set_error() try: ret = rrl.set_rr("", 1) set_error() except TypeError: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".set_rr_count()" rrl = ldns.ldns_rr_list.new() try: rrl.set_rr_count(0) except: set_error() rr = ldns.ldns_rr.new_frm_str("test1 600 IN A 0.0.0.0") rrl.push_rr(rr) try: rrl.set_rr_count("") except TypeError: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".sort()" rrl = ldns.ldns_rr_list.new() try: rrl.sort() except: set_error() #if not error_detected: if True: method_name = class_name + ".subtype_by_rdf()" rrl = ldns.ldns_rr_list.new() rr = ldns.ldns_rr.new_frm_str("test1 600 IN A 0.0.0.0") rrl.push_rr(rr) rr = ldns.ldns_rr.new_frm_str("test2 600 IN A 1.1.1.1") rrl.push_rr(rr) rr = ldns.ldns_rr.new_frm_str("test3 600 IN A 0.0.0.0") rrl.push_rr(rr) rdf = ldns.ldns_rdf.new_frm_str("0.0.0.0", ldns.LDNS_RDF_TYPE_A) try: ret = rrl.subtype_by_rdf(rdf, 0) if not isinstance(ret, ldns.ldns_rr_list): set_error() if ret.rr_count() != 2: set_error() except: set_error() rdf = ldns.ldns_rdf.new_frm_str("::", ldns.LDNS_RDF_TYPE_AAAA) try: ret = rrl.subtype_by_rdf(rdf, 0) if isinstance(ret, ldns.ldns_rr_list): set_error() if ret != None: set_error() except: set_error() try: ret = rrl.subtype_by_rdf("", 0) set_error() except TypeError: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".to_canonical()" rrl = ldns.ldns_rr_list.new() rr = ldns.ldns_rr.new_frm_str("TEST1 600 IN A 0.0.0.0") rrl.push_rr(rr) try: rrl.to_canonical() except: set_error() #if not error_detected: if True: method_name = class_name + ".type()" rrl = ldns.ldns_rr_list.new() try: ret = rrl.type() if not isinstance(ret, int): set_error() if ret != 0: set_error() except: set_error() rr = ldns.ldns_rr.new_frm_str("TEST1 600 IN A 0.0.0.0") rrl.push_rr(rr) try: ret = rrl.type() if not isinstance(ret, int): set_error() if ret != ldns.LDNS_RR_TYPE_A: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".write_to_buffer()" sys.stderr.write("%s not tested.\n" % (method_name)) if not error_detected: sys.stdout.write("%s: passed.\n" % (os.path.basename(__file__))) else: sys.stdout.write("%s: errors detected.\n" % (os.path.basename(__file__))) sys.exit(1) ldns-1.6.17/contrib/python/examples/zone.txt0000664000175100017510000000104112264060151020422 0ustar willemwillem$ORIGIN example. $TTL 600 example. IN SOA example. admin.example. ( 2008022501 ; serial 28800 ; refresh (8 hours) 7200 ; retry (2 hours) 604800 ; expire (1 week) 18000 ; minimum (5 hours) ) @ IN MX 10 mail.example. @ IN NS ns1 @ IN NS ns2 @ IN A 192.168.1.1 ldns-1.6.17/contrib/python/examples/ldns-buf.py0000775000175100017510000000014212264060151020776 0ustar willemwillem#!/usr/bin/python import ldns buf = ldns.ldns_buffer(1024) buf.printf("Test buffer") print buf ldns-1.6.17/contrib/python/examples/test_buffer.py0000775000175100017510000004015212264060151021601 0ustar willemwillem#!/usr/bin/env python # # ldns_buffer testing script. # # Do not use constructs that differ between Python 2 and 3. # Use write on stdout or stderr. # import ldns import sys import os import inspect class_name = "ldns_buffer" method_name = None error_detected = False def set_error(): """ Writes an error message and sets error flag. """ global class_name global method_name global error_detected error_detected = True sys.stderr.write("(line %d): malfunctioning method %s.\n" % \ (inspect.currentframe().f_back.f_lineno, method_name)) # Buffer creation. capacity = 1024 #if not error_detected: if True: method_name = "ldns_buffer.__init__()" try: buf = ldns.ldns_buffer(1024) except: set_error() #if not error_detected: if True: method_name = "ldns_buffer.__str__()" buf.printf("abcedf") try: string = buf.__str__() except: set_error() if not isinstance(string, str): # Should be string. set_error() buf.clear() #if not error_detected: if True: method_name = "ldns_buffer.at()" try: ret = buf.at(512) except: set_error() try: # Must raise TypeError. ret = buf.at("") set_error() except TypeError: pass except: set_error() #if not error_detected: if True: method_name = "ldns_buffer.available()" try: ret = buf.available(capacity) except: set_error() if not isinstance(ret, bool): # Should be bool. set_error() if not buf.available(capacity): # Should return True. set_error() if buf.available(capacity + 1): # Should return False. set_error() try: # Must raise TypeError. ret = buf.available("") set_error() except TypeError: pass except: set_error() # try: # # Must raise ValueError. # ret = buf.available("") # set_error() # except ValueError: # pass # except: # set_error() #if not error_detected: if True: method_name = "ldns_buffer.available_at()" try: ret = buf.available_at(512, capacity - 512) except: set_error() if not isinstance(ret, bool): # Should be bool. set_error() if not buf.available_at(512, capacity - 512): # Should return True. set_error() if buf.available_at(512, capacity - 512 + 1): # Should return False. set_error() try: # Must raise TypeError. ret = buf.available_at("", 1) set_error() except TypeError: pass except: set_error() try: # Must raise TypeError. ret = buf.available_at(1, "") set_error() except TypeError: pass except: set_error() # try: # # Must raise ValueError. # ret = buf.available_at(-1, 512) # set_error() # except ValueError: # pass # except: # set_error() # try: # # Must raise ValueError. # ret = buf.available_at(512, -1) # set_error() # except ValueError: # pass # except: # set_error() #if not error_detected: if True: method_name = "ldns_buffer.begin()" try: ret = buf.begin() except: set_error() #if not error_detected: if True: method_name = "ldns_buffer.capacity()" try: ret = buf.capacity() except: set_error() if (not isinstance(ret, int)) and (not isinstance(ret, long)): # Should be int. set_error() #if not error_detected: if True: method_name = "ldns_buffer.clear()" try: buf.clear() except: set_error() #if not error_detected: if True: method_name = "ldns_buffer.copy()" sys.stderr.write("%s not tested.\n" % (method_name)) # buf2 = ldns.ldns_buffer(10) # buf2.printf("abcdef") # try: # buf.copy(buf2) # print buf.capacity() # print buf2.capacity() # except: # set_error() # buf.printf("2") # print buf #if not error_detected: if True: method_name = "ldns_buffer.current()" try: ret = buf.current() except: set_error() #if not error_detected: if True: method_name = "ldns_buffer.end()" try: ret = buf.end() except: set_error() #if not error_detected: if True: method_name = "ldns_buffer.export()" sys.stderr.write("%s not tested.\n" % (method_name)) #if not error_detected: if True: mehod_name = "ldns_buffer.flip()" buf.printf("abcdef") try: buf.flip() except: set_error() # if buf.remaining() != capacity: # # Should be at beginning. # set_error() buf.clear() #if not error_detected: if True: method_name = "ldns_buffer.getc()" buf.printf("a") buf.rewind() try: ret = buf.getc() except: set_error() if ret != ord("a"): set_error() # Test return value for -1 buf.clear() #if not error_detected: if True: method_name = "ldns_buffer.invariant()" try: buf.invariant() except: set_error() #if not error_detected: if True: method_name = "ldns_buffer.limit()" try: ret = buf.limit() except: set_error() if ret != capacity: set_error() #if not error_detected: if True: method_name = "ldns_buffer.position()" try: ret = buf.position() except: set_error() if (not isinstance(ret, int)) and (not isinstance(ret, long)): set_error() #if not error_detected: if True: method_name = "ldns_buffer.printf()" try: ret = buf.printf("abcdef") except: set_error() if not isinstance(ret, int): set_error() try: ret = buf.printf(10) set_error() except TypeError: pass except: set_error() buf.clear() #if not error_detected: if True: method_name = "ldns_buffer.read()" sys.stderr.write("%s not tested.\n" % (method_name)) #if not error_detected: if True: method_name = "ldns_buffer.read_at()" sys.stderr.write("%s not tested.\n" % (method_name)) #if not error_detected: if True: method_name = "ldns_buffer.read_u16()" buf.printf("aac") buf.rewind() try: ret = buf.read_u16() except: set_error() if (not isinstance(ret, int)) and (not isinstance(ret, long)): set_error() if ret != (ord("a") * 0x0101): set_error() buf.clear() #if not error_detected: if True: method_name = "ldns_buffer.read_u16_at()" buf.printf("abbc") try: ret = buf.read_u16_at(1) except: set_error() if (not isinstance(ret, int)) and (not isinstance(ret, long)): set_error() if ret != (ord("b") * 0x0101): set_error() try: ret = buf.read_u16_at("") set_error() except TypeError: pass except: set_error() # try: # ret = buf.read_u16_at(-1) # set_error() # except ValueError: # pass # except: # set_error() buf.clear() #if not error_detected: if True: method_name = "ldns_buffer.read_u32()" buf.printf("aaaac") buf.rewind() try: ret = buf.read_u32() except: set_error() if not isinstance(ret, int): set_error() if ret != (ord("a") * 0x01010101): set_error() buf.clear() #if not error_detected: if True: method_name = "ldns_buffer.read_u32_at()" buf.printf("abbbbc") try: ret = buf.read_u32_at(1) except: set_error() if not isinstance(ret, int): set_error() if ret != (ord("b") * 0x01010101): set_error() try: ret = buf.read_u32_at("") set_error() except TypeError: pass except: set_error() # try: # ret = buf.read_u32_at(-1) # set_error() # except ValueError: # pass # except: # set_error() buf.clear() #if not error_detected: if True: method_name = "ldns_buffer.read_u8()" buf.printf("ac") buf.rewind() try: ret = buf.read_u8() except: set_error() if (not isinstance(ret, int)) and (not isinstance(ret, long)): set_error() if ret != ord("a"): set_error() buf.clear() #if not error_detected: if True: method_name = "ldns_buffer.read_u8_at()" buf.printf("abc") try: ret = buf.read_u8_at(1) except: set_error() if (not isinstance(ret, int)) and (not isinstance(ret, long)): set_error() if ret != ord("b"): set_error() try: ret = buf.read_u8_at("") set_error() except TypeError: pass except: set_error() # try: # ret = buf.read_u8_at(-1) # set_error() # except ValueError: # pass # except: # set_error() buf.clear() #if not error_detected: if True: method_name = "ldns_buffer.remaining()" buf.printf("abcdef") try: ret = buf.remaining() except: set_error() if (not isinstance(ret, int)) and (not isinstance(ret, long)): set_error() if ret != (capacity - 6): set_error() buf.clear() #if not error_detected: if True: method_name = "ldns_buffer.remaining_at()" buf.printf("abcdef") try: ret = buf.remaining_at(1) except: set_error() if (not isinstance(ret, int)) and (not isinstance(ret, long)): set_error() if ret != (capacity - 1): set_error() try: ret = buf.remaining_at("") set_error() except TypeError: pass except: set_error() # try: # ret = buf.remaining_at(-1) # set_error() # except ValueError: # pass # except: # set_error() buf.clear() #if not error_detected: if True: method_name = "ldns_buffer.reserve()" buf2 = ldns.ldns_buffer(512) try: ret = buf2.reserve(1024) except: set_error() if not isinstance(ret, bool): set_error() try: ret = buf2.reserve("") set_error() except TypeError: pass except: set_error() # try: # ret = buf2.reserve(-1) # set_error() # except ValueError: # pass # except: # set_error() #if not error_detected: if True: method_name = "ldns_buffer.rewind()" buf.printf("abcdef") try: buf.rewind() except: set_error() if buf.position() != 0: set_error() buf.clear() #if not error_detected: if True: method_name = "ldns_buffer.set_capacity()" try: ret = buf.set_capacity(capacity) except: set_error() if not isinstance(ret, bool): set_error() try: ret = buf.set_capacity("") set_error() except TypeError: pass except: set_error() # try: # ret = buf.set_capacity(-1) # set_error() # except ValueError: # pass # except: # set_error() buf.clear() #if not error_detected: if True: method_name = "ldns_buffer.set_limit()" try: buf.set_limit(0) except: set_error() try: buf.set_limit("") set_error() except TypeError: pass except: set_error() # try: # buf.set_limit(-1) # set_error() # except ValueError: # pass # except: # set_error() buf.clear() #if not error_detected: if True: method_name = "ldns_buffer.set_position()" try: buf.set_position(0) except: set_error() try: buf.set_position("") except TypeError: pass except: set_error() # try: # buf.set_position(-1) # except ValueError: # pass # except: # set_error() buf.clear() #if not error_detected: if True: method_name = "ldns_buffer.skip()" try: buf.skip(10) except: set_error() try: buf.skip(-1) except: set_error() try: buf.skip("") set_error() except TypeError: pass except: set_error() buf.clear() #if not error_detected: if True: method_name = "ldns_buffer.status()" try: ret = buf.status() except: set_error() # Returned status is an integer. if not isinstance(ret, int): set_error() buf.clear() #if not error_detected: if True: method_name = "ldns_buffer.status_ok()" try: ret = buf.status_ok() except: set_error() if not isinstance(ret, bool): set_error() buf.clear() #if not error_detected: if True: method_name = "ldns_buffer.write()" sys.stderr.write("%s not tested.\n" % (method_name)) #if not error_detected: if True: method_name = "ldns_buffer.write_at()" sys.stderr.write("%s not tested.\n" % (method_name)) #if not error_detected: if True: method_name = "ldns_buffer.write_string()" try: buf.write_string("abcdef") except: set_error() # try: # buf.write_sring(-1) # set_error() # except TypeError: # pass # except: # set_error() sys.stderr.write("%s not tested for parameter correctness.\n" % \ (method_name)) buf.clear() #if not error_detected: if True: method_name = "ldns_buffer.write_string_at()" sys.stderr.write("%s not tested.\n" % (method_name)) #if not error_detected: if True: method_name = "ldns_buffer.write_u16()" try: buf.write_u16(ord("b") * 0x0101) except: set_error() try: buf.write_u16("") set_error() except TypeError: pass except: set_error() buf.clear() #if not error_detected: if True: method_name = "ldns_buffer.write_u16_at()" buf.printf("a") try: buf.write_u16_at(1, ord("b") * 0x0101) except: set_error() try: buf.write_u16_at("", ord("b") * 0x0101) set_error() except TypeError: pass except: set_error() # try: # buf.write_u16_at(-1, ord("b") * 0x0101) # set_error() # except ValueError: # pass # except: # set_error() try: buf.write_u16_at(1, "") set_error() except TypeError: pass except: set_error() #if not error_detected: if True: method_name = "ldns_buffer.write_u32()" try: buf.write_u32(ord("b") * 0x01010101) except: set_error() try: buf.write_u32("") set_error() except TypeError: pass except: set_error() buf.clear() #if not error_detected: if True: method_name = "ldns_buffer.write_u32_at()" buf.printf("a") try: buf.write_u32_at(1, ord("b") * 0x01010101) except: set_error() try: buf.write_u32_at("", ord("b") * 0x01010101) set_error() except TypeError: pass except: set_error() # try: # buf.write_u32_at(-1, ord("b") * 0x01010101) # set_error() # except ValueError: # pass # except: # set_error() try: buf.write_u32_at(1, "") set_error() except TypeError: pass except: set_error() #if not error_detected: if True: method_name = "ldns_buffer.write_u8()" try: buf.write_u8(ord("b")) except: set_error() try: buf.write_u8("") set_error() except TypeError: pass except: set_error() buf.clear() #if not error_detected: if True: method_name = "ldns_buffer.write_u8_at()" buf.printf("a") try: buf.write_u8_at(1, ord("b")) except: set_error() try: buf.write_u8_at("", ord("b")) set_error() except TypeError: pass except: set_error() # try: # buf.write_u8_at(-1, ord("b")) # set_error() # except ValueError: # pass # except: # set_error() try: buf.write_u8_at(1, "") set_error() except TypeError: pass except: set_error() if not error_detected: sys.stdout.write("%s: passed.\n" % (os.path.basename(__file__))) else: sys.stdout.write("%s: errors detected.\n" % (os.path.basename(__file__))) sys.exit(1) ldns-1.6.17/contrib/python/examples/ldns-axfr.py0000775000175100017510000000327512264060151021174 0ustar willemwillem#!/usr/bin/python # vim:fileencoding=utf-8 # # AXFR client with IDN (Internationalized Domain Names) support # import ldns import encodings.idna def utf2name(name): return '.'.join([encodings.idna.ToASCII(a) for a in name.split('.')]) def name2utf(name): return '.'.join([encodings.idna.ToUnicode(a) for a in name.split('.')]) resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") #addr = ldns.ldns_get_rr_list_addr_by_name(resolver, "zone.nic.cz", ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD); addr = resolver.get_addr_by_name("zone.nic.cz", ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD); if (not addr): raise Exception("Can't retrieve server address") print "Addr_by_name:",str(addr).replace("\n","; ") #remove all nameservers while resolver.pop_nameserver(): pass #insert server addr for rr in addr.rrs(): resolver.push_nameserver_rr(rr) #AXFR transfer status = resolver.axfr_start(utf2name(u"háÄkyÄárky.cz"), ldns.LDNS_RR_CLASS_IN) if status != ldns.LDNS_STATUS_OK: raise Exception("Can't start AXFR. Error: %s" % ldns.ldns_get_errorstr_by_id(status)) #Print results while True: rr = resolver.axfr_next() if not rr: break rdf = rr.owner() if (rdf.get_type() == ldns.LDNS_RDF_TYPE_DNAME): print "RDF owner: type=",rdf.get_type_str(),"data=",name2utf(str(rdf)) else: print "RDF owner: type=",rdf.get_type_str(),"data=",str(rdf) print " RR type=", rr.get_type_str()," ttl=",rr.ttl() for rdf in rr.rdfs(): if (rdf.get_type() == ldns.LDNS_RDF_TYPE_DNAME): print " RDF: type=",rdf.get_type_str(),"data=",name2utf(str(rdf)) else: print " RDF: type=",rdf.get_type_str(),"data=",str(rdf) print ldns-1.6.17/contrib/python/examples/ldns-dnssec.py0000775000175100017510000000215212264060151021504 0ustar willemwillem#!/usr/bin/python # -*- coding: utf-8 -*- import ldns import sys debug = True # Check args argc = len(sys.argv) name = "www.nic.cz" if argc < 2: print "Usage:", sys.argv[0], "domain [resolver_addr]" sys.exit(1) else: name = sys.argv[1] # Create resolver resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") resolver.set_dnssec(True) # Custom resolver if argc > 2: # Clear previous nameservers ns = resolver.pop_nameserver() while ns != None: ns = resolver.pop_nameserver() ip = ldns.ldns_rdf.new_frm_str(sys.argv[2], ldns.LDNS_RDF_TYPE_A) resolver.push_nameserver(ip) # Resolve DNS name pkt = resolver.query(name, ldns.LDNS_RR_TYPE_A, ldns.LDNS_RR_CLASS_IN) if pkt and pkt.answer(): # Debug if debug: print "NS returned:", pkt.get_rcode(), "(AA: %d AD: %d)" % ( pkt.ad(), pkt.ad() ) # SERVFAIL indicated bogus name if pkt.get_rcode() is ldns.LDNS_RCODE_SERVFAIL: print name, "is bogus" # Check AD (Authenticated) bit if pkt.get_rcode() is ldns.LDNS_RCODE_NOERROR: if pkt.ad(): print name, "is secure" else: print name, "is insecure" ldns-1.6.17/contrib/python/examples/ldns-zone.py0000775000175100017510000000040412264060151021176 0ustar willemwillem#!/usr/bin/python import ldns #Read zone from file zone = ldns.ldns_zone.new_frm_fp(open("zone.txt","r"), None, 0, ldns.LDNS_RR_CLASS_IN) print zone print "SOA:", zone.soa() for r in zone.rrs().rrs(): print "RR:", r zone = ldns.ldns_zone() #print zone ldns-1.6.17/contrib/python/examples/test_resolver.py0000775000175100017510000013031512264060151022172 0ustar willemwillem#!/usr/bin/env python # # ldns_resolver testing script. # # Do not use constructs that differ between Python 2 and 3. # Use write on stdout or stderr. # import ldns import sys import os import inspect class_name = "ldns_resolver" method_name = None error_detected = False temp_fname = "tmp_resolver.txt" def set_error(): """ Writes an error message and sets error flag. """ global class_name global method_name global error_detected error_detected = True sys.stderr.write("(line %d): malfunctioning method %s.\n" % \ (inspect.currentframe().f_back.f_lineno, method_name)) #if not error_detected: if True: method_name = class_name + ".axfr_complete()" sys.stderr.write("%s not tested.\n" % (method_name)) #if not error_detected: if True: method_name = class_name + ".axfr_last_pkt()" sys.stderr.write("%s not tested.\n" % (method_name)) #if not error_detected: if True: method_name = class_name + ".axfr_next()" sys.stderr.write("%s not tested.\n" % (method_name)) #if not error_detected: if True: method_name = class_name + ".axfr_start()" sys.stderr.write("%s not tested.\n" % (method_name)) #if not error_detected: if True: method_name = class_name + ".debug()" resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") resolver.set_debug(False) try: ret = resolver.debug() if not isinstance(ret, bool): set_error() if ret != False: set_error() except: set_error() resolver.set_debug(True) try: ret = resolver.debug() if not isinstance(ret, bool): set_error() if ret != True: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".dec_nameserver_count()" resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") cnt = resolver.nameserver_count() try: resolver.dec_nameserver_count() except: set_error() if cnt != (resolver.nameserver_count() + 1): set_error() #if not error_detected: if True: method_name = class_name + ".defnames()" resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") resolver.set_defnames(False) try: ret = resolver.defnames() if not isinstance(ret, bool): set_error() if ret != False: set_error() except: set_error() resolver.set_defnames(True) try: ret = resolver.defnames() if not isinstance(ret, bool): set_error() if ret != True: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".dnsrch()" resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") resolver.set_dnsrch(False) try: ret = resolver.dnsrch() if not isinstance(ret, bool): set_error() if ret != False: set_error() except: set_error() resolver.set_dnsrch(True) try: ret = resolver.dnsrch() if not isinstance(ret, bool): set_error() if ret != True: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".dnssec()" resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") resolver.set_dnssec(False) try: ret = resolver.dnssec() if not isinstance(ret, bool): set_error() if ret != False: set_error() except: set_error() resolver.set_dnssec(True) try: ret = resolver.dnssec() if not isinstance(ret, bool): set_error() if ret != True: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".dnssec_anchors()" resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") rrl = ldns.ldns_rr_list.new() try: ret = resolver.dnssec_anchors() if ret != None: set_error() except: set_error() resolver.set_dnssec_anchors(rrl) try: ret = resolver.dnssec_anchors() if not isinstance(ret, ldns.ldns_rr_list): set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".dnssec_cd()" resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") resolver.set_dnssec_cd(False) try: ret = resolver.dnssec_cd() if not isinstance(ret, bool): set_error() if ret != False: set_error() except: set_error() resolver.set_dnssec_cd(True) try: ret = resolver.dnssec_cd() if not isinstance(ret, bool): set_error() if ret != True: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".domain()" resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") resolver.set_domain(None) try: ret = resolver.domain() if ret != None: set_error() except: set_error() dname = ldns.ldns_dname("example.com.") resolver.set_domain(dname) try: ret = resolver.domain() if not isinstance(ret, ldns.ldns_dname): set_error() if ret != dname: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".edns_udp_size()" try: resolver = ldns.ldns_resolver.new() if not isinstance(resolver, ldns.ldns_resolver): set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".edns_udp_size()" resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") resolver.set_edns_udp_size(4096) try: ret = resolver.edns_udp_size() if (not isinstance(ret, int)) and (not isinstance(ret, long)): set_error() if ret != 4096: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".fail()" resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") resolver.set_fail(False) try: ret = resolver.fail() if not isinstance(ret, bool): set_error() if ret != False: set_error() except: set_error() resolver.set_fail(True) try: ret = resolver.fail() if not isinstance(ret, bool): set_error() if ret != True: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".fallback()" resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") resolver.set_fallback(False) try: ret = resolver.fallback() if not isinstance(ret, bool): set_error() if ret != False: set_error() except: set_error() resolver.set_fallback(True) try: ret = resolver.fallback() if not isinstance(ret, bool): set_error() if ret != True: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".get_addr_by_name()" resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") try: ret = resolver.get_addr_by_name("www.google.com", ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD) if not isinstance(ret, ldns.ldns_rr_list): set_error() except: set_error() try: ret = resolver.get_addr_by_name(1, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD) set_error() except TypeError as e: pass except: set_error() try: ret = resolver.get_addr_by_name("www.google.com", "bad argument", ldns.LDNS_RD) set_error() except TypeError as e: pass except: set_error() try: ret = resolver.get_addr_by_name("www.google.com", ldns.LDNS_RR_CLASS_IN, "bad argument") set_error() except TypeError as e: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".get_name_by_addr()" resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") try: addr = resolver.get_name_by_addr("8.8.8.8", ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD) if not isinstance(addr, ldns.ldns_rr_list): set_error() except: set_error() try: addr = resolver.get_name_by_addr(1, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD) set_error() except TypeError as e: pass except: set_error() try: addr = resolver.get_name_by_addr("8.8.8.8", "bad argument", ldns.LDNS_RD) set_error() except TypeError as e: pass except: set_error() try: addr = resolver.get_name_by_addr("8.8.8.8", ldns.LDNS_RR_CLASS_IN, "bad argument") set_error() except TypeError as e: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".igntc()" resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") resolver.set_igntc(False) try: ret = resolver.igntc() if not isinstance(ret, bool): set_error() if ret != False: set_error() except: set_error() resolver.set_igntc(True) try: ret = resolver.igntc() if not isinstance(ret, bool): set_error() if ret != True: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".incr_nameserver_count()" resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") cnt = resolver.nameserver_count() try: resolver.incr_nameserver_count() except: set_error() if (cnt + 1) != resolver.nameserver_count(): set_error() #if not error_detected: if True: method_name = class_name + ".ip6()" resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") resolver.set_ip6(0) try: ret = resolver.ip6() if (not isinstance(ret, int)) and (not isinstance(ret, long)): set_error() if ret != 0: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".nameserver_count()" resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") resolver.set_nameserver_count(1) try: ret = resolver.nameserver_count() if (not isinstance(ret, int)) and (not isinstance(ret, long)): set_error() if ret != 1: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".nameserver_rtt()" resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") num = resolver.nameserver_count() for i in range(0, num): resolver.set_nameserver_rtt(i, i + 1) try: for i in range(0, num): ret = resolver.nameserver_rtt(i) if (not isinstance(ret, int)) and (not isinstance(ret, long)): set_error() if (i + 1) != ret: set_error() except: set_error() try: ret = resolver.nameserver_rtt("bad argument") set_error() except TypeError as e: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".nameservers()" sys.stderr.write("%s not tested.\n" % (method_name)) #if not error_detected: if True: method_name = class_name + ".nameservers_randomize()" resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") try: resolver.nameservers_randomize() except: set_error() #if not error_detected: if True: method_name = class_name + ".new_frm_file()" try: ret = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf", raiseException=True) if not isinstance(ret, ldns.ldns_resolver): set_error() except: set_error() try: ret = ldns.ldns_resolver.new_frm_file(1, raiseException=True) set_error() except TypeError as e: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".new_frm_fp()" fi = open("/etc/resolv.conf") try: ret = ldns.ldns_resolver.new_frm_fp(fi, raiseException=True) if not isinstance(ret, ldns.ldns_resolver): set_error() except: set_error() fi.close() try: ret = ldns.ldns_resolver.new_frm_fp(1, raiseException=True) set_error() except TypeError as e: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".new_frm_fp_l()" fi = open("/etc/resolv.conf") try: ret, line = ldns.ldns_resolver.new_frm_fp_l(fi, raiseException=True) if not isinstance(ret, ldns.ldns_resolver): set_error() if (not isinstance(line, int)) and (not isinstance(line, long)): set_error() except: set_error() fi.close() try: ret, line = ldns.ldns_resolver.new_frm_fp_l(1, raiseException=True) set_error() except TypeError as e: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".pop_nameserver()" resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") cnt = resolver.nameserver_count() try: for i in range(0, cnt): ret = resolver.pop_nameserver() if not isinstance(ret, ldns.ldns_rdf): set_error() except: set_error() try: ret = resolver.pop_nameserver() if ret != None: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".port()" resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") resolver.set_port(12345) try: ret = resolver.port() if (not isinstance(ret, int)) and (not isinstance(ret, long)): set_error() if ret != 12345: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".prepare_query_pkt()" resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") try: ret = resolver.prepare_query_pkt("example.com.", ldns.LDNS_RR_TYPE_A, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD, raiseException=True) if not isinstance(ret, ldns.ldns_pkt): set_error() except: set_error() try: ret = resolver.prepare_query_pkt(1, ldns.LDNS_RR_TYPE_A, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD, raiseException=True) set_error() except TypeError as e: pass except: set_error() try: ret = resolver.prepare_query_pkt("example.com.", "bad argument", ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD, raiseException=True) set_error() except TypeError as e: pass except: set_error() try: ret = resolver.prepare_query_pkt("example.com.", ldns.LDNS_RR_TYPE_A, "bad argument", ldns.LDNS_RD, raiseException=True) set_error() except TypeError as e: pass except: set_error() try: ret = resolver.prepare_query_pkt("example.com.", ldns.LDNS_RR_TYPE_A, ldns.LDNS_RR_CLASS_IN, "bad argument", raiseException=True) set_error() except TypeError as e: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".push_dnssec_anchor()" resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") key = ldns.ldns_key.new_frm_algorithm(ldns.LDNS_SIGN_DSA, 512) domain = ldns.ldns_dname("example.") key.set_pubkey_owner(domain) pubkey = key.key_to_rr() ds = ldns.ldns_key_rr2ds(pubkey, ldns.LDNS_SHA1) try: ret = resolver.push_dnssec_anchor(ds) if ret != ldns.LDNS_STATUS_OK: set_error() except: set_error() rr = ldns.ldns_rr.new_frm_str("test1 600 IN A 0.0.0.0") try: ret = resolver.push_dnssec_anchor(rr) if ret == ldns.LDNS_STATUS_OK: set_error() except: set_error() try: ret = resolver.push_dnssec_anchor("bad argument") set_error() except TypeError as e: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".push_nameserver()" resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") rdf = ldns.ldns_rdf.new_frm_str("127.0.0.1", ldns.LDNS_RDF_TYPE_A) try: ret = resolver.push_nameserver(rdf) if ret != ldns.LDNS_STATUS_OK: set_error() except: set_error() rdf = ldns.ldns_rdf.new_frm_str("::1", ldns.LDNS_RDF_TYPE_AAAA) try: ret = resolver.push_nameserver(rdf) if ret != ldns.LDNS_STATUS_OK: set_error() except: set_error() rdf = ldns.ldns_rdf.new_frm_str("example.com.", ldns.LDNS_RDF_TYPE_DNAME) try: ret = resolver.push_nameserver(rdf) if ret == ldns.LDNS_STATUS_OK: set_error() except: set_error() try: ret = resolver.push_nameserver("bad argument") set_error() except TypeError as e: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".push_nameserver_rr()" resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") rr = ldns.ldns_rr.new_frm_str("test 600 IN A 127.0.0.1") try: ret = resolver.push_nameserver_rr(rr) if ret != ldns.LDNS_STATUS_OK: set_error() except: set_error() rr = ldns.ldns_rr.new_frm_str("test 600 IN AAAA ::1") try: ret = resolver.push_nameserver_rr(rr) if ret != ldns.LDNS_STATUS_OK: set_error() except: set_error() rr = ldns.ldns_rr.new_frm_str("test 600 IN NS 8.8.8.8") try: ret = resolver.push_nameserver_rr(rr) if ret == ldns.LDNS_STATUS_OK: set_error() except: set_error() try: ret = resolver.push_nameserver_rr("bad argument") set_error() except TypeError as e: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".push_nameserver_rr_list()" resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") rrl = ldns.ldns_rr_list.new() rr = ldns.ldns_rr.new_frm_str("test 600 IN A 127.0.0.1") rrl.push_rr(rr) try: ret = resolver.push_nameserver_rr_list(rrl) if ret != ldns.LDNS_STATUS_OK: set_error() except: set_error() rrl = ldns.ldns_rr_list.new() rr = ldns.ldns_rr.new_frm_str("test 600 IN AAAA ::1") rrl.push_rr(rr) try: ret = resolver.push_nameserver_rr_list(rrl) if ret != ldns.LDNS_STATUS_OK: set_error() except: set_error() rrl = ldns.ldns_rr_list.new() rr = ldns.ldns_rr.new_frm_str("test 600 IN NS 8.8.8.8") rrl.push_rr(rr) try: ret = resolver.push_nameserver_rr_list(rrl) if ret == ldns.LDNS_STATUS_OK: set_error() except: set_error() try: ret = resolver.push_nameserver_rr_list("bad argument") set_error() except TypeError as e: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".push_searchlist()" resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") resolver.push_searchlist("example.com.") try: resolver.push_searchlist("example.com.") except: set_error() try: resolver.push_searchlist(1) set_error() except TypeError as e: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".query()" resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") try: ret = resolver.query("www.nic.cz", ldns.LDNS_RR_TYPE_A, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD) if not isinstance(ret, ldns.ldns_pkt): set_error() except: set_error() try: ret = resolver.query(1, ldns.LDNS_RR_TYPE_A, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD) set_error() except TypeError as e: pass except: set_error() try: ret = resolver.query("www.nic.cz", "bad argument", ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD) set_error() except TypeError as e: pass except: set_error() try: ret = resolver.query("www.nic.cz", ldns.LDNS_RR_TYPE_A, "bad argument", ldns.LDNS_RD) set_error() except TypeError as e: pass except: set_error() try: ret = resolver.query("www.nic.cz", ldns.LDNS_RR_TYPE_A, ldns.LDNS_RR_CLASS_IN, "bad argument") set_error() except TypeError as e: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".random()" resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") resolver.set_random(False) try: ret = resolver.random() if not isinstance(ret, bool): set_error() if ret != False: set_error() except: set_error() resolver.set_random(True) try: ret = resolver.random() if not isinstance(ret, bool): set_error() if ret != True: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".recursive()" resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") resolver.set_recursive(False) try: ret = resolver.recursive() if not isinstance(ret, bool): set_error() if ret != False: set_error() except: set_error() resolver.set_recursive(True) try: ret = resolver.recursive() if not isinstance(ret, bool): set_error() if ret != True: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".retrans()" resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") resolver.set_retrans(127) try: ret = resolver.retrans() if (not isinstance(ret, int)) and (not isinstance(ret, long)): set_error() if ret != 127: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".retry()" resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") resolver.set_retry(4) try: ret = resolver.retry() if (not isinstance(ret, int)) and (not isinstance(ret, long)): set_error() if ret != 4: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".rtt()" sys.stderr.write("%s not tested.\n" % (method_name)) #if not error_detected: if True: method_name = class_name + ".search()" resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") try: ret = resolver.search("www.nic.cz", ldns.LDNS_RR_TYPE_A, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD) if not isinstance(ret, ldns.ldns_pkt): set_error() except: set_error() try: ret = resolver.search(1, ldns.LDNS_RR_TYPE_A, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD) set_error() except TypeError as e: pass except: set_error() try: ret = resolver.search("www.nic.cz", "bad argument", ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD) set_error() except TypeError as e: pass except: set_error() try: ret = resolver.search("www.nic.cz", ldns.LDNS_RR_TYPE_A, "bad argument", ldns.LDNS_RD) set_error() except TypeError as e: pass except: set_error() try: ret = resolver.search("www.nic.cz", ldns.LDNS_RR_TYPE_A, ldns.LDNS_RR_CLASS_IN, "bad argument") set_error() except TypeError as e: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".searchlist()" sys.stderr.write("%s not tested.\n" % (method_name)) #if not error_detected: if True: method_name = class_name + ".searchlist_count()" resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") try: ret = resolver.searchlist_count() if (not isinstance(ret, int)) and (not isinstance(ret, long)): set_error() if ret != 0: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".send()" resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") try: ret = resolver.send("www.nic.cz", ldns.LDNS_RR_TYPE_A, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD) if not isinstance(ret, ldns.ldns_pkt): set_error() except: set_error() try: ret = resolver.send(1, ldns.LDNS_RR_TYPE_A, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD) set_error() except TypeError as e: pass except: set_error() try: ret = resolver.send("www.nic.cz", "bad argument", ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD) set_error() except TypeError as e: pass except: set_error() try: ret = resolver.send("www.nic.cz", ldns.LDNS_RR_TYPE_A, "bad argument", ldns.LDNS_RD) set_error() except TypeError as e: pass except: set_error() try: ret = resolver.send("www.nic.cz", ldns.LDNS_RR_TYPE_A, ldns.LDNS_RR_CLASS_IN, "bad argument") set_error() except TypeError as e: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".send_pkt()" resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD | ldns.LDNS_AD) try: status, ret = resolver.send_pkt(pkt) if status != ldns.LDNS_STATUS_OK: ste_error() if not isinstance(ret, ldns.ldns_pkt): set_error() except: set_error() try: status, ret = resolver.send_pkt("bad argument") set_error() except TypeError as e: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".set_debug()" resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") try: resolver.set_debug(False) ret = resolver.debug() if not isinstance(ret, bool): set_error() if ret != False: set_error() except: set_error() try: resolver.set_debug(True) ret = resolver.debug() if not isinstance(ret, bool): set_error() if ret != True: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".set_defnames()" resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") try: resolver.set_defnames(False) ret = resolver.defnames() if not isinstance(ret, bool): set_error() if ret != False: set_error() except: set_error() try: resolver.set_defnames(True) ret = resolver.defnames() if not isinstance(ret, bool): set_error() if ret != True: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".set_dnsrch()" resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") try: resolver.set_dnsrch(False) ret = resolver.dnsrch() if not isinstance(ret, bool): set_error() if ret != False: set_error() except: set_error() try: resolver.set_dnsrch(True) ret = resolver.dnsrch() if not isinstance(ret, bool): set_error() if ret != True: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".set_dnssec()" resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") try: resolver.set_dnssec(False) ret = resolver.dnssec() if not isinstance(ret, bool): set_error() if ret != False: set_error() except: set_error() try: resolver.set_dnssec(True) ret = resolver.dnssec() if not isinstance(ret, bool): set_error() if ret != True: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".set_dnssec_anchors()" resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") rrl = ldns.ldns_rr_list.new() try: resolver.set_dnssec_anchors(rrl) ret = resolver.dnssec_anchors() if not isinstance(ret, ldns.ldns_rr_list): set_error() except: set_error() try: resolver.set_dnssec_anchors("bad argument") set_error() except TypeError as e: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".set_dnssec_cd()" resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") try: resolver.set_dnssec_cd(False) ret = resolver.dnssec_cd() if not isinstance(ret, bool): set_error() if ret != False: set_error() except: set_error() try: resolver.set_dnssec_cd(True) ret = resolver.dnssec_cd() if not isinstance(ret, bool): set_error() if ret != True: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".set_domain()" resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") try: resolver.set_domain(None) ret = resolver.domain() if ret != None: set_error() except: set_error() dname = ldns.ldns_dname("example.com.") try: resolver.set_domain(dname) ret = resolver.domain() if not isinstance(ret, ldns.ldns_dname): set_error() if ret != dname: set_error() except: set_error() rdf = ldns.ldns_rdf.new_frm_str("example.com.", ldns.LDNS_RDF_TYPE_DNAME) try: resolver.set_domain(rdf) ret = resolver.domain() if not isinstance(ret, ldns.ldns_rdf): set_error() if ret != dname: set_error() except: set_error() resolver.set_domain("example.com.") try: resolver.set_domain("example.com.") ret = resolver.domain() if not isinstance(ret, ldns.ldns_dname): set_error() if ret != dname: set_error() except: set_error() rdf = ldns.ldns_rdf.new_frm_str("127.0.0.1", ldns.LDNS_RDF_TYPE_A) try: resolver.set_domain(rdf) set_error() except Exception as e: pass except: set_error() try: resolver.set_domain(1) set_error() except TypeError as e: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".set_edns_udp_size()" resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") try: resolver.set_edns_udp_size(4096) ret = resolver.edns_udp_size() if (not isinstance(ret, int)) and (not isinstance(ret, long)): set_error() if ret != 4096: set_error() except: set_error() try: resolver.set_edns_udp_size("bad argument") set_error() except TypeError as e: pass except: ste_error() #if not error_detected: if True: method_name = class_name + ".set_fail()" resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") try: resolver.set_fail(False) ret = resolver.fail() if not isinstance(ret, bool): set_error() if ret != False: set_error() except: set_error() try: resolver.set_fail(True) ret = resolver.fail() if not isinstance(ret, bool): set_error() if ret != True: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".set_fallback()" resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") try: resolver.set_fallback(False) ret = resolver.fallback() if not isinstance(ret, bool): set_error() if ret != False: set_error() except: set_error() try: resolver.set_fallback(True) ret = resolver.fallback() if not isinstance(ret, bool): set_error() if ret != True: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".set_igntc()" resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") try: resolver.set_igntc(False) ret = resolver.igntc() if not isinstance(ret, bool): set_error() if ret != False: set_error() except: set_error() try: resolver.set_igntc(True) ret = resolver.igntc() if not isinstance(ret, bool): set_error() if ret != True: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".set_ip6()" resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") try: resolver.set_ip6(1) ret = resolver.ip6() if (not isinstance(ret, int)) and (not isinstance(ret, long)): set_error() if ret != 1: set_error() except: set_error() try: resolver.set_ip6("bad argument") set_error() except TypeError as e: pass except: ste_error() #if not error_detected: if True: method_name = class_name + ".set_nameserver_count()" resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") try: resolver.set_nameserver_count(2) ret = resolver.nameserver_count() if (not isinstance(ret, int)) and (not isinstance(ret, long)): set_error() if ret != 2: set_error() except: set_error() try: resolver.set_nameserver_count("bad argument") set_error() except TypeError as e: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".set_nameserver_rtt()" resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") num = resolver.nameserver_count() try: for i in range(0, num): resolver.set_nameserver_rtt(i, i + 1) ret = resolver.nameserver_rtt(i) if (not isinstance(ret, int)) and (not isinstance(ret, long)): set_error() if (i + 1) != ret: set_error() except: set_error() try: ret = resolver.set_nameserver_rtt("bad argument", 0) set_error() except TypeError as e: pass except: set_error() try: ret = resolver.set_nameserver_rtt(0, "bad argument") set_error() except TypeError as e: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".set_nameservers()" sys.stderr.write("%s not tested.\n" % (method_name)) #if not error_detected: if True: method_name = class_name + ".set_port()" resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") try: resolver.set_port(12345) ret = resolver.port() if (not isinstance(ret, int)) and (not isinstance(ret, long)): set_error() if ret != 12345: set_error() except: set_error() try: resolver.set_port("bad argument") set_error() except TypeError as e: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".set_random()" resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") try: resolver.set_random(False) ret = resolver.random() if not isinstance(ret, bool): set_error() if ret != False: set_error() except: set_error() try: resolver.set_random(True) ret = resolver.random() if not isinstance(ret, bool): set_error() if ret != True: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".set_recursive()" resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") try: resolver.set_recursive(False) ret = resolver.recursive() if not isinstance(ret, bool): set_error() if ret != False: set_error() except: set_error() try: resolver.set_recursive(True) ret = resolver.recursive() if not isinstance(ret, bool): set_error() if ret != True: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".set_retrans()" resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") try: resolver.set_retrans(127) ret = resolver.retrans() if (not isinstance(ret, int)) and (not isinstance(ret, long)): set_error() if ret != 127: set_error() except: set_error() try: resolver.set_retrans("bad argument") set_error() except TypeError as e: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".set_retry()" resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") try: resolver.set_retry(4) ret = resolver.retry() if (not isinstance(ret, int)) and (not isinstance(ret, long)): set_error() if ret != 4: set_error() except: set_error() try: resolver.set_retry("bad argument") set_error() except TypeError as e: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".set_rtt()" sys.stderr.write("%s not tested.\n" % (method_name)) #if not error_detected: if True: method_name = class_name + ".set_timeout()" sys.stderr.write("%s not tested.\n" % (method_name)) #if not error_detected: if True: method_name = class_name + ".set_tsig_algorithm()" resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") tsigstr = "hmac-md5.sig-alg.reg.int." try: resolver.set_tsig_algorithm(tsigstr) ret = resolver.tsig_algorithm() if not isinstance(ret, str): set_error() if ret != tsigstr: set_error() except: set_error() try: resolver.set_tsig_algorithm(1) set_error() except TypeError as e: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".set_tsig_keydata()" resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") tkdstr = "Humpty Dumpty sat on a wall, Humpty Dumpty had a great fall, All the King's horses and all the King's men, Couldn't put Humpty together again." try: resolver.set_tsig_keydata(tkdstr) ret = resolver.tsig_keydata() if not isinstance(ret, str): set_error() if ret != tkdstr: set_error() except: set_error() try: resolver.set_tsig_keydata(1) set_error() except TypeError as e: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".set_tsig_keyname()" resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") tknstr = "key 1" try: resolver.set_tsig_keyname(tknstr) ret = resolver.tsig_keyname() if not isinstance(ret, str): set_error() if ret != tknstr: set_error() except: set_error() try: resolver.set_tsig_keyname(1) set_error() except TypeError as e: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".set_usevc()" resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") try: resolver.set_usevc(False) ret = resolver.usevc() if not isinstance(ret, bool): set_error() if ret != False: set_error() except: set_error() try: resolver.set_usevc(True) ret = resolver.usevc() if not isinstance(ret, bool): set_error() if ret != True: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".timeout()" sys.stderr.write("%s not tested.\n" % (method_name)) #if not error_detected: if True: method_name = class_name + ".trusted_key()" resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") key = ldns.ldns_key.new_frm_algorithm(ldns.LDNS_SIGN_DSA, 512) domain = ldns.ldns_dname("example.") key.set_pubkey_owner(domain) pubkey = key.key_to_rr() ds = ldns.ldns_key_rr2ds(pubkey, ldns.LDNS_SHA1) resolver.push_dnssec_anchor(ds) rrl = ldns.ldns_rr_list.new() try: ret = resolver.trusted_key(rrl) if ret != None: set_error() except: set_error() rrl.push_rr(ds) ret = resolver.trusted_key(rrl) try: ret = resolver.trusted_key(rrl) if not isinstance(ret, ldns.ldns_rr_list): set_error() if ret.rr_count() != 1: set_error() except: set_error() try: ret = resolver.trusted_key("bad argument") set_error() except TypeError as e: pass except: set_error() #if not error_detected: if True: method_name = class_name + ".tsig_algorithm()" resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") try: ret = resolver.tsig_algorithm() if ret != None: set_error() except: set_error() tsigstr = "hmac-md5.sig-alg.reg.int." resolver.set_tsig_algorithm(tsigstr) try: ret = resolver.tsig_algorithm() if not isinstance(ret, str): set_error() if ret != tsigstr: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".tsig_keydata()" resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") try: ret = resolver.tsig_keydata() if ret != None: set_error() except: set_error() tkdstr = "Twas brillig, and the slithy toves Did gyre and gimble in the wabe; All mimsy were the borogoves, And the mome raths outgrabe." resolver.set_tsig_keydata(tkdstr) try: ret = resolver.tsig_keydata() if not isinstance(ret, str): set_error() if ret != tkdstr: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".tsig_keyname()" resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") try: ret = resolver.tsig_keyname() if ret != None: set_error() except: set_error() tknstr = "key 2" resolver.set_tsig_keyname(tknstr) try: ret = resolver.tsig_keyname() if not isinstance(ret, str): set_error() if ret != tknstr: set_error() except: set_error() #if not error_detected: if True: method_name = class_name + ".usevc()" resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") resolver.set_usevc(False) try: ret = resolver.usevc() if not isinstance(ret, bool): set_error() if ret != False: set_error() except: set_error() resolver.set_usevc(True) try: ret = resolver.usevc() if not isinstance(ret, bool): set_error() if ret != True: set_error() except: set_error() if not error_detected: sys.stdout.write("%s: passed.\n" % (os.path.basename(__file__))) else: sys.stdout.write("%s: errors detected.\n" % (os.path.basename(__file__))) sys.exit(1) ldns-1.6.17/contrib/python/ldns_rr.i0000664000175100017510000025266712264060151016733 0ustar willemwillem/****************************************************************************** * ldns_rr.i: LDNS resource records (RR), RR list * * Copyright (c) 2009, Zdenek Vasicek (vasicek AT fit.vutbr.cz) * Karel Slany (slany AT fit.vutbr.cz) * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * Redistributions of source code must retain the above copyright notice, * this list of conditions and the following disclaimer. * * Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * Neither the name of the organization nor the names of its * contributors may be used to endorse or promote products derived from * this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. *****************************************************************************/ /* ========================================================================= */ /* SWIG setting and definitions. */ /* ========================================================================= */ /* Creates a temporary instance of (ldns_rr *). */ %typemap(in, numinputs=0, noblock=1) (ldns_rr **) { ldns_rr *$1_rr; $1 = &$1_rr; } /* Result generation, appends (ldns_rr *) after the result. */ %typemap(argout, noblock=1) (ldns_rr **) { $result = SWIG_Python_AppendOutput($result, SWIG_NewPointerObj(SWIG_as_voidptr($1_rr), SWIGTYPE_p_ldns_struct_rr, SWIG_POINTER_OWN | 0 )); } %nodefaultctor ldns_struct_rr; /* No default constructor. */ %nodefaultdtor ldns_struct_rr; /* No default destructor. */ %ignore ldns_struct_rr::_rdata_fields; %newobject ldns_rr_clone; %newobject ldns_rr_new; %newobject ldns_rr_new_frm_type; %newobject ldns_rr_pop_rdf; %delobject ldns_rr_free; %rename(ldns_rr) ldns_struct_rr; %newobject ldns_rr2str; %newobject ldns_rr_type2str; %newobject ldns_rr_class2str; %newobject ldns_read_anchor_file; /* Clone rdf data on pull. */ /* Clone will fail with NULL argument. */ %newobject _ldns_rr_rdf; %rename(__ldns_rr_rdf) ldns_rr_rdf; %inline %{ ldns_rdf * _ldns_rr_rdf(ldns_rr *rr, size_t i) { ldns_rdf *rdf; rdf = ldns_rr_rdf(rr, i); return (rdf != NULL) ? ldns_rdf_clone(rdf) : NULL; } %} %newobject _ldns_rr_rrsig_algorithm; %rename(__ldns_rr_rrsig_algorithm) ldns_rr_rrsig_algorithm; %inline %{ ldns_rdf * _ldns_rr_rrsig_algorithm(ldns_rr *rr) { ldns_rdf *rdf; rdf = ldns_rr_rrsig_algorithm(rr); return (rdf != NULL) ? ldns_rdf_clone(rdf) : NULL; } %} %newobject _ldns_rr_dnskey_algorithm; %rename(__ldns_rr_dnskey_algorithm) ldns_rr_dnskey_algorithm; %inline %{ ldns_rdf * _ldns_rr_dnskey_algorithm(ldns_rr *rr) { ldns_rdf *rdf; rdf = ldns_rr_dnskey_algorithm(rr); return (rdf != NULL) ? ldns_rdf_clone(rdf) : NULL; } %} %newobject _ldns_rr_dnskey_flags; %rename(__ldns_rr_dnskey_flags) ldns_rr_dnskey_flags; %inline %{ ldns_rdf * _ldns_rr_dnskey_flags(ldns_rr *rr) { ldns_rdf *rdf; rdf = ldns_rr_dnskey_flags(rr); return (rdf != NULL) ? ldns_rdf_clone(rdf) : NULL; } %} %newobject _ldns_rr_dnskey_key; %rename(__ldns_rr_dnskey_key) ldns_rr_dnskey_key; %inline %{ ldns_rdf * _ldns_rr_dnskey_key(ldns_rr *rr) { ldns_rdf *rdf; rdf = ldns_rr_dnskey_key(rr); return (rdf != NULL) ? ldns_rdf_clone(rdf) : NULL; } %} %newobject _ldns_rr_dnskey_protocol; %rename(__ldns_rr_dnskey_protocol) ldns_rr_dnskey_protocol; %inline %{ ldns_rdf * _ldns_rr_dnskey_protocol(ldns_rr *rr) { ldns_rdf *rdf; rdf = ldns_rr_dnskey_protocol(rr); return (rdf != NULL) ? ldns_rdf_clone(rdf) : NULL; } %} %newobject _ldns_rr_owner; %rename(__ldns_rr_owner) ldns_rr_owner; %inline %{ ldns_rdf * _ldns_rr_owner(ldns_rr *rr) { ldns_rdf *rdf; rdf = ldns_rr_owner(rr); return (rdf != NULL) ? ldns_rdf_clone(rdf) : NULL; } %} %newobject _ldns_rr_a_address; %rename(__ldns_rr_a_address) ldns_rr_a_address; %inline %{ ldns_rdf * _ldns_rr_a_address(ldns_rr *rr) { ldns_rdf *rdf; rdf = ldns_rr_a_address(rr); return (rdf != NULL) ? ldns_rdf_clone(rdf) : NULL; } %} %newobject _ldns_rr_mx_exchange; %rename(__ldns_rr_mx_exchange) ldns_rr_mx_exchange; %inline %{ ldns_rdf * _ldns_rr_mx_exchange(ldns_rr *rr) { ldns_rdf *rdf; rdf = ldns_rr_mx_exchange(rr); return (rdf != NULL) ? ldns_rdf_clone(rdf) : NULL; } %} %newobject _ldns_rr_mx_preference; %rename(__ldns_rr_mx_preference) ldns_rr_mx_preference; %inline %{ ldns_rdf * _ldns_rr_mx_preference(ldns_rr *rr) { ldns_rdf *rdf; rdf = ldns_rr_mx_preference(rr); return (rdf != NULL) ? ldns_rdf_clone(rdf) : NULL; } %} %newobject _ldns_rr_ns_nsdname; %rename(__ldns_rr_ns_nsdname) ldns_rr_ns_nsdname; %inline %{ ldns_rdf * _ldns_rr_ns_nsdname(ldns_rr *rr) { ldns_rdf *rdf; rdf = ldns_rr_ns_nsdname(rr); return (rdf != NULL) ? ldns_rdf_clone(rdf) : NULL; } %} %newobject _ldns_rr_rrsig_expiration; %rename(__ldns_rr_rrsig_expiration) ldns_rr_rrsig_expiration; %inline %{ ldns_rdf * _ldns_rr_rrsig_expiration(ldns_rr *rr) { ldns_rdf *rdf; rdf = ldns_rr_rrsig_expiration(rr); return (rdf != NULL) ? ldns_rdf_clone(rdf) : NULL; } %} %newobject _ldns_rr_rrsig_inception; %rename(__ldns_rr_rrsig_inception) ldns_rr_rrsig_inception; %inline %{ ldns_rdf * _ldns_rr_rrsig_inception(ldns_rr *rr) { ldns_rdf *rdf; rdf = ldns_rr_rrsig_inception(rr); return (rdf != NULL) ? ldns_rdf_clone(rdf) : NULL; } %} %newobject _ldns_rr_rrsig_keytag; %rename(__ldns_rr_rrsig_keytag) ldns_rr_rrsig_keytag; %inline %{ ldns_rdf * _ldns_rr_rrsig_keytag(ldns_rr *rr) { ldns_rdf *rdf; rdf = ldns_rr_rrsig_keytag(rr); return (rdf != NULL) ? ldns_rdf_clone(rdf) : NULL; } %} %newobject _ldns_rr_rrsig_labels; %rename(__ldns_rr_rrsig_labels) ldns_rr_rrsig_labels; %inline %{ ldns_rdf * _ldns_rr_rrsig_labels(ldns_rr *rr) { ldns_rdf *rdf; rdf = ldns_rr_rrsig_labels(rr); return (rdf != NULL) ? ldns_rdf_clone(rdf) : NULL; } %} %newobject _ldns_rr_rrsig_origttl; %rename(__ldns_rr_rrsig_origttl) ldns_rr_rrsig_origttl; %inline %{ ldns_rdf * _ldns_rr_rrsig_origttl(ldns_rr *rr) { ldns_rdf *rdf; rdf = ldns_rr_rrsig_origttl(rr); return (rdf != NULL) ? ldns_rdf_clone(rdf) : NULL; } %} %newobject _ldns_rr_rrsig_sig; %rename(__ldns_rr_rrsig_sig) ldns_rr_rrsig_sig; %inline %{ ldns_rdf * _ldns_rr_rrsig_sig(ldns_rr *rr) { ldns_rdf *rdf; rdf = ldns_rr_rrsig_sig(rr); return (rdf != NULL) ? ldns_rdf_clone(rdf) : NULL; } %} %newobject _ldns_rr_rrsig_signame; %rename(__ldns_rr_rrsig_signame) ldns_rr_rrsig_signame; %inline %{ ldns_rdf * _ldns_rr_rrsig_signame(ldns_rr *rr) { ldns_rdf *rdf; rdf = ldns_rr_rrsig_signame(rr); return (rdf != NULL) ? ldns_rdf_clone(rdf) : NULL; } %} %newobject _ldns_rr_rrsig_typecovered; %rename(__ldns_rr_rrsig_typecovered) ldns_rr_rrsig_typecovered; %inline %{ ldns_rdf * _ldns_rr_rrsig_typecovered(ldns_rr *rr) { ldns_rdf *rdf; rdf = ldns_rr_rrsig_typecovered(rr); return (rdf != NULL) ? ldns_rdf_clone(rdf) : NULL; } %} /* End of pull cloning. */ /* Clone rdf data on push. */ %rename(__ldns_rr_a_set_address) ldns_rr_a_set_address; %inline %{ bool _ldns_rr_a_set_address(ldns_rr *rr, ldns_rdf *rdf) { return ldns_rr_a_set_address(rr, ldns_rdf_clone(rdf)); } %} %rename(__ldns_rr_dnskey_set_algorithm) ldns_rr_dnskey_set_algorithm; %inline %{ bool _ldns_rr_dnskey_set_algorithm(ldns_rr *rr, ldns_rdf *rdf) { return ldns_rr_dnskey_set_algorithm(rr, ldns_rdf_clone(rdf)); } %} %rename(__ldns_rr_dnskey_set_flags) ldns_rr_dnskey_set_flags; %inline %{ bool _ldns_rr_dnskey_set_flags(ldns_rr *rr, ldns_rdf *rdf) { return ldns_rr_dnskey_set_flags(rr, ldns_rdf_clone(rdf)); } %} %rename(__ldns_rr_dnskey_set_key) ldns_rr_dnskey_set_key; %inline %{ bool _ldns_rr_dnskey_set_key(ldns_rr *rr, ldns_rdf *rdf) { return ldns_rr_dnskey_set_key(rr, ldns_rdf_clone(rdf)); } %} %rename(__ldns_rr_dnskey_set_protocol) ldns_rr_dnskey_set_protocol; %inline %{ bool _ldns_rr_dnskey_set_protocol(ldns_rr *rr, ldns_rdf *rdf) { return ldns_rr_dnskey_set_protocol(rr, ldns_rdf_clone(rdf)); } %} %rename(__ldns_rr_push_rdf) ldns_rr_push_rdf; %inline %{ bool _ldns_rr_push_rdf(ldns_rr *rr, ldns_rdf *rdf) { return ldns_rr_push_rdf(rr, ldns_rdf_clone(rdf)); } %} %rename(__ldns_rr_rrsig_set_algorithm) ldns_rr_rrsig_set_algorithm; %inline %{ bool _ldns_rr_rrsig_set_algorithm(ldns_rr *rr, ldns_rdf *rdf) { return ldns_rr_rrsig_set_algorithm(rr, ldns_rdf_clone(rdf)); } %} %rename(__ldns_rr_rrsig_set_expiration) ldns_rr_rrsig_set_expiration; %inline %{ bool _ldns_rr_rrsig_set_expiration(ldns_rr *rr, ldns_rdf *rdf) { return ldns_rr_rrsig_set_expiration(rr, ldns_rdf_clone(rdf)); } %} %rename(__ldns_rr_rrsig_set_inception) ldns_rr_rrsig_set_inception; %inline %{ bool _ldns_rr_rrsig_set_inception(ldns_rr *rr, ldns_rdf *rdf) { return ldns_rr_rrsig_set_inception(rr, ldns_rdf_clone(rdf)); } %} %rename(__ldns_rr_rrsig_set_keytag) ldns_rr_rrsig_set_keytag; %inline %{ bool _ldns_rr_rrsig_set_keytag(ldns_rr *rr, ldns_rdf *rdf) { return ldns_rr_rrsig_set_keytag(rr, ldns_rdf_clone(rdf)); } %} %rename(__ldns_rr_rrsig_set_labels) ldns_rr_rrsig_set_labels; %inline %{ bool _ldns_rr_rrsig_set_labels(ldns_rr *rr, ldns_rdf *rdf) { return ldns_rr_rrsig_set_labels(rr, ldns_rdf_clone(rdf)); } %} %rename(__ldns_rr_rrsig_set_origttl) ldns_rr_rrsig_set_origttl; %inline %{ bool _ldns_rr_rrsig_set_origttl(ldns_rr *rr, ldns_rdf *rdf) { return ldns_rr_rrsig_set_origttl(rr, ldns_rdf_clone(rdf)); } %} %rename(__ldns_rr_rrsig_set_sig) ldns_rr_rrsig_set_sig; %inline %{ bool _ldns_rr_rrsig_set_sig(ldns_rr *rr, ldns_rdf *rdf) { return ldns_rr_rrsig_set_sig(rr, ldns_rdf_clone(rdf)); } %} %rename(__ldns_rr_rrsig_set_signame) ldns_rr_rrsig_set_signame; %inline %{ bool _ldns_rr_rrsig_set_signame(ldns_rr *rr, ldns_rdf *rdf) { return ldns_rr_rrsig_set_signame(rr, ldns_rdf_clone(rdf)); } %} %rename(__ldns_rr_rrsig_set_typecovered) ldns_rr_rrsig_set_typecovered; %inline %{ bool _ldns_rr_rrsig_set_typecovered(ldns_rr *rr, ldns_rdf *rdf) { return ldns_rr_rrsig_set_typecovered(rr, ldns_rdf_clone(rdf)); } %} %rename(__ldns_rr_set_owner) ldns_rr_set_owner; %inline %{ void _ldns_rr_set_owner(ldns_rr *rr, ldns_rdf *rdf) { return ldns_rr_set_owner(rr, ldns_rdf_clone(rdf)); } %} %newobject _ldns_rr_set_rdf; %rename(__ldns_rr_set_rdf) ldns_rr_set_rdf; %inline %{ ldns_rdf * _ldns_rr_set_rdf(ldns_rr *rr, ldns_rdf *rdf, size_t pos) { /* May leak memory on unsuccessful calls. */ ldns_rdf *new, *ret; new = ldns_rdf_clone(rdf); if ((ret = ldns_rr_set_rdf(rr, new, pos)) == NULL) { ldns_rdf_deep_free(new); } return ret; } %} /* End of push cloning. */ %rename(_ldns_rr_new_frm_str) ldns_rr_new_frm_str; %rename(_ldns_rr_new_frm_fp_l) ldns_rr_new_frm_fp_l; %rename(_ldns_rr_new_frm_fp) ldns_rr_new_frm_fp; /* ========================================================================= */ /* Debugging related code. */ /* ========================================================================= */ #ifdef LDNS_DEBUG %rename(__ldns_rr_free) ldns_rr_free; %inline %{ void _ldns_rr_free (ldns_rr *r) { printf("******** LDNS_RR free 0x%lX ************\n", (long unsigned int)r); ldns_rr_free(r); } %} #else /* !LDNS_DEBUG */ %rename(_ldns_rr_free) ldns_rr_free; #endif /* LDNS_DEBUG */ /* ========================================================================= */ /* Added C code. */ /* ========================================================================= */ /* None. */ /* ========================================================================= */ /* Encapsulating Python code. */ /* ========================================================================= */ %feature("docstring") ldns_struct_rr "Resource Record (RR). The RR is the basic DNS element that contains actual data. This class allows to create RR and manipulate with the content. Use :meth:`ldns_rr_new`, :meth:`ldns_rr_new_frm_type`, :meth:`new_frm_fp`, :meth:`new_frm_fp_l`, :meth:`new_frm_str` or :meth:`new_question_frm_str` to create :class:`ldns_rr` instances. " %extend ldns_struct_rr { %pythoncode %{ def __init__(self): raise Exception("This class can't be created directly. " + "Please use: ldns_rr_new(), ldns_rr_new_frm_type(), " + "new_frm_fp(), new_frm_fp_l(), new_frm_str() or " + "new_question_frm_str()") __swig_destroy__ = _ldns._ldns_rr_free # # LDNS_RR_CONSTRUCTORS_ # @staticmethod def new_frm_str(string, default_ttl=0, origin=None, prev=None, raiseException=True): """ Creates an rr object from a string. The string should be a fully filled-in rr, like "owner_name [space] TTL [space] CLASS [space] TYPE [space] RDATA." :param string: The string to convert. :type string: str :param default_ttl: Default ttl value for the rr. If 0 DEF_TTL will be used. :type default_ttl: int :param origin: When the owner is relative add this. :type origin: :class:`ldns_dname` :param prev: The previous owner name. :type prev: :class:`ldns_rdf` :param raiseException: If True, an exception occurs in case a rr instance can't be created. :throws Exception: If `raiseExceprion` is set and fails. :throws TypeError: When parameters of incorrect types. :return: (:class:`ldns_rr`) RR instance or None. .. note:: The type checking of `origin` is benevolent. It allows also to pass a dname :class:`ldns_rdf` object. This will probably change in future. **Usage** >>> import ldns >>> rr = ldns.ldns_rr.new_frm_str("www.nic.cz. IN A 192.168.1.1", 300) >>> print rr www.nic.cz. 300 IN A 192.168.1.1 >>> rr = ldns.ldns_rr.new_frm_str("test.nic.cz. 600 IN A 192.168.1.2") >>> print rr test.nic.cz. 600 IN A 192.168.1.2 """ if (not isinstance(origin, ldns_dname)) and \ isinstance(origin, ldns_rdf) and \ origin.get_type() == _ldns.LDNS_RDF_TYPE_DNAME: warnings.warn("The ldns_rr.new_frm_str() method will" + " drop the possibility to accept ldns_rdf as origin." + " Convert argument to ldns_dname.", PendingDeprecationWarning, stacklevel=2) status, rr, prev = _ldns.ldns_rr_new_frm_str_(string, default_ttl, origin, prev) if status != LDNS_STATUS_OK: if (raiseException): raise Exception("Can't create RR, error: %d" % status) return None return rr @staticmethod def new_question_frm_str(string, default_ttl=0, origin=None, prev=None, raiseException=True): """ Creates an rr object from a string. The string is like :meth:`new_frm_str` but without rdata. :param string: The string to convert. :type string: str :param origin: When the owner is relative add this. :type origin: :class:`ldns_dname` :param prev: The previous owner name. :type prev: :class:`ldns_rdf` :param raiseException: If True, an exception occurs in case a rr instance can't be created. :throws Exception: If `raiseExceprion` is set and fails. :throws TypeError: When parameters of incorrect types. :return: (:class:`ldns_rr`) RR instance or None. If the object can't be created and `raiseException` is True, an exception occurs. .. note:: The type checking of `origin` is benevolent. It allows also to pass a dname :class:`ldns_rdf` object. This will probably change in future. """ if (not isinstance(origin, ldns_dname)) and \ isinstance(origin, ldns_rdf) and \ origin.get_type() == _ldns.LDNS_RDF_TYPE_DNAME: warnings.warn("The ldns_rr.new_question_frm_str() method will" + " drop the possibility to accept ldns_rdf as origin." + " Convert argument to ldns_dname.", PendingDeprecationWarning, stacklevel=2) status, rr, prev = _ldns.ldns_rr_new_question_frm_str_(string, origin, prev) if status != LDNS_STATUS_OK: if (raiseException): raise Exception("Can't create RR, error: %d" % status) return None return rr @staticmethod def new_frm_str_prev(string, default_ttl=0, origin=None, prev=None, raiseException=True): """ Creates an rr object from a string. The string should be a fully filled-in rr, like "owner_name [space] TTL [space] CLASS [space] TYPE [space] RDATA". :param string: The string to convert. :type string: str :param default_ttl: Default ttl value for the rr. If 0 DEF_TTL will be used. :type default_ttl: int :param origin: When the owner is relative add this. :type origin: :class:`ldns_dname` :param prev: The previous owner name. :type prev: :class:`ldns_rdf` :param raiseException: If True, an exception occurs in case when a rr instance can't be created. :throws Exception: If `raiseExceprion` is set and fails. :throws TypeError: When parameters of incorrect types. :return: None when fails, otherwise a tuple containing: * rr - (:class:`ldns_rr`) RR instance or None. If the object can't be created and `raiseException` is True, an exception occurs. * prev - (:class:`ldns_rdf`) Owner name found in this string or None. .. note:: The type checking of `origin` is benevolent. It allows also to pass a dname :class:`ldns_rdf` object. This will probably change in future. """ if (not isinstance(origin, ldns_dname)) and \ isinstance(origin, ldns_rdf) and \ origin.get_type() == _ldns.LDNS_RDF_TYPE_DNAME: warnings.warn("The ldns_rr.new_frm_str_prev() method will" + " drop the possibility to accept ldns_rdf as origin." + " Convert argument to ldns_dname.", PendingDeprecationWarning, stacklevel=2) status, rr, prev = _ldns.ldns_rr_new_frm_str_(string, default_ttl, origin, prev) if status != LDNS_STATUS_OK: if (raiseException): raise Exception("Can't create RR, error: %d" % status) return None return rr, prev @staticmethod def new_frm_fp(file, default_ttl=0, origin=None, prev=None, raiseException=True): """ Creates a new rr from a file containing a string. :param file: Opened file. :param default_ttl: If 0 DEF_TTL will be used. :type default_ttl: int :param origin: When the owner is relative add this. :type origin: :class:`ldns_dname` :param prev: When the owner is white spaces use this. :type prev: :class:`ldns_rdf` :param raiseException: If True, an exception occurs in case a resolver object can't be created. :throws Exception: If `raiseException` is set and the input cannot be read. :throws TypeError: When parameters of incorrect types. :return: None when fails, otherwise a tuple containing: * rr - (:class:`ldns_rr`) RR object or None. If the object can't be created and `raiseException` is True, an exception occurs. * ttl - (int) None or TTL if the file contains a TTL directive. * origin - (:class:`ldns_rdf`) None or dname rdf if the file contains a ORIGIN directive. * prev - (:class:`ldns_rdf`) None or updated value of prev parameter. .. note:: The type checking of `origin` is benevolent. It allows also to pass a dname :class:`ldns_rdf` object. This will probably change in future. """ if (not isinstance(origin, ldns_dname)) and \ isinstance(origin, ldns_rdf) and \ origin.get_type() == _ldns.LDNS_RDF_TYPE_DNAME: warnings.warn("The ldns_rr.new_frm_fp() method will" + " drop the possibility to accept ldns_rdf as origin." + " Convert argument to ldns_dname.", PendingDeprecationWarning, stacklevel=2) res = _ldns.ldns_rr_new_frm_fp_(file, default_ttl, origin, prev) if res[0] != LDNS_STATUS_OK: if (raiseException): raise Exception("Can't create RR, error: %d" % res[0]) return None return res[1:] @staticmethod def new_frm_fp_l(file, default_ttl=0, origin=None, prev=None, raiseException=True): """ Creates a new rr from a file containing a string. :param file: Opened file. :param default_ttl: If 0 DEF_TTL will be used. :type default_ttl: int :param origin: When the owner is relative add this. :type origin: :class:`ldns_dname` :param prev: When the owner is white spaces use this. :type prev: :class:`ldns_rdf` :param raiseException: Iif True, an exception occurs in case a resolver object can't be created. :throws Exception: If `raiseException` is set and the input cannot be read. :throws TypeError: When parameters of incorrect types. :return: None when fails, otherwise a tuple containing: * rr - (:class:`ldns_rr`) RR object or None. If the object can't be created and `raiseException` is True, an exception occurs. * line - (int) line number (for debugging). * ttl - (int) None or TTL if the file contains a TTL directive . * origin - (:class:`ldns_rdf`) None or dname rdf if the file contains a ORIGIN directive. * prev - (:class:`ldns_rdf`) None or updated value of prev parameter. .. note:: The type checking of `origin` is benevolent. It allows also to pass a dname :class:`ldns_rdf` object. This will probably change in future. """ if (not isinstance(origin, ldns_dname)) and \ isinstance(origin, ldns_rdf) and \ origin.get_type() == _ldns.LDNS_RDF_TYPE_DNAME: warnings.warn("The ldns_rr.new_frm_fp_l() method will" + " drop the possibility to accept ldns_rdf as origin." + " Convert argument to ldns_dname.", PendingDeprecationWarning, stacklevel=2) res = _ldns.ldns_rr_new_frm_fp_l_(file, default_ttl, origin, prev) if res[0] != LDNS_STATUS_OK: if (raiseException): raise Exception("Can't create RR, error: %d" % res[0]) return None return res[1:] # # _LDNS_RR_CONSTRUCTORS # def __str__(self): """ Converts the data in the resource record to presentation format. :return: (str) """ return _ldns.ldns_rr2str(self) def __cmp__(self, other): """ Compares two rrs. The TTL is not looked at. :param other: The second RR one. :type other: :class:`ldns_rr` :throws TypeError: When `other` of non-:class:`ldns_rr` type. :return: (int) 0 if equal, -1 if `self` comes before `other`, 1 if `other` RR comes before `self`. """ return _ldns.ldns_rr_compare(self, other) def __lt__(self, other): """ Compares two rrs. The TTL is not looked at. :param other: The second RR one. :type other: :class:`ldns_rr` :throws TypeError: When `other` of non-:class:`ldns_rr` type. :return: (bool) True when `self` is less than 'other'. """ return _ldns.ldns_rr_compare(self, other) == -1 def __le__(self, other): """ Compares two rrs. The TTL is not looked at. :param other: The second RR one. :type other: :class:`ldns_rr` :throws TypeError: When `other` of non-:class:`ldns_rr` type. :return: (bool) True when `self` is less than or equal to 'other'. """ return _ldns.ldns_rr_compare(self, other) != 1 def __eq__(self, other): """ Compares two rrs. The TTL is not looked at. :param other: The second RR one. :type other: :class:`ldns_rr` :throws TypeError: When `other` of non-:class:`ldns_rr` type. :return: (bool) True when `self` is equal to 'other'. """ return _ldns.ldns_rr_compare(self, other) == 0 def __ne__(self, other): """ Compares two rrs. The TTL is not looked at. :param other: The second RR one. :type other: :class:`ldns_rr` :throws TypeError: When `other` of non-:class:`ldns_rr` type. :return: (bool) True when `self` is not equal to 'other'. """ return _ldns.ldns_rr_compare(self, other) != 0 def __gt__(self, other): """ Compares two rrs. The TTL is not looked at. :param other: The second RR one. :type other: :class:`ldns_rr` :throws TypeError: When `other` of non-:class:`ldns_rr` type. :return: (bool) True when `self` is greater than 'other'. """ return _ldns.ldns_rr_compare(self, other) == 1 def __ge__(self, other): """ Compares two rrs. The TTL is not looked at. :param other: The second RR one. :type other: :class:`ldns_rr` :throws TypeError: When `other` of non-:class:`ldns_rr` type. :return: (bool) True when `self` is greater than or equal to 'other'. """ return _ldns.ldns_rr_compare(self, other) != -1 @staticmethod def class_by_name(string): """ Retrieves a class identifier value by looking up its name. :param string: Class name. :type string: str :throws TypeError: when `string` of inappropriate type. :return: (int) Class identifier value, or 0 if not valid class name given. """ return _ldns.ldns_get_rr_class_by_name(string) def rdfs(self): """ Returns a generator object of rdata records. :return: Generator of :class:`ldns_rdf`. """ for i in range(0, self.rd_count()): yield self.rdf(i) def print_to_file(self, output): """ Prints the data in the resource record to the given file stream (in presentation format). :param output: Opened file stream. :throws TypeError: When `output` not a file. """ _ldns.ldns_rr_print(output, self) #parameters: FILE *, const ldns_rr *, def get_type_str(self): """ Converts an RR type value to its string representation, and returns that string. :return: (str) containing type identification. """ return _ldns.ldns_rr_type2str(self.get_type()) #parameters: const ldns_rr_type, def get_class_str(self): """ Converts an RR class value to its string representation, and returns that string. :return: (str) containing class identification. """ return _ldns.ldns_rr_class2str(self.get_class()) #parameters: const ldns_rr_class, @staticmethod def dnskey_key_size_raw(keydata, len, alg): """ Get the length of the keydata in bits. :param keydata: Key raw data. :type keydata: unsigned char \* :param len: Number of bytes of `keydata`. :type len: size_t :param alg: Algorithm identifier. :type alg: ldns_algorithm :return: (size_t) The length of key data in bits. """ return _ldns.ldns_rr_dnskey_key_size_raw(keydata, len, alg) #parameters: const unsigned char *,const size_t,const ldns_algorithm, #retvals: size_t def write_to_buffer(self,buffer,section): """ Copies the rr data to the buffer in wire format. :param buffer: Buffer to append the result to. :type buffer: :class:`ldns_buffer` :param section: The section in the packet this rr is supposed to be in (to determine whether to add rdata or not). :type section: int :throws TypeError: when arguments of mismatching types passed. :return: (ldns_status) ldns_status """ return _ldns.ldns_rr2buffer_wire(buffer, self, section) #parameters: ldns_buffer *,const ldns_rr *,int, #retvals: ldns_status def write_to_buffer_canonical(self,buffer,section): """ Copies the rr data to the buffer in wire format, in canonical format according to RFC3597 (every dname in rdata fields of RR's mentioned in that RFC will be converted to lower-case). :param buffer: Buffer to append the result to. :type buffer: :class:`ldns_buffer` :param section: The section in the packet this rr is supposed to be in (to determine whether to add rdata or not). :type section: int :throws TypeError: when arguments of mismatching types passed. :return: (ldns_status) ldns_status """ return _ldns.ldns_rr2buffer_wire_canonical(buffer,self,section) #parameters: ldns_buffer *,const ldns_rr *,int, #retvals: ldns_status def write_data_to_buffer(self, buffer): """ Converts an rr's rdata to wire format, while excluding the owner name and all the stuff before the rdata. This is needed in DNSSEC key-tag calculation, the ds calculation from the key and maybe elsewhere. :param buffer: Buffer to append the result to. :type buffer: :class:`ldns_buffer` :throws TypeError: when `buffer` of non-:class:`ldns_buffer` type. :return: (ldns_status) ldns_status """ return _ldns.ldns_rr_rdata2buffer_wire(buffer,self) #parameters: ldns_buffer *, const ldns_rr *, #retvals: ldns_status def write_rrsig_to_buffer(self, buffer): """ Converts a rrsig to wire format BUT EXCLUDE the rrsig rdata. This is needed in DNSSEC verification. :param buffer: Buffer to append the result to. :type buffer: :class:`ldns_buffer` :throws TypeError: when `buffer` of non-:class:`ldns_buffer` type. :return: (ldns_status) ldns_status """ return _ldns.ldns_rrsig2buffer_wire(buffer,self) #parameters: ldns_buffer *,const ldns_rr *, #retvals: ldns_status # # LDNS_RR_METHODS_ # def a_address(self): """ Returns the address rdf of a LDNS_RR_TYPE_A or LDNS_RR_TYPE_AAAA rr. :return: (:class:`ldns_rdf`) with the address or None on failure. """ return _ldns._ldns_rr_a_address(self) #parameters: const ldns_rr *, #retvals: ldns_rdf * def a_set_address(self, f): """ Sets the address of a LDNS_RR_TYPE_A or LDNS_RR_TYPE_AAAA rr. :param f: The address to be set. :type f: :class:`ldns_rdf` :throws TypeError: When `f` of non-:class:`ldns_rdf` type. :return: (bool) True on success, False otherwise. """ return _ldns._ldns_rr_a_set_address(self, f) #parameters: ldns_rr *, ldns_rdf *, #retvals: bool def clone(self): """ Clones a rr and all its data. :return: (:class:`ldns_rr`) The new rr or None on failure. """ return _ldns.ldns_rr_clone(self) #parameters: const ldns_rr *, #retvals: ldns_rr * def compare_ds(self, rr2): """ Returns True if the given rr's are equal. Also returns True if one record is a DS that represents the same DNSKEY record as the other record. :param rr2: The second rr. :type rr2: :class:`ldns_rr` :throws TypeError: When `rr2` of non-:class:`ldns_rr` type. :return: (bool) True if equal otherwise False. """ return _ldns.ldns_rr_compare_ds(self, rr2) #parameters: const ldns_rr *, const ldns_rr *, #retvals: bool def compare_no_rdata(self, rr2): """ Compares two rrs, up to the rdata. :param rr2: Rhe second rr. :type rr2: :class:`ldns_rr` :throws TypeError: When `rr2` of non-:class:`ldns_rr` type. :return: (int) 0 if equal, negative integer if `self` comes before `rr2`, positive integer if `rr2` comes before `self`. """ return _ldns.ldns_rr_compare_no_rdata(self, rr2) #parameters: const ldns_rr *, const ldns_rr *, #retvals: int def dnskey_algorithm(self): """ Returns the algorithm of a LDNS_RR_TYPE_DNSKEY rr. :return: (:class:`ldns_rdf`) with the algorithm or None on failure. """ return _ldns._ldns_rr_dnskey_algorithm(self) #parameters: const ldns_rr *, #retvals: ldns_rdf * def dnskey_flags(self): """ Returns the flags of a LDNS_RR_TYPE_DNSKEY rr. :return: (:class:`ldns_rdf`) with the flags or None on failure. """ return _ldns._ldns_rr_dnskey_flags(self) #parameters: const ldns_rr *, #retvals: ldns_rdf * def dnskey_key(self): """ Returns the key data of a LDNS_RR_TYPE_DNSKEY rr. :return: (:class:`ldns_rdf`) with the key data or None on failure. """ return _ldns._ldns_rr_dnskey_key(self) #parameters: const ldns_rr *, #retvals: ldns_rdf * def dnskey_key_size(self): """ Get the length of the keydata in bits. :return: (size_t) the keysize in bits. """ return _ldns.ldns_rr_dnskey_key_size(self) #parameters: const ldns_rr *, #retvals: size_t def dnskey_protocol(self): """ Returns the protocol of a LDNS_RR_TYPE_DNSKEY rr. :return: (:class:`ldns_rdf`) with the protocol or None on failure. """ return _ldns._ldns_rr_dnskey_protocol(self) #parameters: const ldns_rr *, #retvals: ldns_rdf * def dnskey_set_algorithm(self, f): """ Sets the algorithm of a LDNS_RR_TYPE_DNSKEY rr :param f: The algorithm to set. :type f: :class:`ldns_rdf` :throws TypeError: When `f` of non-:class:`ldns_rdf` type. :return: (bool) True on success, False otherwise. """ return _ldns._ldns_rr_dnskey_set_algorithm(self, f) #parameters: ldns_rr *, ldns_rdf *, #retvals: bool def dnskey_set_flags(self, f): """ Sets the flags of a LDNS_RR_TYPE_DNSKEY rr. :param f: The flags to be set. :type f: :class:`ldns_rdf` :throws TypeError: When `f` of non-:class:`ldns_rdf` type. :return: (bool) True on success, False otherwise. """ return _ldns._ldns_rr_dnskey_set_flags(self, f) #parameters: ldns_rr *, ldns_rdf *, #retvals: bool def dnskey_set_key(self, f): """ Sets the key data of a LDNS_RR_TYPE_DNSKEY rr. :param f: The key data to set. :type f: :class:`ldns_rdf` :throws TypeError: When `f` of non-:class:`ldns_rdf` type. :return: (bool) True on success, False otherwise. """ return _ldns._ldns_rr_dnskey_set_key(self, f) #parameters: ldns_rr *, ldns_rdf *, #retvals: bool def dnskey_set_protocol(self,f): """ Sets the protocol of a LDNS_RR_TYPE_DNSKEY rr. :param f: The protocol to set. :type f: :class:`ldns_rdf` :throws TypeError: When `f` of non-:class:`ldns_rdf` type. :return: (bool) True on success, False otherwise. """ return _ldns._ldns_rr_dnskey_set_protocol(self,f) #parameters: ldns_rr *,ldns_rdf *, #retvals: bool def get_class(self): """ Returns the class of the rr. :return: (int) The class identifier of the rr. """ return _ldns.ldns_rr_get_class(self) #parameters: const ldns_rr *, #retvals: ldns_rr_class def get_type(self): """ Returns the type of the rr. :return: (int) The type identifier of the rr. """ return _ldns.ldns_rr_get_type(self) #parameters: const ldns_rr *, #retvals: ldns_rr_type def is_question(self): """ Returns the question flag of a rr structure. :return: (bool) True if question flag is set. """ return _ldns.ldns_rr_is_question(self) def label_count(self): """ Counts the number of labels of the owner name. :return: (int) The number of labels. """ return _ldns.ldns_rr_label_count(self) #parameters: ldns_rr *, #retvals: uint8_t def mx_exchange(self): """ Returns the mx host of a LDNS_RR_TYPE_MX rr. :return: (:class:`ldns_rdf`) with the name of the MX host or None on failure. """ return _ldns._ldns_rr_mx_exchange(self) #parameters: const ldns_rr *, #retvals: ldns_rdf * def mx_preference(self): """ Returns the mx preference of a LDNS_RR_TYPE_MX rr. :return: (:class:`ldns_rdf`) with the preference or None on failure. """ return _ldns._ldns_rr_mx_preference(self) #parameters: const ldns_rr *, #retvals: ldns_rdf * def ns_nsdname(self): """ Returns the name of a LDNS_RR_TYPE_NS rr. :return: (:class:`ldns_rdf`) A dname rdf with the name or None on failure. """ return _ldns._ldns_rr_ns_nsdname(self) #parameters: const ldns_rr *, #retvals: ldns_rdf * def owner(self): """ Returns the owner name of an rr structure. :return: (:class:`ldns_dname`) Owner name or None on failure. """ rdf = _ldns._ldns_rr_owner(self) if rdf: rdf = ldns_dname(rdf, clone=False) return rdf #parameters: const ldns_rr *, #retvals: ldns_rdf * def pop_rdf(self): """ Removes a rd_field member, it will be popped from the last position. :return: (:class:`ldns_rdf`) rdf which was popped, None if nothing. """ return _ldns.ldns_rr_pop_rdf(self) #parameters: ldns_rr *, #retvals: ldns_rdf * def push_rdf(self,f): """ Sets rd_field member, it will be placed in the next available spot. :param f: The rdf to be appended. :type f: :class:`ldns_rdf` :throws TypeError: When `f` of non-:class:`ldns_rdf` type. :return: (bool) Returns True if success, False otherwise. """ return _ldns._ldns_rr_push_rdf(self, f) #parameters: ldns_rr *, const ldns_rdf *, #retvals: bool def rd_count(self): """ Returns the rd_count of an rr structure. :return: (size_t) the rd count of the rr. """ return _ldns.ldns_rr_rd_count(self) #parameters: const ldns_rr *, #retvals: size_t def rdf(self, nr): """ Returns the rdata field with the given index. :param nr: The index of the rdf to return. :type nr: positive int :throws TypeError: When `nr` not a positive integer. :return: (:class:`ldns_rdf`) The given rdf or None if fails. """ return _ldns._ldns_rr_rdf(self, nr) #parameters: const ldns_rr *, size_t, #retvals: ldns_rdf * def rrsig_algorithm(self): """ Returns the algorithm identifier of a LDNS_RR_TYPE_RRSIG RR. :return: (:class:`ldns_rdf`) with the algorithm or None on failure. """ return _ldns._ldns_rr_rrsig_algorithm(self) #parameters: const ldns_rr *, #retvals: ldns_rdf * def rrsig_expiration(self): """ Returns the expiration time of a LDNS_RR_TYPE_RRSIG RR. :return: (:class:`ldns_rdf`) with the expiration time or None on failure. """ return _ldns._ldns_rr_rrsig_expiration(self) #parameters: const ldns_rr *, #retvals: ldns_rdf * def rrsig_inception(self): """ Returns the inception time of a LDNS_RR_TYPE_RRSIG RR. :return: (:class:`ldns_rdf`) with the inception time or None on failure. """ return _ldns._ldns_rr_rrsig_inception(self) #parameters: const ldns_rr *, #retvals: ldns_rdf * def rrsig_keytag(self): """ Returns the keytag of a LDNS_RR_TYPE_RRSIG RR. :return: (:class:`ldns_rdf`) with the keytag or None on failure. """ return _ldns._ldns_rr_rrsig_keytag(self) #parameters: const ldns_rr *, #retvals: ldns_rdf * def rrsig_labels(self): """ Returns the number of labels of a LDNS_RR_TYPE_RRSIG RR. :return: (:class:`ldns_rdf`) with the number of labels or None on failure. """ return _ldns._ldns_rr_rrsig_labels(self) #parameters: const ldns_rr *, #retvals: ldns_rdf * def rrsig_origttl(self): """ Returns the original TTL of a LDNS_RR_TYPE_RRSIG RR. :return: (:class:`ldns_rdf`) with the original TTL or None on failure. """ return _ldns._ldns_rr_rrsig_origttl(self) #parameters: const ldns_rr *, #retvals: ldns_rdf * def rrsig_set_algorithm(self, f): """ Sets the algorithm of a LDNS_RR_TYPE_RRSIG rr. :param f: The algorithm to set. :type f: :class:`ldns_rdf` :throws TypeError: when `f` of non-:class:`ldns_rdf` type. :return: (bool) True on success, False otherwise. """ return _ldns._ldns_rr_rrsig_set_algorithm(self, f) #parameters: ldns_rr *, ldns_rdf *, #retvals: bool def rrsig_set_expiration(self, f): """ Sets the expireation date of a LDNS_RR_TYPE_RRSIG rr. :param f: The expireation date to set. :type f: :class:`ldns_rdf` :throws TypeError: when `f` of non-:class:`ldns_rdf` type. :return: (bool) True on success, False otherwise. """ return _ldns._ldns_rr_rrsig_set_expiration(self, f) #parameters: ldns_rr *, ldns_rdf *, #retvals: bool def rrsig_set_inception(self, f): """ Sets the inception date of a LDNS_RR_TYPE_RRSIG rr. :param f: The inception date to set. :type f: :class:`ldns_rdf` :throws TypeError: when `f` of non-:class:`ldns_rdf` type. :return: (bool) True on success, False otherwise. """ return _ldns._ldns_rr_rrsig_set_inception(self, f) #parameters: ldns_rr *, ldns_rdf *, #retvals: bool def rrsig_set_keytag(self, f): """ Sets the keytag of a LDNS_RR_TYPE_RRSIG rr. :param f: The keytag to set. :type f: :class:`ldns_rdf` :throws TypeError: when `f` of non-:class:`ldns_rdf` type. :return: (bool) True on success, False otherwise. """ return _ldns._ldns_rr_rrsig_set_keytag(self, f) #parameters: ldns_rr *, ldns_rdf *, #retvals: bool def rrsig_set_labels(self, f): """ Sets the number of labels of a LDNS_RR_TYPE_RRSIG rr. :param f: The number of labels to set. :type f: :class:`ldns_rdf` :throws TypeError: when `f` of non-:class:`ldns_rdf` type. :return: (bool) True on success, False otherwise. """ return _ldns._ldns_rr_rrsig_set_labels(self, f) #parameters: ldns_rr *, ldns_rdf *, #retvals: bool def rrsig_set_origttl(self, f): """ Sets the original TTL of a LDNS_RR_TYPE_RRSIG rr. :param f: The original TTL to set. :type f: :class:`ldns_rdf` :throws TypeError: when `f` of non-:class:`ldns_rdf` type. :return: (bool) True on success, False otherwise. """ return _ldns._ldns_rr_rrsig_set_origttl(self, f) #parameters: ldns_rr *, ldns_rdf *, #retvals: bool def rrsig_set_sig(self, f): """ Sets the signature data of a LDNS_RR_TYPE_RRSIG rr. :param f: The signature data to set. :type f: :class:`ldns_rdf` :throws TypeError: when `f` of non-:class:`ldns_rdf` type. :return: (bool) True on success, False otherwise. """ return _ldns._ldns_rr_rrsig_set_sig(self, f) #parameters: ldns_rr *, ldns_rdf *, #retvals: bool def rrsig_set_signame(self, f): """ Sets the signers name of a LDNS_RR_TYPE_RRSIG rr. :param f: The signers name to set. :type f: :class:`ldns_rdf` :throws TypeError: when `f` of non-:class:`ldns_rdf` type. :return: (bool) True on success, False otherwise. """ return _ldns._ldns_rr_rrsig_set_signame(self, f) #parameters: ldns_rr *, ldns_rdf *, #retvals: bool def rrsig_set_typecovered(self, f): """ Sets the typecovered of a LDNS_RR_TYPE_RRSIG rr. :param f: The type covered to set. :type f: :class:`ldns_rdf` :throws TypeError: when `f` of non-:class:`ldns_rdf` type. :return: (bool) True on success, False otherwise. """ return _ldns._ldns_rr_rrsig_set_typecovered(self, f) #parameters: ldns_rr *, ldns_rdf *, #retvals: bool def rrsig_sig(self): """ Returns the signature data of a LDNS_RR_TYPE_RRSIG RR. :return: (:class:`ldns_rdf`) with the signature data or None on failure. """ return _ldns._ldns_rr_rrsig_sig(self) #parameters: const ldns_rr *, #retvals: ldns_rdf * def rrsig_signame(self): """ Returns the signers name of a LDNS_RR_TYPE_RRSIG RR. :return: (:class:`ldns_rdf`) with the signers name or None on failure. """ return _ldns._ldns_rr_rrsig_signame(self) #parameters: const ldns_rr *, #retvals: ldns_rdf * def rrsig_typecovered(self): """ Returns the type covered of a LDNS_RR_TYPE_RRSIG rr. :return: (:class:`ldns_rdf`) with the type covered or None on failure. """ return _ldns._ldns_rr_rrsig_typecovered(self) #parameters: const ldns_rr *, #retvals: ldns_rdf * def set_class(self, rr_class): """ Sets the class in the rr. :param rr_class: Set to this class. :type rr_class: int :throws TypeError: when `rr_class` of non-integer type. """ _ldns.ldns_rr_set_class(self, rr_class) #parameters: ldns_rr *, ldns_rr_class, #retvals: def set_owner(self, owner): """ Sets the owner in the rr structure. :param owner: Owner name. :type owner: :class:`ldns_dname` :throws TypeError: when `owner` of non-:class:`ldns_dname` type. .. note:: The type checking of `owner` is benevolent. It allows also to pass a dname :class:`ldns_rdf` object. This will probably change in future. """ if (not isinstance(owner, ldns_dname)) and \ isinstance(owner, ldns_rdf) and \ owner.get_type() == _ldns.LDNS_RDF_TYPE_DNAME: warnings.warn("The ldns_rr.new_frm_str() method will" + " drop the possibility to accept ldns_rdf as owner." + " Convert argument to ldns_dname.", PendingDeprecationWarning, stacklevel=2) _ldns._ldns_rr_set_owner(self, owner) #parameters: ldns_rr *, ldns_rdf *, #retvals: def set_question(self, question): """ Sets the question flag in the rr structure. :param question: Question flag. :type question: bool """ _ldns.ldns_rr_set_question(self, question) #parameters: ldns_rr *, bool, #retvals: def set_rd_count(self, count): """ Sets the rd_count in the rr. :param count: Set to this count. :type count: positive int :throws TypeError: when `count` of non-integer type. """ _ldns.ldns_rr_set_rd_count(self, count) #parameters: ldns_rr *, size_t, #retvals: def set_rdf(self, f, position): """ Sets a rdf member, it will be set on the position given. The old value is returned, like pop. :param f: The rdf to be set. :type f: :class:`ldns_rdf` :param position: The position the set the rdf. :type position: positive int :throws TypeError: when mismatching types passed. :return: (:class:`ldns_rdf`) the old value in the rr, None on failure. """ return _ldns._ldns_rr_set_rdf(self, f, position) #parameters: ldns_rr *, const ldns_rdf *, size_t, #retvals: ldns_rdf * def set_ttl(self, ttl): """ Sets the ttl in the rr structure. :param ttl: Set to this ttl. :type ttl: positive int :throws TypeError: when `ttl` of non-integer type. """ _ldns.ldns_rr_set_ttl(self, ttl) #parameters: ldns_rr *, uint32_t, #retvals: def set_type(self, rr_type): """ Sets the type in the rr. :param rr_type: Set to this type. :type rr_type: ineteger :throws TypeError: when `rr_type` of non-integer type. """ _ldns.ldns_rr_set_type(self, rr_type) #parameters: ldns_rr *, ldns_rr_type, #retvals: def to_canonical(self): """ Converts each dname in a rr to its canonical form. """ _ldns.ldns_rr2canonical(self) def ttl(self): """ Returns the ttl of an rr structure. :return: (int) the ttl of the rr. """ return _ldns.ldns_rr_ttl(self) #parameters: const ldns_rr *, #retvals: uint32_t @staticmethod def type_by_name(string): """ Retrieves a rr type identifier value by looking up its name. Returns 0 if invalid name passed. :param string: RR type name. :type string: str :throws TypeError: when `string` of inappropriate type. :return: (int) RR type identifier, or 0 if no matching value to identifier found. """ return _ldns.ldns_get_rr_type_by_name(string) def uncompressed_size(self): """ Calculates the uncompressed size of an RR. :return: (inetger) size of the rr. """ return _ldns.ldns_rr_uncompressed_size(self) #parameters: const ldns_rr *, #retvals: size_t # # _LDNS_RR_METHODS # %} } /* ========================================================================= */ /* SWIG setting and definitions. */ /* ========================================================================= */ %nodefaultctor ldns_struct_rr_list; /* No default constructor. */ %nodefaultdtor ldns_struct_rr_list; /* No default destructor. */ %ignore ldns_struct_rr_list::_rrs; %newobject ldns_rr_list_cat_clone; %newobject ldns_rr_list_clone; %newobject ldns_rr_list_pop_rr; %newobject ldns_rr_list_pop_rr_list; %newobject ldns_rr_list_pop_rrset; %newobject ldns_rr_list_rr; %newobject ldns_rr_list_new; %newobject ldns_get_rr_list_hosts_frm_file; %newobject ldns_rr_list_subtype_by_rdf; %newobject ldns_rr_list2str; %delobject ldns_rr_list_deep_free; %delobject ldns_rr_list_free; /* Clone data on push. */ %rename(__ldns_rr_list_push_rr) ldns_rr_list_push_rr; %inline %{ bool _ldns_rr_list_push_rr(ldns_rr_list* r, ldns_rr *rr) { bool ret; ldns_rr *new; new = ldns_rr_clone(rr); if (!(ret = ldns_rr_list_push_rr(r, new))) { ldns_rr_free(new); } return ret; } %} %rename(__ldns_rr_list_push_rr_list) ldns_rr_list_push_rr_list; %inline %{ bool _ldns_rr_list_push_rr_list(ldns_rr_list* r, ldns_rr_list *r2) { bool ret; ldns_rr_list *new; new = ldns_rr_list_clone(r2); if (!(ret = ldns_rr_list_push_rr_list(r, new))) { ldns_rr_list_deep_free(new); } return ret; } %} %newobject _ldns_rr_list_set_rr; %rename(__ldns_rr_list_set_rr) ldns_rr_list_set_rr; %inline %{ ldns_rr * _ldns_rr_list_set_rr(ldns_rr_list * rrl, ldns_rr *rr, size_t idx) { ldns_rr *ret; ldns_rr *new; new = ldns_rr_clone(rr); if ((ret = ldns_rr_list_set_rr(rrl, new, idx)) == NULL) { ldns_rr_free(new); } return ret; } %} %rename(__ldns_rr_list_cat) ldns_rr_list_cat; %inline %{ bool _ldns_rr_list_cat(ldns_rr_list *r, ldns_rr_list *r2) { return ldns_rr_list_cat(r, ldns_rr_list_clone(r2)); } %} /* End clone data on push. */ /* Clone data on pull. */ %newobject _ldns_rr_list_rr; %rename(__ldns_rr_list_rr) ldns_rr_list_rr; %inline %{ ldns_rr * _ldns_rr_list_rr(ldns_rr_list *r, int i) { ldns_rr *rr; rr = ldns_rr_list_rr(r, i); return (rr != NULL) ? ldns_rr_clone(rr) : NULL; } %} %newobject _ldns_rr_list_owner; %rename(__ldns_rr_list_owner) ldns_rr_list_owner; %inline %{ ldns_rdf * _ldns_rr_list_owner(ldns_rr_list *r) { ldns_rdf *rdf; rdf = ldns_rr_list_owner(r); return (rdf != NULL) ? ldns_rdf_clone(rdf) : NULL; } %} /* End clone data on pull. */ /* ========================================================================= */ /* Debugging related code. */ /* ========================================================================= */ %rename(ldns_rr_list) ldns_struct_rr_list; #ifdef LDNS_DEBUG %rename(__ldns_rr_list_deep_free) ldns_rr_list_deep_free; %rename(__ldns_rr_list_free) ldns_rr_list_free; %inline %{ void _ldns_rr_list_deep_free(ldns_rr_list *r) { printf("******** LDNS_RR_LIST deep free 0x%lX ************\n", (long unsigned int) r); ldns_rr_list_deep_free(r); } void _ldns_rr_list_free(ldns_rr_list *r) { printf("******** LDNS_RR_LIST deep free 0x%lX ************\n", (long unsigned int) r); ldns_rr_list_free(r); } %} #else %rename(_ldns_rr_list_deep_free) ldns_rr_list_deep_free; %rename(_ldns_rr_list_free) ldns_rr_list_free; #endif /* ========================================================================= */ /* Added C code. */ /* ========================================================================= */ /* None. */ /* ========================================================================= */ /* Encapsulating Python code. */ /* ========================================================================= */ %feature("docstring") ldns_struct_rr_list "List of Resource Records. This class contains a list of RR's (see :class:`ldns.ldns_rr`). " %extend ldns_struct_rr_list { %pythoncode %{ def __init__(self): self.this = _ldns.ldns_rr_list_new() if not self.this: raise Exception("Can't create new RR_LIST") __swig_destroy__ = _ldns._ldns_rr_list_deep_free # # LDNS_RR_LIST_CONSTRUCTORS_ # @staticmethod def new(raiseException=True): """ Creates an empty RR List object. :param raiseException: Set to True if an exception should signal an error. :type raiseException: bool :throws Exception: when `raiseException` is True and error occurs. :return: :class:`ldns_rr_list` Empty RR list. """ rrl = _ldns.ldns_rr_list_new() if (not rrl) and raiseException: raise Exception("Can't create RR List.") return rrl @staticmethod def new_frm_file(filename="/etc/hosts", raiseException=True): """ Creates an RR List object from file content. Goes through a file and returns a rr list containing all the defined hosts in there. :param filename: The filename to use. :type filename: str :param raiseException: Set to True if an exception should signal an error. :type raiseException: bool :throws TypeError: when `filename` of inappropriate type. :throws Exception: when `raiseException` is True and error occurs. :return: RR List object or None. If the object can't be created and `raiseException` is True, an exception occurs. **Usage** >>> alist = ldns.ldns_rr_list.new_frm_file() >>> print alist localhost. 3600 IN A 127.0.0.1 ... """ rr = _ldns.ldns_get_rr_list_hosts_frm_file(filename) if (not rr) and (raiseException): raise Exception("Can't create RR List.") return rr # # _LDNS_RR_LIST_CONSTRUCTORS # def __str__(self): """ Converts a list of resource records to presentation format. :return: (str) Presentation format. """ return _ldns.ldns_rr_list2str(self) def print_to_file(self, output): """ Print a rr_list to output. :param output: Opened file to print to. :throws TypeError: when `output` of inappropriate type. """ _ldns.ldns_rr_list_print(output, self) def to_canonical(self): """ Converts each dname in each rr in a rr_list to its canonical form. """ _ldns.ldns_rr_list2canonical(self) #parameters: ldns_rr_list *, #retvals: def rrs(self): """ Returns a generator object of a list of rr records. :return: (generator) generator object. """ for i in range(0, self.rr_count()): yield self.rr(i) def is_rrset(self): """ Checks if the rr list is a rr set. :return: (bool) True if rr list is a rr set. """ return _ldns.ldns_is_rrset(self) def __cmp__(self, rrl2): """ Compares two rr lists. :param rrl2: The second one. :type rrl2: :class:`ldns_rr_list` :throws TypeError: when `rrl2` of non-:class:`ldns_rr_list` type. :return: (int) 0 if equal, -1 if this list comes before `rrl2`, 1 if `rrl2` comes before this list. """ return _ldns.ldns_rr_list_compare(self, rrl2) def __lt__(self, other): """ Compares two rr lists. :param other: The second one. :type other: :class:`ldns_rr_list` :throws TypeError: when `other` of non-:class:`ldns_rr_list` type. :return: (bool) True when `self` is less than 'other'. """ return _ldns.ldns_rr_list_compare(self, other) == -1 def __le__(self, other): """ Compares two rr lists. :param other: The second one. :type other: :class:`ldns_rr_list` :throws TypeError: when `other` of non-:class:`ldns_rr_list` type. :return: (bool) True when `self` is less than or equal to 'other'. """ return _ldns.ldns_rr_list_compare(self, other) != 1 def __eq__(self, other): """ Compares two rr lists. :param other: The second one. :type other: :class:`ldns_rr_list` :throws TypeError: when `other` of non-:class:`ldns_rr_list` type. :return: (bool) True when `self` is equal to 'other'. """ return _ldns.ldns_rr_list_compare(self, other) == 0 def __ne__(self, other): """ Compares two rr lists. :param other: The second one. :type other: :class:`ldns_rr_list` :throws TypeError: when `other` of non-:class:`ldns_rr_list` type. :return: (bool) True when `self` is not equal to 'other'. """ return _ldns.ldns_rr_list_compare(self, other) != 0 def __gt__(self, other): """ Compares two rr lists. :param other: The second one. :type other: :class:`ldns_rr_list` :throws TypeError: when `other` of non-:class:`ldns_rr_list` type. :return: (bool) True when `self` is greater than 'other'. """ return _ldns.ldns_rr_list_compare(self, other) == 1 def __ge__(self, other): """ Compares two rr lists. :param other: The second one. :type other: :class:`ldns_rr_list` :throws TypeError: when `other` of non-:class:`ldns_rr_list` type. :return: (bool) True when `self` is greater than or equal to 'other'. """ return _ldns.ldns_rr_list_compare(self, other) != -1 def write_to_buffer(self, buffer): """ Copies the rr_list data to the buffer in wire format. :param buffer: Output buffer to append the result to. :type buffer: :class:`ldns_buffer` :throws TypeError: when `buffer` of non-:class:`ldns_buffer` type. :return: (ldns_status) ldns_status """ return _ldns.ldns_rr_list2buffer_wire(buffer, self) # # LDNS_RR_LIST_METHODS_ # def cat(self, right): """ Concatenates two ldns_rr_lists together. This modifies rr list (to extend it and adds RRs from right). :param right: The right-hand side. :type right: :class:`ldns_rr_list` :throws TypeError: when `right` of non-:class:`ldns_rr_list` type. :return: (bool) True if success. """ return _ldns._ldns_rr_list_cat(self, right) #parameters: ldns_rr_list *, ldns_rr_list *, #retvals: bool def cat_clone(self, right): """ Concatenates two ldns_rr_lists together, creates a new list of the rr's (instead of appending the content to an existing list). :param right: The right-hand side. :type right: :class:`ldns_rr_list` :throws TypeError: when `right` of non-:class:`ldns_rr_list` type. :return: (:class:`ldns_rr_list`) rr list with left-hand side + right-hand side concatenated, on None on error. """ return _ldns.ldns_rr_list_cat_clone(self, right) #parameters: ldns_rr_list *, ldns_rr_list *, #retvals: ldns_rr_list * def clone(self): """ Clones an rrlist. :return: (:class:`ldns_rr_list`) the cloned rr list, or None on error. """ return _ldns.ldns_rr_list_clone(self) #parameters: const ldns_rr_list *, #retvals: ldns_rr_list * def contains_rr(self, rr): """ Returns True if the given rr is one of the rrs in the list, or if it is equal to one. :param rr: The rr to check. :type rr: :class:`ldns_rr` :throws TypeError: when `rr` of non-:class:`ldns_rr` type. :return: (bool) True if rr_list contains `rr`, False otherwise. """ return _ldns.ldns_rr_list_contains_rr(self, rr) #parameters: const ldns_rr_list *, ldns_rr *, #retvals: bool def owner(self): """ Returns the owner domain name rdf of the first element of the RR. If there are no elements present, None is returned. :return: (:class:`ldns_dname`) dname of the first element, or None if the list is empty. """ rdf = _ldns._ldns_rr_list_owner(self) if rdf: rdf = ldns_dname(rdf, clone=False) return rdf #parameters: const ldns_rr_list *, #retvals: ldns_rdf * def pop_rr(self): """ Pops the last rr from an rrlist. :return: (:class:`ldns_rr`) None if nothing to pop. Otherwise the popped RR. """ rr = _ldns.ldns_rr_list_pop_rr(self) return rr #parameters: ldns_rr_list *, #retvals: ldns_rr * def pop_rr_list(self, size): """ Pops an rr_list of size s from an rrlist. :param size: The number of rr's to pop. :type size: positive int :throws TypeError: when `size` of inappropriate type. :return: (:class:`ldns_rr_list`) None if nothing to pop. Otherwise the popped rr list. """ return _ldns.ldns_rr_list_pop_rr_list(self, size) #parameters: ldns_rr_list *, size_t, #retvals: ldns_rr_list * def pop_rrset(self): """ Pops the first rrset from the list, the list must be sorted, so that all rr's from each rrset are next to each other. :return: (:class:`ldns_rr_list`) the first rrset, or None when empty. """ return _ldns.ldns_rr_list_pop_rrset(self) #parameters: ldns_rr_list *, #retvals: ldns_rr_list * def push_rr(self, rr): """ Pushes an rr to an rrlist. :param rr: The rr to push. :type rr: :class:`ldns_rr` :throws TypeError: when `rr` of non-:class:`ldns_rr` type. :return: (bool) False on error, otherwise True. """ return _ldns._ldns_rr_list_push_rr(self, rr) #parameters: ldns_rr_list *, const ldns_rr *, #retvals: bool def push_rr_list(self, push_list): """ Pushes an rr list to an rr list. :param push_list: The rr_list to push. :type push_list: :class:`ldns_rr_list` :throws TypeError: when `push_list` of non-:class:`ldns_rr_list` type. :returns: (bool) False on error, otherwise True. """ return _ldns._ldns_rr_list_push_rr_list(self, push_list) #parameters: ldns_rr_list *, const ldns_rr_list *, #retvals: bool def rr(self, nr): """ Returns a specific rr of an rrlist. :param nr: Index of the desired rr. :type nr: positive int :throws TypeError: when `nr` of inappropriate type. :return: (:class:`ldns_rr`) The rr at position `nr`, or None if failed. """ return _ldns._ldns_rr_list_rr(self, nr) #parameters: const ldns_rr_list *, size_t, #retvals: ldns_rr * def rr_count(self): """ Returns the number of rr's in an rr_list. :return: (int) The number of rr's. """ return _ldns.ldns_rr_list_rr_count(self) #parameters: const ldns_rr_list *, #retvals: size_t def set_rr(self, r, idx): """ Set a rr on a specific index in a ldns_rr_list. :param r: The rr to set. :type r: :class:`ldns_rr` :param idx: Index into the rr_list. :type idx: positive int :throws TypeError: when parameters of inappropriate types. :return: (:class:`ldns_rr`) the old rr which was stored in the rr_list, or None if the index was too large to set a specific rr. """ return _ldns._ldns_rr_list_set_rr(self, r, idx) #parameters: ldns_rr_list *, const ldns_rr *, size_t, #retvals: ldns_rr * def set_rr_count(self, count): """ Sets the number of rr's in an rr_list. :param count: The number of rr in this list. :type count: positive int :throws TypeError: when `count` of non-integer type. :throws Exception: when `count` out of acceptable range. .. warning:: Don't use this method unless you really know what you are doing. """ # The function C has a tendency to generate an assertion fail when # the count exceeds the list's capacity -- therefore the checking # code. if isinstance(count, int) and \ ((count < 0) or (count > self._rr_capacity)): raise Exception("Given count %d is out of range " % (count) + "of the rr list's capacity %d." % (self._rr_capacity)) _ldns.ldns_rr_list_set_rr_count(self, count) #parameters: ldns_rr_list *, size_t, #retvals: def sort(self): """ Sorts an rr_list (canonical wire format). """ _ldns.ldns_rr_list_sort(self) #parameters: ldns_rr_list *, #retvals: def subtype_by_rdf(self, r, pos): """ Return the rr_list which matches the rdf at position field. Think type-covered stuff for RRSIG. :param r: The rdf to use for the comparison. :type r: :class:`ldns_rdf` :param pos: At which position we can find the rdf. :type pos: positive int :throws TypeError: when parameters of inappropriate types. :return: (:class:`ldns_rr_list`) a new rr list with only the RRs that match, or None when nothing matches. """ return _ldns.ldns_rr_list_subtype_by_rdf(self, r, pos) #parameters: ldns_rr_list *, ldns_rdf *, size_t, #retvals: ldns_rr_list * def type(self): """ Returns the type of the first element of the RR. If there are no elements present, 0 is returned. :return: (int) rr_type of the first element, or 0 if the list is empty. """ return _ldns.ldns_rr_list_type(self) #parameters: const ldns_rr_list *, #retvals: ldns_rr_type # # _LDNS_RR_LIST_METHODS # %} } /* ========================================================================= */ /* SWIG setting and definitions. */ /* ========================================================================= */ %newobject ldns_rr_descript; %nodefaultctor ldns_struct_rr_descriptor; /* No default constructor. */ %nodefaultdtor ldns_struct_rr_descriptor; /* No default destructor.*/ %rename(ldns_rr_descriptor) ldns_struct_rr_descriptor; /* ========================================================================= */ /* Debugging related code. */ /* ========================================================================= */ /* None. */ /* ========================================================================= */ /* Added C code. */ /* ========================================================================= */ %inline %{ /* * Does nothing, but keeps the SWIG wrapper quiet about absent destructor. */ void ldns_rr_descriptor_dummy_free(const ldns_rr_descriptor *rd) { (void) rd; } %} /* ========================================================================= */ /* Encapsulating Python code. */ /* ========================================================================= */ %feature("docstring") ldns_struct_rr_descriptor "Resource Record descriptor. This structure contains, for all rr types, the rdata fields that are defined. In order to create a class instance use :meth:`ldns_rr_descriptor`. " %extend ldns_struct_rr_descriptor { %pythoncode %{ def __init__(self, rr_type): """ Returns the resource record descriptor for the given type. :param rr_type: RR type. :type rr_type: int :throws TypeError: when `rr_type` of inappropriate type. :return: (:class:`ldns_rr_descriptor`) RR descriptor class. """ self.this = self.ldns_rr_descriptor(rr_type) def __str__(self): raise Exception("The content of this class cannot be printed.") __swig_destroy__ = _ldns.ldns_rr_descriptor_dummy_free # # LDNS_RR_DESCRIPTOR_CONSTRUCTORS_ # @staticmethod def ldns_rr_descriptor(rr_type): """ Returns the resource record descriptor for the given type. :param rr_type: RR type. :type rr_type: int :throws TypeError: when `rr_type` of inappropriate type. :return: (:class:`ldns_rr_descriptor`) RR descriptor class. """ return _ldns.ldns_rr_descript(rr_type) #parameters: uint16_t #retvals: const ldns_rr_descriptor * # # _LDNS_RR_DESCRIPTOR_CONSTRUCTORS # # # LDNS_RR_DESCRIPTOR_METHODS_ # def field_type(self, field): """ Returns the rdf type for the given rdata field number of the rr type for the given descriptor. :param field: The field number. :type field: positive int :throws TypeError: when `field` of non-inetger type. :return: (int) the rdf type for the field. """ return _ldns.ldns_rr_descriptor_field_type(self, field) #parameters: const ldns_rr_descriptor *, size_t, #retvals: ldns_rdf_type def maximum(self): """ Returns the maximum number of rdata fields of the rr type this descriptor describes. :return: (int) the maximum number of rdata fields. """ return _ldns.ldns_rr_descriptor_maximum(self) #parameters: const ldns_rr_descriptor *, #retvals: size_t def minimum(self): """ Returns the minimum number of rdata fields of the rr type this descriptor describes. :return: (int) the minimum number of rdata fields. """ return _ldns.ldns_rr_descriptor_minimum(self) #parameters: const ldns_rr_descriptor *, #retvals: size_t # # _LDNS_RR_DESCRIPTOR_METHODS # %} } /* ========================================================================= */ /* Added C code. */ /* ========================================================================= */ /* * rrsig checking wrappers * * Copying of rr pointers into the good_keys list leads to double free * problems, therefore we provide two options - either ignore the keys * or get list of indexes of the keys. The latter allows fetching of the * keys later on from the original key set. */ %rename(__ldns_verify_rrsig_keylist) ldns_verify_rrsig_keylist; %inline %{ ldns_status ldns_verify_rrsig_keylist_status_only(ldns_rr_list *rrset, ldns_rr *rrsig, const ldns_rr_list *keys) { ldns_rr_list *good_keys = ldns_rr_list_new(); ldns_status status = ldns_verify_rrsig_keylist(rrset, rrsig, keys, good_keys); ldns_rr_list_free(good_keys); return status; } %} %rename(__ldns_verify_rrsig_keylist) ldns_verify_rrsig_keylist; %inline %{ PyObject* ldns_verify_rrsig_keylist_(ldns_rr_list *rrset, ldns_rr *rrsig, const ldns_rr_list *keys) { PyObject* tuple; PyObject* keylist; ldns_rr_list *good_keys = ldns_rr_list_new(); ldns_status status = ldns_verify_rrsig_keylist(rrset, rrsig, keys, good_keys); tuple = PyTuple_New(2); PyTuple_SetItem(tuple, 0, SWIG_From_int(status)); keylist = PyList_New(0); if (status == LDNS_STATUS_OK) { unsigned int i; for (i = 0; i < ldns_rr_list_rr_count(keys); i++) { if (ldns_rr_list_contains_rr(good_keys, ldns_rr_list_rr(keys, i))) { PyList_Append(keylist, SWIG_From_int(i)); } } } PyTuple_SetItem(tuple, 1, keylist); ldns_rr_list_free(good_keys); return tuple; } %} %rename(__ldns_verify_rrsig_keylist_notime) ldns_verify_rrsig_keylist_notime; %inline %{ ldns_status ldns_verify_rrsig_keylist_notime_status_only(ldns_rr_list *rrset, ldns_rr *rrsig, const ldns_rr_list *keys) { ldns_rr_list *good_keys = ldns_rr_list_new(); ldns_status status = ldns_verify_rrsig_keylist_notime(rrset, rrsig, keys, good_keys); ldns_rr_list_free(good_keys); return status; } %} %rename(__ldns_verify_rrsig_keylist_notime) ldns_verify_rrsig_keylist_notime; %inline %{ PyObject* ldns_verify_rrsig_keylist_notime_(ldns_rr_list *rrset, ldns_rr *rrsig, const ldns_rr_list *keys) { PyObject* tuple; PyObject* keylist; ldns_rr_list *good_keys = ldns_rr_list_new(); ldns_status status = ldns_verify_rrsig_keylist_notime(rrset, rrsig, keys, good_keys); tuple = PyTuple_New(2); PyTuple_SetItem(tuple, 0, SWIG_From_int(status)); keylist = PyList_New(0); if (status == LDNS_STATUS_OK) { unsigned int i; for (i = 0; i < ldns_rr_list_rr_count(keys); i++) { if (ldns_rr_list_contains_rr(good_keys, ldns_rr_list_rr(keys, i))) { PyList_Append(keylist, SWIG_From_int(i)); } } } PyTuple_SetItem(tuple, 1, keylist); ldns_rr_list_free(good_keys); return tuple; } %} /* End of rrsig checking wrappers. */ ldns-1.6.17/contrib/NETLDNS.readme.txt0000664000175100017510000000077512264060151016670 0ustar willemwillemNETLDNS is a functionality port of NLnet Labs' LDNS to the .NET 2.0 framework, contributed by Alex Nicoll of the Carnegie Mellon University Software Engineering Institute. NETLDNS is released under the BSD license. NETLDNS uses Mihnea Radulescu's BigInteger Library (http://www.codeproject.com/KB/cs/BigInteger_Library.aspx) from CodeProject to help with key manipulation. Please contact Alex at anicoll@cert.org with inquiries or requests for newer versions. This project is not supported by NLnet Labs. ldns-1.6.17/contrib/ldnsx/0000775000175100017510000000000012264060151014703 5ustar willemwillemldns-1.6.17/contrib/ldnsx/LICENSE0000664000175100017510000000302112264060151015704 0ustar willemwillemCopyright (c) 2011, Xelerance Author: Christopher Olah All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the name of Xelerance nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ldns-1.6.17/contrib/ldnsx/source/0000775000175100017510000000000012264060151016203 5ustar willemwillemldns-1.6.17/contrib/ldnsx/source/conf.py0000664000175100017510000001431112264060151017502 0ustar willemwillem# -*- coding: utf-8 -*- # # ldnsx documentation build configuration file, created by # sphinx-quickstart on Mon May 30 16:56:19 2011. # # This file is execfile()d with the current directory set to its containing dir. # # Note that not all possible configuration values are present in this # autogenerated file. # # All configuration values have a default; values that are commented out # serve to show the default. import sys, os # If extensions (or modules to document with autodoc) are in another directory, # add these directories to sys.path here. If the directory is relative to the # documentation root, use os.path.abspath to make it absolute, like shown here. sys.path.append(os.path.abspath('..')) # -- General configuration ----------------------------------------------------- # Add any Sphinx extension module names here, as strings. They can be extensions # coming with Sphinx (named 'sphinx.ext.*') or your custom ones. extensions = ['sphinx.ext.autodoc', 'sphinx.ext.doctest']#, 'sphinx.ext.jsmath'] # Add any paths that contain templates here, relative to this directory. templates_path = ['_templates'] # The suffix of source filenames. source_suffix = '.rst' # The encoding of source files. #source_encoding = 'utf-8' # The master toctree document. master_doc = 'index' # General information about the project. project = u'ldnsx' copyright = u'2011, Christopher Olah' # The version info for the project you're documenting, acts as replacement for # |version| and |release|, also used in various other places throughout the # built documents. # # The short X.Y version. version = '0.0' # The full version, including alpha/beta/rc tags. release = '-1' # The language for content autogenerated by Sphinx. Refer to documentation # for a list of supported languages. #language = None # There are two options for replacing |today|: either, you set today to some # non-false value, then it is used: #today = '' # Else, today_fmt is used as the format for a strftime call. #today_fmt = '%B %d, %Y' # List of documents that shouldn't be included in the build. #unused_docs = [] # List of directories, relative to source directory, that shouldn't be searched # for source files. exclude_trees = [] # The reST default role (used for this markup: `text`) to use for all documents. #default_role = None # If true, '()' will be appended to :func: etc. cross-reference text. #add_function_parentheses = True # If true, the current module name will be prepended to all description # unit titles (such as .. function::). #add_module_names = True # If true, sectionauthor and moduleauthor directives will be shown in the # output. They are ignored by default. #show_authors = False # The name of the Pygments (syntax highlighting) style to use. pygments_style = 'sphinx' # A list of ignored prefixes for module index sorting. #modindex_common_prefix = [] # -- Options for HTML output --------------------------------------------------- # The theme to use for HTML and HTML Help pages. Major themes that come with # Sphinx are currently 'default' and 'sphinxdoc'. html_theme = 'default' # Theme options are theme-specific and customize the look and feel of a theme # further. For a list of options available for each theme, see the # documentation. #html_theme_options = {} # Add any paths that contain custom themes here, relative to this directory. #html_theme_path = [] # The name for this set of Sphinx documents. If None, it defaults to # " v documentation". #html_title = None # A shorter title for the navigation bar. Default is the same as html_title. #html_short_title = None # The name of an image file (relative to this directory) to place at the top # of the sidebar. #html_logo = None # The name of an image file (within the static path) to use as favicon of the # docs. This file should be a Windows icon file (.ico) being 16x16 or 32x32 # pixels large. #html_favicon = None # Add any paths that contain custom static files (such as style sheets) here, # relative to this directory. They are copied after the builtin static files, # so a file named "default.css" will overwrite the builtin "default.css". html_static_path = ['_static'] # If not '', a 'Last updated on:' timestamp is inserted at every page bottom, # using the given strftime format. #html_last_updated_fmt = '%b %d, %Y' # If true, SmartyPants will be used to convert quotes and dashes to # typographically correct entities. #html_use_smartypants = True # Custom sidebar templates, maps document names to template names. #html_sidebars = {} # Additional templates that should be rendered to pages, maps page names to # template names. #html_additional_pages = {} # If false, no module index is generated. #html_use_modindex = True # If false, no index is generated. #html_use_index = True # If true, the index is split into individual pages for each letter. #html_split_index = False # If true, links to the reST sources are added to the pages. #html_show_sourcelink = True # If true, an OpenSearch description file will be output, and all pages will # contain a tag referring to it. The value of this option must be the # base URL from which the finished HTML is served. #html_use_opensearch = '' # If nonempty, this is the file name suffix for HTML files (e.g. ".xhtml"). #html_file_suffix = '' # Output file base name for HTML help builder. htmlhelp_basename = 'ldnsxdoc' # -- Options for LaTeX output -------------------------------------------------- # The paper size ('letter' or 'a4'). #latex_paper_size = 'letter' # The font size ('10pt', '11pt' or '12pt'). #latex_font_size = '10pt' # Grouping the document tree into LaTeX files. List of tuples # (source start file, target name, title, author, documentclass [howto/manual]). latex_documents = [ ('index', 'ldnsx.tex', u'ldnsx Documentation', u'Christopher Olah', 'manual'), ] # The name of an image file (relative to this directory) to place at the top of # the title page. #latex_logo = None # For "manual" documents, if this is true, then toplevel headings are parts, # not chapters. #latex_use_parts = False # Additional stuff for the LaTeX preamble. #latex_preamble = '' # Documents to append as an appendix to all manuals. #latex_appendices = [] # If false, no module index is generated. #latex_use_modindex = True ldns-1.6.17/contrib/ldnsx/source/api/0000775000175100017510000000000012264060151016754 5ustar willemwillemldns-1.6.17/contrib/ldnsx/source/api/ldnsx.rst0000664000175100017510000000027712264060151020644 0ustar willemwillemLDNSX API Reference =================== .. automodule:: ldnsx :members: query, get_rrs, secure_query Classes ------- .. toctree:: :maxdepth: 1 :glob: resolver packet resource_record ldns-1.6.17/contrib/ldnsx/source/api/resolver.rst0000664000175100017510000000013212264060151021343 0ustar willemwillemClass resolver =============== .. autoclass:: ldnsx.resolver :members: :undoc-members: ldns-1.6.17/contrib/ldnsx/source/api/resource_record.rst0000664000175100017510000000015612264060151022675 0ustar willemwillemClass resource_record ===================== .. autoclass:: ldnsx.resource_record :members: :undoc-members: ldns-1.6.17/contrib/ldnsx/source/api/packet.rst0000664000175100017510000000012512264060151020753 0ustar willemwillemClass packet ============== .. autoclass:: ldnsx.packet :members: :undoc-members: ldns-1.6.17/contrib/ldnsx/source/examples/0000775000175100017510000000000012264060151020021 5ustar willemwillemldns-1.6.17/contrib/ldnsx/source/examples/ldnsx-walk.rst0000664000175100017510000000015012264060151022633 0ustar willemwillemNSEC Walker =========== .. literalinclude:: ../../examples/ldnsx-walk.py :language: python :linenos: ldns-1.6.17/contrib/ldnsx/source/examples/ldnsx-mx1.rst0000664000175100017510000000012712264060151022406 0ustar willemwillemMX1 === .. literalinclude:: ../../examples/ldnsx-mx1.py :language: python :linenos: ldns-1.6.17/contrib/ldnsx/source/examples/ldnsx-dnssec.rst0000664000175100017510000000016012264060151023155 0ustar willemwillemDNSSEC Example ============== .. literalinclude:: ../../examples/ldnsx-dnssec.py :language: python :linenos: ldns-1.6.17/contrib/ldnsx/source/examples/ldnsx-mx2.rst0000664000175100017510000000012712264060151022407 0ustar willemwillemMX2 === .. literalinclude:: ../../examples/ldnsx-mx2.py :language: python :linenos: ldns-1.6.17/contrib/ldnsx/source/examples/ldnsx-axfr.rst0000664000175100017510000000015212264060151022637 0ustar willemwillemAXFR Example ============ .. literalinclude:: ../../examples/ldnsx-axfr.py :language: python :linenos: ldns-1.6.17/contrib/ldnsx/source/index.rst0000664000175100017510000000203412264060151020043 0ustar willemwillemWelcome to ldnsx's documentation! ================================= LDNSX: Easy DNS (including DNSSEC) via ldns. ldns is a great library. It is a powerfull tool for working with DNS. python-ldns it is a straight up clone of the C interface, howver that is not a very good interface for python. Its documentation is incomplete and some functions don't work as described. And some objects don't have a full python API. ldnsx aims to fix this. It wraps around the ldns python bindings, working around its limitations and providing a well-documented, more pythonistic interface. Reference ========= .. toctree:: :maxdepth: 1 api/ldnsx .. toctree:: :maxdepth: 2 api/resolver api/packet api/resource_record Examples ======== Examples translated from ldns examples: .. toctree:: :maxdepth: 1 examples/ldnsx-axfr examples/ldnsx-dnssec examples/ldnsx-mx1 examples/ldnsx-mx2 Others: .. toctree:: :maxdepth: 1 examples/ldnsx-walk Indices and tables ================== * :ref:`genindex` * :ref:`search` ldns-1.6.17/contrib/ldnsx/ldnsx.py0000664000175100017510000007274712264060151016426 0ustar willemwillem# Copyright (C) Xelerance Corp. . # Author: Christopher Olah # License: BSD """ Easy DNS (including DNSSEC) via ldns. ldns is a great library. It is a powerfull tool for working with DNS. python-ldns it is a straight up clone of the C interface, howver that is not a very good interface for python. Its documentation is incomplete and some functions don't work as described. And some objects don't have a full python API. ldnsx aims to fix this. It wraps around the ldns python bindings, working around its limitations and providing a well-documented, more pythonistic interface. **WARNING:** **API subject to change.** No backwards compatibility guarantee. Write software using this version at your own risk! Examples -------- Query the default resolver for google.com's A records. Print the response packet. >>> import ldnsx >>> resolver = ldnsx.resolver() >>> print resolver.query("google.com","A") Print the root NS records from f.root-servers.net; if we get a response, else an error message. >>> import ldnsx >>> pkt = ldnsx.resolver("f.root-servers.net").query(".", "NS") >>> if pkt: >>> for rr in pkt.answer(): >>> print rr >>> else: >>> print "response not received" """ import time, sys, calendar, warnings, socket try: import ldns except ImportError: print >> sys.stderr, "ldnsx requires the ldns-python sub-package from http://www.nlnetlabs.nl/projects/ldns/" print >> sys.stderr, "Fedora/CentOS: yum install ldns-python" print >> sys.stderr, "Debian/Ubuntu: apt-get install python-ldns" print >> sys.stderr, "openSUSE: zypper in python-ldns" sys.exit(1) __version__ = "0.1" def isValidIP(ipaddr): try: v4 = socket.inet_pton(socket.AF_INET,ipaddr) return 4 except: try: v6 = socket.inet_pton(socket.AF_INET6,ipaddr) return 6 except: return 0 def query(name, rr_type, rr_class="IN", flags=["RD"], tries = 3, res=None): """Convenience function. Creates a resolver and then queries it. Refer to resolver.query() * name -- domain to query for * rr_type -- rr_type to query for * flags -- flags for query (list of strings) * tries -- number of times to retry the query on failure * res -- configurations for the resolver as a dict -- see resolver() """ if isinstance(res, list) or isinstance(res, tuple): res = resolver(*res) elif isinstance(res, dict): res = resolver(**res) else: res = resolver(res) return res.query(name, rr_type, rr_class, flags, tries) def get_rrs(name, rr_type, rr_class="IN", tries = 3, strict = False, res=None, **kwds): """Convenience function. Gets RRs for name of type rr_type trying tries times. If strict, it raises and exception on failure, otherwise it returns []. * name -- domain to query for * rr_type -- rr_type to query for * flags -- flags for query (list of strings) * tries -- number of times to retry the query on failure * strict -- if the query fails, do we return [] or raise an exception? * res -- configurations for the resolver as a dict -- see resolver() * kwds -- query filters, refer to packet.answer() """ if isinstance(res, list) or isinstance(res, tuple): res = resolver(*res) elif isinstance(res, dict): res = resolver(**res) else: res = resolver(res) if "|" in rr_type: pkt = res.query(name, "ANY", rr_class=rr_class, tries=tries) else: pkt = res.query(name, rr_type, rr_class=rr_class, tries=tries) if pkt: if rr_type in ["", "ANY", "*"]: return pkt.answer( **kwds) else: return pkt.answer(rr_type=rr_type, **kwds) else: if strict: raise Exception("LDNS couldn't complete query") else: return [] def secure_query(name, rr_type, rr_class="IN", flags=["RD"], tries = 1, flex=False, res=None): """Convenience function. Creates a resolver and then does a DNSSEC query. Refer to resolver.query() * name -- domain to query for * rr_type -- rr_type to query for * flags -- flags for query (list of strings) * tries -- number of times to retry the query on failure * flex -- if we can't verify data, exception or warning? * res -- configurations for the resolver as a dict -- see resolver()""" if isinstance(res, list) or isinstance(res, tuple): res = resolver(*res) elif isinstance(res, dict): res = resolver(**res) else: res = resolver(res) pkt = res.query(name, rr_type, rr_class, flags, tries) if pkt.rcode() == "SERVFAIL": raise Exception("%s lookup failed (server error or dnssec validation failed)" % name) if pkt.rcode() == "NXDOMAIN": if "AD" in pkt.flags(): raise Exception("%s lookup failed (non-existence proven by DNSSEC)" % name ) else: raise Exception("%s lookup failed" % name ) if pkt.rcode() == "NOERROR": if "AD" not in pkt.flags(): if not flex: raise Exception("DNS lookup was insecure") else: warnings.warn("DNS lookup was insecure") return pkt else: raise Exception("unknown ldns error, %s" % pkt.rcode()) class resolver: """ A wrapper around ldns.ldns_resolver. **Examples** Making resolvers is easy! >>> from ldnsx import resolver >>> resolver() # from /etc/resolv.conf >>> resolver("") # resolver with no nameservers >>> resolver("193.110.157.135") #resolver pointing to ip addr >>> resolver("f.root-servers.net") # resolver pointing ip address(es) resolved from name >>> resolver("193.110.157.135, 193.110.157.136") >>> # resolver pointing to multiple ip addr, first takes precedence. So is playing around with their nameservers! >>> import ldnsx >>> res = ldnsx.resolver("192.168.1.1") >>> res.add_nameserver("192.168.1.2") >>> res.add_nameserver("192.168.1.3") >>> res.nameservers_ip() ["192.168.1.1","192.168.1.2","192.168.1.3"] And querying! >>> from ldnsx import resolver >>> res= resolver() >>> res.query("cow.com","A") ;; ->>HEADER<<- opcode: QUERY, rcode: NOERROR, id: 7663 ;; flags: qr rd ra ; QUERY: 1, ANSWER: 1, AUTHORITY: 0, ADDITIONAL: 0 ;; QUESTION SECTION: ;; cow.com. IN A ;; ANSWER SECTION: cow.com. 300 IN A 208.87.34.18 ;; AUTHORITY SECTION: ;; ADDITIONAL SECTION: ;; Query time: 313 msec ;; SERVER: 192.168.111.9 ;; WHEN: Fri Jun 3 11:01:02 2011 ;; MSG SIZE rcvd: 41 """ def __init__(self, ns = None, dnssec = False, tcp = False, port = 53): """resolver constructor * ns -- the nameserver/comma delimited nameserver list defaults to settings from /etc/resolv.conf * dnssec -- should the resolver try and use dnssec or not? * tcp -- should the resolver use TCP 'auto' is a depricated work around for old ldns problems * port -- the port to use, must be the same for all nameservers """ # We construct based on a file and dump the nameservers rather than using # ldns_resolver_new() to avoid environment/configuration/magic specific # bugs. self._ldns_resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") if ns != None: self.drop_nameservers() nm_list = ns.split(',') nm_list = map(lambda s: s.strip(), nm_list) nm_list = filter(lambda s: s != "", nm_list) nm_list.reverse() for nm in nm_list: self.add_nameserver(nm) # Configure DNSSEC, tcp and port self.set_dnssec(dnssec) if tcp == 'auto': self.autotcp = True self._ldns_resolver.set_usevc(False) else: self.autotcp = False self._ldns_resolver.set_usevc(tcp) self._ldns_resolver.set_port(port) def query(self, name, rr_type, rr_class="IN", flags=["RD"], tries = 3): """Run a query on the resolver. * name -- name to query for * rr_type -- the record type to query for * rr_class -- the class to query for, defaults to IN (Internet) * flags -- the flags to send the query with * tries -- the number of times to attempt to acheive query in case of packet loss, etc **Examples** Let's get some A records! >>> google_a_records = resolver.query("google.com","A").answer() Using DNSSEC is easy :) >>> dnssec_pkt = ldnsx.resolver(dnssec=True).query("xelerance.com") We let you use strings to make things easy, but if you prefer stay close to DNS... >>> AAAA = 28 >>> resolver.query("ipv6.google.com", AAAA) **More about rr_type** rr_type must be a supported resource record type. There are a large number of RR types: =========== =================================== ================== TYPE Value and meaning Reference =========== =================================== ================== A 1 a host address [RFC1035] NS 2 an authoritative name server [RFC1035] ... AAAA 28 IP6 Address [RFC3596] ... DS 43 Delegation Signer [RFC4034][RFC3658] ... DNSKEY 48 DNSKEY [RFC4034][RFC3755] ... Unassigned 32770-65279 Private use 65280-65534 Reserved 65535 =========== =================================== ================== (From http://www.iana.org/assignments/dns-parameters) RR types are given as a string (eg. "A"). In the case of Unassigned/Private use/Reserved ones, they are given as "TYPEXXXXX" where XXXXX is the number. ie. RR type 65280 is "TYPE65280". You may also pass the integer, but you always be given the string. If the version of ldnsx you are using is old, it is possible that there could be new rr_types that we don't recognise mnemonic for. You can still use the number XXX or the string "TYPEXXX". To determine what rr_type menmonics we support, please refer to resolver.supported_rr_types() """ # Determine rr_type int if rr_type in _rr_types.keys(): _rr_type = _rr_types[rr_type] elif isinstance(rr_type,int): _rr_type = rr_type elif isinstance(rr_type,str) and rr_type[0:4] == "TYPE": try: _rr_type = int(rr_type[4:]) except: raise Exception("%s is a bad RR type. TYPEXXXX: XXXX must be a number") else: raise Exception("ldnsx (version %s) does not support the RR type %s." % (__version__, str(rr_type)) ) # Determine rr_class int if rr_class == "IN": _rr_class = ldns.LDNS_RR_CLASS_IN elif rr_class == "CH": _rr_class = ldns.LDNS_RR_CLASS_CH elif rr_class == "HS": _rr_class = ldns.LDNS_RR_CLASS_HS else: raise Exception("ldnsx (version %s) does not support the RR class %s." % (__version__, str(rr_class)) ) # Determine flags int _flags = 0 if "QR" in flags: _flags |= ldns.LDNS_QR if "AA" in flags: _flags |= ldns.LDNS_AA if "TC" in flags: _flags |= ldns.LDNS_TC if "RD" in flags: _flags |= ldns.LDNS_RD if "CD" in flags: _flags |= ldns.LDNS_CD if "RA" in flags: _flags |= ldns.LDNS_RA if "AD" in flags: _flags |= ldns.LDNS_AD # Query if tries == 0: return None try: pkt = self._ldns_resolver.query(name, _rr_type, _rr_class, _flags) except KeyboardInterrupt: #Since so much time is spent waiting on ldns, this is very common place for Ctr-C to fall raise except: #Since the ldns exceptiion is not very descriptive... raise Exception("ldns backend ran into problems. Likely, the name you were querying for, %s, was invalid." % name) #Deal with failed queries if not pkt: if tries <= 1: return None else: # One of the major causes of none-packets is truncation of packets # When autotcp is set, we are in a flexible enough position to try and use tcp # to get around this. # Either way, we want to replace the resolver, since resolvers will sometimes # just freeze up. if self.autotcp: self = resolver( ",".join(self.nameservers_ip()),tcp=True, dnssec = self._ldns_resolver.dnssec()) self.autotcp = True pkt = self.query(name, rr_type, rr_class=rr_class, flags=flags, tries = tries-1) self._ldns_resolver.set_usevc(False) return pkt else: self = resolver( ",".join(self.nameservers_ip()), tcp = self._ldns_resolver.usevc(), dnssec = self._ldns_resolver.dnssec() ) time.sleep(1) # It could be that things are failing because of a brief outage return self.query(name, rr_type, rr_class=rr_class, flags=flags, tries = tries-1) elif self.autotcp: pkt = packet(pkt) if "TC" in pkt.flags(): self._ldns_resolver.set_usevc(True) pkt2 = self.query(name, rr_type, rr_class=rr_class, flags=flags, tries = tries-1) self._ldns_resolver.set_usevc(False) if pkt2: return packet(pkt2) return pkt return packet(pkt) #ret = [] #for rr in pkt.answer().rrs(): # ret.append([str(rr.owner()),rr.ttl(),rr.get_class_str(),rr.get_type_str()]+[str(rdf) for rdf in rr.rdfs()]) #return ret def suported_rr_types(self): """ Returns the supported DNS resource record types. Refer to resolver.query() for thorough documentation of resource record types or refer to: http://www.iana.org/assignments/dns-parameters """ return _rr_types.keys() def AXFR(self,name): """AXFR for name * name -- name to AXFR for This function is a generator. As it AXFRs it will yield you the records. **Example** Let's get a list of the tlds (gotta catch em all!): >>> tlds = [] >>> for rr in resolver("f.root-servers.net").AXFR("."): >>> if rr.rr_type() == "NS": >>> tlds.append(rr.owner()) """ #Dname seems to be unecessary on some computers, but it is on others. Avoid bugs. if self._ldns_resolver.axfr_start(ldns.ldns_dname(name), ldns.LDNS_RR_CLASS_IN) != ldns.LDNS_STATUS_OK: raise Exception("Starting AXFR failed. Error: %s" % ldns.ldns_get_errorstr_by_id(status)) pres = self._ldns_resolver.axfr_next() while pres: yield resource_record(pres) pres = self._ldns_resolver.axfr_next() def nameservers_ip(self): """ returns a list of the resolvers nameservers (as IP addr) """ nm_stack2 =[] nm_str_stack2=[] nm = self._ldns_resolver.pop_nameserver() while nm: nm_stack2.append(nm) nm_str_stack2.append(str(nm)) nm = self._ldns_resolver.pop_nameserver() for nm in nm_stack2: self._ldns_resolver.push_nameserver(nm) nm_str_stack2.reverse() return nm_str_stack2 def add_nameserver(self,ns): """ Add a nameserver, IPv4/IPv6/name. """ if isValidIP(ns) == 4: address = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_A,ns) self._ldns_resolver.push_nameserver(address) elif isValidIP(ns) == 6: address = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_AAAA,ns) self._ldns_resolver.push_nameserver(address) else: resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf") #address = resolver.get_addr_by_name(ns) address = resolver.get_addr_by_name(ldns.ldns_dname(ns)) if not address: address = resolver.get_addr_by_name(ldns.ldns_dname(ns)) if not address: raise Exception("Failed to resolve address for %s" % ns) for rr in address.rrs(): self._ldns_resolver.push_nameserver_rr(rr) def drop_nameservers(self): """Drops all nameservers. This function causes the resolver to forget all nameservers. """ while self._ldns_resolver.pop_nameserver(): pass def set_nameservers(self, nm_list): """Takes a list of nameservers and sets the resolver to use them """ self.drop_nameservers() for nm in nm_list: self.add_nameserver(nm) def __repr__(self): return "" % ", ".join(self.nameservers_ip()) __str__ = __repr__ def set_dnssec(self,new_dnssec_status): """Set whether the resolver uses DNSSEC. """ self._ldns_resolver.set_dnssec(new_dnssec_status) class packet: def _construct_rr_filter(self, **kwds): def match(pattern, target): if pattern[0] in ["<",">","!"]: rel = pattern[0] pattern=pattern[1:] elif pattern[0:2] in ["<=","=>"]: rel = pattern[0:2] pattern=pattern[2:] else: rel = "=" for val in pattern.split("|"): if {"<" : target < val, ">" : target > val, "!" : target != val, "=" : target == val, ">=": target >= val, "<=": target <= val}[rel]: return True return False def f(rr): for key in kwds.keys(): if ( ( isinstance(kwds[key], list) and str(rr[key]) not in map(str,kwds[key]) ) or ( not isinstance(kwds[key], list) and not match(str(kwds[key]), str(rr[key])))): return False return True return f def __init__(self, pkt): self._ldns_pkt = pkt def __repr__(self): return str(self._ldns_pkt) __str__ = __repr__ def rcode(self): """Returns the rcode. Example returned value: "NOERROR" possilbe rcodes (via ldns): "FORMERR", "MASK", "NOERROR", "NOTAUTH", "NOTIMPL", "NOTZONE", "NXDOMAIN", "NXRSET", "REFUSED", "SERVFAIL", "SHIFT", "YXDOMAIN", "YXRRSET" Refer to http://www.iana.org/assignments/dns-parameters section: DNS RCODEs """ return self._ldns_pkt.rcode2str() def opcode(self): """Returns the rcode. Example returned value: "QUERY" """ return self._ldns_pkt.opcode2str() def flags(self): """Return packet flags (as list of strings). Example returned value: ['QR', 'RA', 'RD'] **What are the flags?** ======== ==== ===================== ========= Bit Flag Description Reference ======== ==== ===================== ========= bit 5 AA Authoritative Answer [RFC1035] bit 6 TC Truncated Response [RFC1035] bit 7 RD Recursion Desired [RFC1035] bit 8 RA Recursion Allowed [RFC1035] bit 9 Reserved bit 10 AD Authentic Data [RFC4035] bit 11 CD Checking Disabled [RFC4035] ======== ==== ===================== ========= (from http://www.iana.org/assignments/dns-parameters) There is also QR. It is mentioned in other sources, though not the above page. It being false means that the packet is a query, it being true means that it is a response. """ ret = [] if self._ldns_pkt.aa(): ret += ["AA"] if self._ldns_pkt.ad(): ret += ["AD"] if self._ldns_pkt.cd(): ret += ["CD"] if self._ldns_pkt.qr(): ret += ["QR"] if self._ldns_pkt.ra(): ret += ["RA"] if self._ldns_pkt.rd(): ret += ["RD"] if self._ldns_pkt.tc(): ret += ["TC"] return ret def answer(self, **filters): """Returns the answer section. * filters -- a filtering mechanism Since a very common desire is to filter the resource records in a packet section, we provide a special tool for doing this: filters. They are a lot like regular python filters, but more convenient. If you set a field equal to some value, you will only receive resource records for which it holds true. **Examples** >>> res = ldnsx.resolver() >>> pkt = res.query("google.ca","A") >>> pkt.answer() [google.ca. 28 IN A 74.125.91.99 , google.ca. 28 IN A 74.125.91.105 , google.ca. 28 IN A 74.125.91.147 , google.ca. 28 IN A 74.125.91.103 , google.ca. 28 IN A 74.125.91.104 , google.ca. 28 IN A 74.125.91.106 ] To understand filters, consider the following: >>> pkt = ldnsx.query("cow.com","ANY") >>> pkt.answer() [cow.com. 276 IN A 208.87.32.75 , cow.com. 3576 IN NS sell.internettraffic.com. , cow.com. 3576 IN NS buy.internettraffic.com. , cow.com. 3576 IN SOA buy.internettraffic.com. hostmaster.hostingnet.com. 1308785320 10800 3600 604800 3600 ] >>> pkt.answer(rr_type="A") [cow.com. 276 IN A 208.87.32.75 ] >>> pkt.answer(rr_type="A|NS") [cow.com. 276 IN A 208.87.32.75 , cow.com. 3576 IN NS sell.internettraffic.com. , cow.com. 3576 IN NS buy.internettraffic.com. ] >>> pkt.answer(rr_type="!NS") [cow.com. 276 IN A 208.87.32.75 , cow.com. 3576 IN SOA buy.internettraffic.com. hostmaster.hostingnet.com. 1308785320 10800 3600 604800 3600 ] fields are the same as when indexing a resource record. note: ordering is alphabetical. """ ret = [resource_record(rr) for rr in self._ldns_pkt.answer().rrs()] return filter(self._construct_rr_filter(**filters), ret) def authority(self, **filters): """Returns the authority section. * filters -- a filtering mechanism Since a very common desire is to filter the resource records in a packet section, we provide a special tool for doing this: filters. They are a lot like regular python filters, but more convenient. If you set a field equal to some value, you will only receive resource records for which it holds true. See answer() for details. **Examples** >>> res = ldnsx.resolver() >>> pkt = res.query("google.ca","A") >>> pkt.authority() [google.ca. 251090 IN NS ns3.google.com. , google.ca. 251090 IN NS ns1.google.com. , google.ca. 251090 IN NS ns2.google.com. , google.ca. 251090 IN NS ns4.google.com. ] """ ret = [resource_record(rr) for rr in self._ldns_pkt.authority().rrs()] return filter(self._construct_rr_filter(**filters), ret) def additional(self, **filters): """Returns the additional section. * filters -- a filtering mechanism Since a very common desire is to filter the resource records in a packet section, we provide a special tool for doing this: filters. They are a lot like regular python filters, but more convenient. If you set a field equal to some value, you will only receive resource records for which it holds true. See answer() for details. **Examples** >>> res = ldnsx.resolver() >>> pkt = res.query("google.ca","A") >>> pkt.additional() [ns3.google.com. 268778 IN A 216.239.36.10 , ns1.google.com. 262925 IN A 216.239.32.10 , ns2.google.com. 255659 IN A 216.239.34.10 , ns4.google.com. 264489 IN A 216.239.38.10 ] """ ret = [resource_record(rr) for rr in self._ldns_pkt.additional().rrs()] return filter(self._construct_rr_filter(**filters), ret) def question(self, **filters): """Returns the question section. * filters -- a filtering mechanism Since a very common desire is to filter the resource records in a packet section, we provide a special tool for doing this: filters. They are a lot like regular python filters, but more convenient. If you set a field equal to some value, you will only receive resource records for which it holds true. See answer() for details. """ ret = [resource_record(rr) for rr in self._ldns_pkt.question().rrs()] return filter(self._construct_rr_filter(**filters), ret) class resource_record: _rdfs = None _iter_pos = None def __init__(self, rr): self._ldns_rr = rr self._rdfs = [str(rr.owner()),rr.ttl(),rr.get_class_str(),rr.get_type_str()]+[str(rdf) for rdf in rr.rdfs()] def __repr__(self): return str(self._ldns_rr) __str__ = __repr__ def __iter__(self): self._iter_pos = 0 return self def next(self): if self._iter_pos < len(self._rdfs): self._iter_pos += 1 return self._rdfs[self._iter_pos-1] else: raise StopIteration def __len__(self): try: return len(self._rdfs) except: return 0 def __getitem__(self, n): if isinstance(n, int): return self._rdfs[n] elif isinstance(n, str): n = n.lower() if n in ["owner"]: return self.owner() elif n in ["rr_type", "rr type", "type"]: return self.rr_type() elif n in ["rr_class", "rr class", "class"]: return self.rr_class() elif n in ["covered_type", "covered type", "type2"]: return self.covered_type() elif n in ["ttl"]: return self.ttl() elif n in ["ip"]: return self.ip() elif n in ["alg", "algorithm"]: return self.alg() elif n in ["protocol"]: return self.protocol() elif n in ["flags"]: return self.flags() else: raise Exception("ldnsx (version %s) does not recognize the rr field %s" % (__version__,n) ) else: raise TypeError("bad type %s for index resource record" % type(n) ) #def rdfs(self): # return self._rdfs.clone() def owner(self): """Get the RR's owner""" return str(self._ldns_rr.owner()) def rr_type(self): """Get a RR's type """ return self._ldns_rr.get_type_str() def covered_type(self): """Get an RRSIG RR's covered type""" if self.rr_type() == "RRSIG": return self[4] else: return "" def rr_class(self): """Get the RR's collapse""" return self._ldns_rr.get_class_str() def ttl(self): """Get the RR's TTL""" return self._ldns_rr.ttl() def inception(self, out_format="UTC"): """returns the inception time in format out_format, defaulting to a UTC string. options for out_format are: UTC -- a UTC string eg. 20110712192610 (2011/07/12 19:26:10) unix -- number of seconds since the epoch, Jan 1, 1970 struct_time -- the format used by python's time library """ # Something very strange is going on with inception/expiration dates in DNS. # According to RFC 4034 section 3.1.5 (http://tools.ietf.org/html/rfc4034#page-9) # the inception/expiration fields should be in seconds since Jan 1, 1970, the Unix # epoch (as is standard in unix). Yet all the packets I've seen provide UTC encoded # as a string instead, eg. "20110712192610" which is 2011/07/12 19:26:10. # # It turns out that this is a standard thing that ldns is doing before the data gets # to us. if self.rr_type() == "RRSIG": if out_format.lower() in ["utc", "utc str", "utc_str"]: return self[9] elif out_format.lower() in ["unix", "posix", "ctime"]: return calendar.timegm(time.strptime(self[9], "%Y%m%d%H%M%S")) elif out_format.lower() in ["relative"]: return calendar.timegm(time.strptime(self[9], "%Y%m%d%H%M%S")) - time.time() elif out_format.lower() in ["struct_time", "time.struct_time"]: return time.strptime(self[9], "%Y%m%d%H%M%S") else: raise Exception("unrecognized time format") else: return "" def expiration(self, out_format="UTC"): """get expiration time. see inception() for more information""" if self.rr_type() == "RRSIG": if out_format.lower() in ["utc", "utc str", "utc_str"]: return self[8] elif out_format.lower() in ["unix", "posix", "ctime"]: return calendar.timegm(time.strptime(self[8], "%Y%m%d%H%M%S")) elif out_format.lower() in ["relative"]: return calendar.timegm(time.strptime(self[8], "%Y%m%d%H%M%S")) - time.time() elif out_format.lower() in ["struct_time", "time.struct_time"]: return time.strptime(self[8], "%Y%m%d%H%M%S") else: raise Exception("unrecognized time format") else: return "" def ip(self): """ IP address form A/AAAA record""" if self.rr_type() in ["A", "AAAA"]: return self[4] else: raise Exception("ldnsx does not support ip for records other than A/AAAA") def alg(self): """Returns algorithm of RRSIG/DNSKEY/DS""" t = self.rr_type() if t == "RRSIG": return int(self[5]) elif t == "DNSKEY": return int(self[6]) elif t == "DS": return int(self[5]) else: return -1 def protocol(self): """ Returns proticol of the DNSKEY""" t = self.rr_type() if t == "DNSKEY": return int(self[5]) else: return -1 def flags(self): """Return RR flags for DNSKEY """ t = self.rr_type() if t == "DNSKEY": ret = [] n = int(self[4]) for m in range(1): if 2**(15-m) & n: if m == 7: ret.append("ZONE") elif m == 8: ret.append("REVOKE") elif m ==15: ret.append("SEP") else: ret.append(m) return ret else: return [] _rr_types={ "A" : ldns.LDNS_RR_TYPE_A, "A6" : ldns.LDNS_RR_TYPE_A6, "AAAA" : ldns.LDNS_RR_TYPE_AAAA, "AFSDB": ldns.LDNS_RR_TYPE_AFSDB, "ANY" : ldns.LDNS_RR_TYPE_ANY, "APL" : ldns.LDNS_RR_TYPE_APL, "ATMA" : ldns.LDNS_RR_TYPE_ATMA, "AXFR" : ldns.LDNS_RR_TYPE_AXFR, "CERT" : ldns.LDNS_RR_TYPE_CERT, "CNAME": ldns.LDNS_RR_TYPE_CNAME, "COUNT": ldns.LDNS_RR_TYPE_COUNT, "DHCID": ldns.LDNS_RR_TYPE_DHCID, "DLV" : ldns.LDNS_RR_TYPE_DLV, "DNAME": ldns.LDNS_RR_TYPE_DNAME, "DNSKEY": ldns.LDNS_RR_TYPE_DNSKEY, "DS" : ldns.LDNS_RR_TYPE_DS, "EID" : ldns.LDNS_RR_TYPE_EID, "FIRST": ldns.LDNS_RR_TYPE_FIRST, "GID" : ldns.LDNS_RR_TYPE_GID, "GPOS" : ldns.LDNS_RR_TYPE_GPOS, "HINFO": ldns.LDNS_RR_TYPE_HINFO, "IPSECKEY": ldns.LDNS_RR_TYPE_IPSECKEY, "ISDN" : ldns.LDNS_RR_TYPE_ISDN, "IXFR" : ldns.LDNS_RR_TYPE_IXFR, "KEY" : ldns.LDNS_RR_TYPE_KEY, "KX" : ldns.LDNS_RR_TYPE_KX, "LAST" : ldns.LDNS_RR_TYPE_LAST, "LOC" : ldns.LDNS_RR_TYPE_LOC, "MAILA": ldns.LDNS_RR_TYPE_MAILA, "MAILB": ldns.LDNS_RR_TYPE_MAILB, "MB" : ldns.LDNS_RR_TYPE_MB, "MD" : ldns.LDNS_RR_TYPE_MD, "MF" : ldns.LDNS_RR_TYPE_MF, "MG" : ldns.LDNS_RR_TYPE_MG, "MINFO": ldns.LDNS_RR_TYPE_MINFO, "MR" : ldns.LDNS_RR_TYPE_MR, "MX" : ldns.LDNS_RR_TYPE_MX, "NAPTR": ldns.LDNS_RR_TYPE_NAPTR, "NIMLOC": ldns.LDNS_RR_TYPE_NIMLOC, "NS" : ldns.LDNS_RR_TYPE_NS, "NSAP" : ldns.LDNS_RR_TYPE_NSAP, "NSAP_PTR" : ldns.LDNS_RR_TYPE_NSAP_PTR, "NSEC" : ldns.LDNS_RR_TYPE_NSEC, "NSEC3": ldns.LDNS_RR_TYPE_NSEC3, "NSEC3PARAM" : ldns.LDNS_RR_TYPE_NSEC3PARAM, "NSEC3PARAMS" : ldns.LDNS_RR_TYPE_NSEC3PARAMS, "NULL" : ldns.LDNS_RR_TYPE_NULL, "NXT" : ldns.LDNS_RR_TYPE_NXT, "OPT" : ldns.LDNS_RR_TYPE_OPT, "PTR" : ldns.LDNS_RR_TYPE_PTR, "PX" : ldns.LDNS_RR_TYPE_PX, "RP" : ldns.LDNS_RR_TYPE_RP, "RRSIG": ldns.LDNS_RR_TYPE_RRSIG, "RT" : ldns.LDNS_RR_TYPE_RT, "SIG" : ldns.LDNS_RR_TYPE_SIG, "SINK" : ldns.LDNS_RR_TYPE_SINK, "SOA" : ldns.LDNS_RR_TYPE_SOA, "SRV" : ldns.LDNS_RR_TYPE_SRV, "SSHFP": ldns.LDNS_RR_TYPE_SSHFP, "TSIG" : ldns.LDNS_RR_TYPE_TSIG, "TXT" : ldns.LDNS_RR_TYPE_TXT, "UID" : ldns.LDNS_RR_TYPE_UID, "UINFO": ldns.LDNS_RR_TYPE_UINFO, "UNSPEC": ldns.LDNS_RR_TYPE_UNSPEC, "WKS" : ldns.LDNS_RR_TYPE_WKS, "X25" : ldns.LDNS_RR_TYPE_X25 } ldns-1.6.17/contrib/ldnsx/Makefile0000664000175100017510000000607012264060151016346 0ustar willemwillem# Makefile for Sphinx documentation # # You can set these variables from the command line. SPHINXOPTS = SPHINXBUILD = sphinx-build PAPER = BUILDDIR = build # Internal variables. PAPEROPT_a4 = -D latex_paper_size=a4 PAPEROPT_letter = -D latex_paper_size=letter ALLSPHINXOPTS = -d $(BUILDDIR)/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) source .PHONY: help clean html dirhtml pickle json htmlhelp qthelp latex changes linkcheck doctest help: @echo "Please use \`make ' where is one of" @echo " html to make standalone HTML files" @echo " dirhtml to make HTML files named index.html in directories" @echo " pickle to make pickle files" @echo " json to make JSON files" @echo " htmlhelp to make HTML files and a HTML help project" @echo " qthelp to make HTML files and a qthelp project" @echo " latex to make LaTeX files, you can set PAPER=a4 or PAPER=letter" @echo " changes to make an overview of all changed/added/deprecated items" @echo " linkcheck to check all external links for integrity" @echo " doctest to run all doctests embedded in the documentation (if enabled)" clean: -rm -rf $(BUILDDIR)/* html: $(SPHINXBUILD) -b html $(ALLSPHINXOPTS) $(BUILDDIR)/html @echo @echo "Build finished. The HTML pages are in $(BUILDDIR)/html." dirhtml: $(SPHINXBUILD) -b dirhtml $(ALLSPHINXOPTS) $(BUILDDIR)/dirhtml @echo @echo "Build finished. The HTML pages are in $(BUILDDIR)/dirhtml." pickle: $(SPHINXBUILD) -b pickle $(ALLSPHINXOPTS) $(BUILDDIR)/pickle @echo @echo "Build finished; now you can process the pickle files." json: $(SPHINXBUILD) -b json $(ALLSPHINXOPTS) $(BUILDDIR)/json @echo @echo "Build finished; now you can process the JSON files." htmlhelp: $(SPHINXBUILD) -b htmlhelp $(ALLSPHINXOPTS) $(BUILDDIR)/htmlhelp @echo @echo "Build finished; now you can run HTML Help Workshop with the" \ ".hhp project file in $(BUILDDIR)/htmlhelp." qthelp: $(SPHINXBUILD) -b qthelp $(ALLSPHINXOPTS) $(BUILDDIR)/qthelp @echo @echo "Build finished; now you can run "qcollectiongenerator" with the" \ ".qhcp project file in $(BUILDDIR)/qthelp, like this:" @echo "# qcollectiongenerator $(BUILDDIR)/qthelp/ldnsx.qhcp" @echo "To view the help file:" @echo "# assistant -collectionFile $(BUILDDIR)/qthelp/ldnsx.qhc" latex: $(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex @echo @echo "Build finished; the LaTeX files are in $(BUILDDIR)/latex." @echo "Run \`make all-pdf' or \`make all-ps' in that directory to" \ "run these through (pdf)latex." changes: $(SPHINXBUILD) -b changes $(ALLSPHINXOPTS) $(BUILDDIR)/changes @echo @echo "The overview file is in $(BUILDDIR)/changes." linkcheck: $(SPHINXBUILD) -b linkcheck $(ALLSPHINXOPTS) $(BUILDDIR)/linkcheck @echo @echo "Link check complete; look for any errors in the above output " \ "or in $(BUILDDIR)/linkcheck/output.txt." doctest: $(SPHINXBUILD) -b doctest $(ALLSPHINXOPTS) $(BUILDDIR)/doctest @echo "Testing of doctests in the sources finished, look at the " \ "results in $(BUILDDIR)/doctest/output.txt." ldns-1.6.17/contrib/ldnsx/examples/0000775000175100017510000000000012264060151016521 5ustar willemwillemldns-1.6.17/contrib/ldnsx/examples/ldnsx-dnssec.py0000664000175100017510000000153612264060151021505 0ustar willemwillem#!/usr/bin/python # -*- coding: utf-8 -*- import ldnsx import sys debug = True if len(sys.argv) < 2: print "Usage:", sys.argv[0], "domain [resolver_addr]" sys.exit(1) name = sys.argv[1] # Create resolver resolver = ldnsx.resolver(dnssec=True) # Custom resolver if len(sys.argv) > 2: # Clear previous nameservers resolver.set_nameservers(sys.argv[2:]) # Resolve DNS name pkt = resolver.query(name, "A") if pkt and pkt.answer(): # Debug if debug: print "NS returned:", pkt.rcode(), "(AA: %d AD: %d)" % ( "AA" in pkt.flags(), "AD" in pkt.flags() ) # SERVFAIL indicated bogus name if pkt.rcode() == "SERVFAIL": print name, "failed to resolve" # Check AD (Authenticated) bit if pkt.rcode() == "NOERROR": if "AD" in pkt.flags(): print name, "is secure" else: print name, "is insecure" ldns-1.6.17/contrib/ldnsx/examples/ldnsx-walk.py0000775000175100017510000000135712264060151021170 0ustar willemwillem#!/usr/bin/python # vim:fileencoding=utf-8 # # Walk a domain that's using NSEC and print in zonefile format. import sys import ldnsx def walk(domain): res = ldnsx.resolver("193.110.157.136", dnssec=True) pkt = res.query(domain, 666) try: nsec_rr = pkt.authority(rr_type="NSEC")[0] except: print "no NSEC found, domain is not signed or using NSEC3" sys.exit() for rr_type in nsec_rr[5].split(' ')[:-1]: for rr in ldnsx.get_rrs(domain, rr_type): print str(rr)[:-1] next_rec = nsec_rr[4] if (next_rec != domain) and (next_rec[-len(domain):] == domain): walk(next_rec) walk("xelerance.com") ldns-1.6.17/contrib/ldnsx/examples/ldnsx-mx2.py0000664000175100017510000000064612264060151020735 0ustar willemwillem#!/usr/bin/python # # MX is a small program that prints out the mx records for a particular domain # import ldnsx resolver = ldnsx.resolver() pkt = resolver.query("nic.cz", "MX") if pkt: for rr in pkt.answer(rr_type = "MX"): rdf = rr.owner() print rr #Could also do: #print rr[0], rr[1], rr[2], rr[3], " ".join(rr[4:]) #print rr.owner(), rr.ttl(), rr.rr_clas(), rr.rr_type(), " ".join(rr[4:]) ldns-1.6.17/contrib/ldnsx/examples/ldnsx-axfr.py0000664000175100017510000000174412264060151021167 0ustar willemwillem#!/usr/bin/python # vim:fileencoding=utf-8 # # AXFR client with IDN (Internationalized Domain Names) support # import ldns import encodings.idna def utf2name(name): return '.'.join([encodings.idna.ToASCII(a) for a in name.split('.')]) def name2utf(name): return '.'.join([encodings.idna.ToUnicode(a) for a in name.split('.')]) resolver = ldnsx.resolver("zone.nic.cz") #Print results for rr in resolver.AXFR(utf2name(u"háÄkyÄárky.cz")): # rdf = rr.owner() # if (rdf.get_type() == ldns.LDNS_RDF_TYPE_DNAME): # print "RDF owner: type=",rr.type(),"data=",name2utf(rr.owner()) # else: # print "RDF owner: type=",rdf.get_type_str(),"data=",str(rdf) # print " RR type=", rr.get_type_str()," ttl=",rr.ttl() # for rdf in rr.rdfs(): # if (rdf.get_type() == ldns.LDNS_RDF_TYPE_DNAME): # print " RDF: type=",rdf.get_type_str(),"data=",name2utf(str(rdf)) # else: # print " RDF: type=",rdf.get_type_str(),"data=",str(rdf) ldns-1.6.17/contrib/ldnsx/examples/ldnsx-mx1.py0000664000175100017510000000023712264060151020730 0ustar willemwillemimport ldnsx resolver = ldnsx.resolver() pkt = resolver.query("nic.cz", "MX") if (pkt): mx = pkt.answer() if (mx): mx.sort() print mx ldns-1.6.17/contrib/ldnsx/README0000664000175100017510000000203312264060151015561 0ustar willemwillemLDNSX: Easy DNS (including DNSSEC) via ldns. ldns is a great library. It is a powerfull tool for working with DNS. python-ldns it is a straight up clone of the C interface, howver that is not a very good interface for python. Its documentation is incomplete and some functions don't work as described. And some objects don't have a full python API. ldnsx aims to fix this. It wraps around the ldns python bindings, working around its limitations and providing a well-documented, more pythonistic interface. Written by Christopher Olah Examples ======== Query the default resolver for google.com's A records. Print the response packet. >>> import ldnsx >>> resolver = ldnsx.resolver() >>> print resolver.query("google.com","A") Print the NS records for com. from f.root-servers.net if we get a response, else an error message. >>> import ldnsx >>> pkt = ldnsx.resolver("f.root-servers.net").query("com.","NS") >>> if pkt: >>> for rr in pkt.answer(): >>> print rr >>> else: >>> print "response not received" ldns-1.6.17/contrib/NETLDNS.tar.gz0000664000175100017510000015246212264060151016023 0ustar willemwillem‹m×2Lí½ `\Iq0<²½‡Lîk—ã­€]i­c.I¶d{wtÙb-ÉHò®—õ®Íþ¿ú+Ïüãoýðmâ ?“8œøìç:7ka‡àíàÏ¿1þ³ŸûÜç8xÞÏÞÀ{¼çá½ÞÁûbx_ ïËàµà½Þ.x_ï]ð¾Þ;áí†wÞ³ðÞ ïqx‡áíƒéÂ5»|¦áÍÀ›…׌!x{à=ïIxGà…÷¼§n'÷À{/¼yx7à}Þ x'á‚wÞsð¾ÞYxïƒwÞ~xçà}¼à‡÷"¼ ð.Â{?¼—à}Þá}ÞWÃ{^Þ¼_ïx_ïux—à}Þ"¼Ëð¾ÞxWá-Á{Þ2¼x×à}^¤Õ5x‘"åàuàmÀ»ï¼¸¦ß€÷1xqŒ‡Ï/„÷ àýjx_ïëDû«ð¯c1 å7 <œÁñŸçÖ0.ÝÙ$íëÞö[oýëÛ±ã0|¿÷2ìÔX…OCíËðmR@¤•úô&n¾gÐç"`€>v ÿᯠmâp§I9/OêÀùÐJýHCo¥ïPÛŒÚ üÃz€z€%«ð«YÝøXPÿ³r.Å­éösè;Î!~h¿o¡6"@€óéΤO§´Ï¤Ï‘ŽàùtiÏL‹tã¥ôç?Ò¤8ÿOjíÀyüÖ„œÿ½ð>õàý‘„œÇ÷&üó_ïÓïÓïrþÿ0¼óÿ‡äÜÁù2žóÓâüGºsŽ~# Àùt iÒ¤(iÏü4ç?Ò) éÒ¤3PØk’þàüGº€óߦ8}þ#=`€qHxþão¤úüGÚˆ4 gÎæÇ(Ò¤ _@¿_Ÿwüñ}oüÚ7-̽ýó.ÿͯßò®á0œ {þq¼³Õ,ÆÓÑï ¼S°«ÌÁª?s¶R$!v ¾q'àÛ0|fà¾' |RNÀ·ÿ"Œ”YïœX½ôZ‘[n›ÄnL{«Ø÷ngÛF—»½½‡—‡€¸ùákÊë*5æî^Æ UÑ€Áémo‹¢]­´©EN@½œ² %.‹Ý6ŽÎäàRG¡m9xÇ¡ Ihþ‡˜…ÄËŸö?¹ã_ý±sþÝ÷ÿʳ¿ý§ŸO|þ/ÜVþïΗͽås_þ¿òñ÷¢HöùœWüÚ_ö²³ù‹?¹q×ÒZVâïBâÄòs>þÙ¿äü{¿¹ø½ßø’8ÙZþDÛõWÅŠÂ4NÒÙeøµ"øŸ¼üônÿÀýêk‰p̬_ 3WR/¿_Hp¢Ÿ®-Ô2¨/¢ïãÐ{ÄeG¬Ê6Ìå°•&øy9­HS·²þ0Àu°m© þ»NԢфû”õã^û9-ÔoÁûn¢¡¯‚_¿»'ÿ·~˜€Óllàþl>·%Î *XíÒù?ù¼DPJGÛEøÓ܆Ô(Jà®B/pu¸*8ÈûEKS‚L‰´a½¼ô+G)~k½| Äí„óÀQïeýEˆ¹)ëi”¶|úß?ò÷ Â=œU·ÐHuQJ¾nrg†½«Íö· ÿ¯o3ÿEGª#1¹èƒ[³§‹èßVùïsК¢¨»#R†¿SbE*RoâÔ2D”Kn¥þ9±ö•Å:ïŠFy' ¤Ù‰ßË·°þ ó­´´yg\ºÏÏ‹¶P?Ÿ¯àã•/À<¨ .µ cýk¹~<çaùKüÓ1ÊBù7rvH—ãÖµ«£yýC1ëGyö‹Z¨Ë}}¿ ¼(p ,¤=ס~ÄükBnÐ ÿÁýôç·P? yYnù¾ú‘°(ˆ6•›P‘/ÛSú­(wö¶4ŠÚ•FÖò&êã-†çŒs/¤0|o£t/Òò¾•Ò¼MKóbÊû®„Z Ó÷o¡ÏçQ‹3XßpçkÄ÷¸ã·Ï%›2@;p¾ Q 4[ú*ùO<ieþ#é;cþ5çþåüÃzŸ™ˆ¿7ÁûéDóúS‰æ(¸þà¸w·Pÿ×Âûû1êÏÄ(ËÚýŶþ1Á?ÿG #—7J•buù¼V*Ô«Nu¹Ñ_±——ëù5{£Z¿zùZº?Ù?˜N_^s Õz¹´ÔÅßâÃò”>‡êÒå8íò?oÛcþñ­{ZEÔZpyXÜ¥à©à_|àñðèêS=‰Ä6A¡"øh”·ä P@b³jÓOýɷ޵‰©(rq¬mÔIa¨ùq”Ân£0ä n§0æËQJø2 KQ˜Eiñ¦0Ä|¤*HuïI(J~„¾ß›àYwƒð¯•õs;à¿*`Úú^æ=_ö†ÿbx#ìx/s[¿—áÕïùÚ¸(ŽFÇ0,ÏÛxß„ÿ»Ýÿ¼‹ªgþøù/æÞãhòç'?ðtꩥ͌;(ÝË´¼ßœü¯óÁ—SÞ÷jy¿ò~§VÖwQºR–û! û¨–îcö+Zy¿Jåýš–î×)Ýïié~ŸÒ½ C¥»¦Y¦CöQJŸíðó+ƘßÊXîü/ˆ³#,]Ç€¿^ûàÞéøÿÜ„ÿŸŸðã?~W´ Œö¾s_öŸiîw¾ò-îëcÎsj'p+…á´a¦ ] ÅßAa=ŽÏœï¢0¦ÃgÖM»0•Ü{1ñŽ}?I?ê>è}ï7¦_=^±ð½™z÷ú°(]…á~¿ŸÂîÑÒÝKa ¤x%Zt!¾÷)BË÷ýÕ¥h »¼ûÈBæ=Cü =Úçi˜wŒ`þ¬„â X톜ú )ì¥ …É</O(úû ;žPô²—˜S@,æýǸ־ [¤0¬ÿ"…Ù ?Æ/'ôUÔÃý€ÿa\äÀÏ?óµQc¨¸H5†ºl‡Ç°ŸÆ0¡!ŽÃ³=㕦ñ:Lp㼫”î 5þ_EaoÕÆú)ï'5úQ ãuÇüS”—×P}¼~߯xPÝóÏ;~¯®¿ûÛ}ìn¡>2ü_Hㇰ¹Sƒ¯ˆ<7˜Óæ0 Õ¯ý°þÕE½xbéÅà·…=;¡öÏ!¨2ÿ0PTˆW„àK)Œ¹J¤8ÌAö$¥»›Âú)¬ÊÄ'›PØÏ7£NRþ¡0^a°Ü{)l‚°ŒI {eBÍœû(lŽÂ°m(ìbBÍìû)ìÕ 5;¢°×$ÔÊ–§0[K·LaU­Þ…}yBÍØ¯HH˜¾;áŸßš` dìúÚ}€ÞS¤#?Ö!´Û™£dÎóÅ ÿ¿Þ/£Á°¯LHºûÆ„¤¹xw÷#oN ì&‘øJ÷u <­M$¾~§IùéÛé÷7ÁçO&ä^ e¨ßB#Œ#úJƒ{©o§ï¸‡z €ó~øDqÆßÀ÷ïÏï…÷rõax¿>€ò~>ÿ?ÄHhÃÃç<|^„4?ßß Ÿ?ñ¤« Ÿ‡ß?ïOÃû3ðþ,¼?Geý|~Þ_¤ß¿ ŸŸLÈõ÷gŸJ(}óß€ï¿ ïÿ¡°?ĶÁû» ¹Ö`Xê[„÷à÷SØŸÂçŸÁûçôe“ ï_Áûáýkì;¼ ïßÁ‹G”ÿ@iÿ >ÿ™¾ÿ+|þ?x— ü+ðþ|ÿ Å¡(à¿éû_CÜóˆnþK푲Дۤ9ðkŸ}ÍQž:¾3O ¯+šî uùGöútÊ_Ý¢:´ø'oÿÝÕç¿™bè¯>H¡yõa¹Rw–Kð9RùÛ(ìn ÃûG¸‹óƒ„ŸRžP0M¤2ðoàv:—¦…ÚU:q#èüz÷égEœAÚ=ï þGß÷¹óQ0|¾C–âÊËRçSßùa Âe ,Õ™qó.mœø¼4¥¥céâHB­h£Æ+.ޝ¸3 …û³„¿»)¿6!_$MS9‡ÿ¿7þÍ:Ãaú4j3Kߘ×gnÇÒÆè%‰æg"{«¢÷˜1îUÇ ¿À½ÖŸ ŒcžQŸy1z­¿äò«>Ö3Îõa™Ç¨>ÆdÄÆä;ÚÖÿh~kâ´Ç¡sCÃמ;ÿm‰80 ŸíÂpoÇmõ¼3nâã?÷:œn!81eCªƒ³ð0ဆÏ3jÃ]Z:ïIGäùcœË`|þú€Ñ{Þ ïWÑôŠ>M5-k+úŸˆšß—h^6ªz°ÿ¼Ã‹[ÿwÀû¶›š×ÇþÅVÎqús÷®bˆc¼¿D<ášO„I(üĽ&j³äŠ6ŽSºé„Ÿû»/áßí`ØÖ5Þ´§óWiˆ2åûòß|XŽ«GØý´ ùÉn®ÿU¡y†˜wÅ=EP½yã»þóÇ‚zÃRê®Àý÷îŸgŒô3¿õ§}z«‘Š"Åd0òz|W}œßg||ï{ï}_äyæ±äjoñ?/v:ì_þæ÷õ&´6òs[@_ÜÛõ?HrúÆÃÏ@!†;[£$§ÇoØ'ô[~߃ÿysÎÜ”P”˜5,øÎ\»øL?°5ÏL¯trkpgÄ|Ë]FkÚ¥_{‹ÿÕ¶çwÞÿË«?ìæ=ïQ“ÿF¸ë܃7tüå.Ë”Ùz>©&üWóg+üÇ&¤Ì Ÿ¨úOFÒFýƒ÷]±øÏæÀ¨ÿ‡´ ¥ôqëÿù„”å5¯¿9Xÿ~°…ú Þ×RÿÛ¥¿íÞØ)ùϧkÿxI\ü ›OH™¼ò#äv½ò#䎽ò#œQ^ùò^ù.ˆ^ù¦óʬ„_~„ŒŒW~„r–]N˜|жP\\x÷>”ÿ™{âo=ó¢oâÃÓöí•Bí‡ó£­Jði}ǽãÛíÝÝ# ?þæþsæ0øïùüÇñêgo¯ñ8Þžhs‡´¼÷±íêßEëŸ7¿ƒëÏ]‰ÖôÿQWçRŒõ7³CòŸß†÷黼¥9)ƾãV¥»ûqŸ@ÿy¯·þ¸÷Ï21ïàÃ+Z¨×–ÿ¼—ðg=Šøs͘?NÈü©ùæëêêߢõÇq&U_·&P‘gÏÖÅЩ¯Î¬›ÈaÁÐ)–…}›OUÖËå32,7>rù¢c×˹²}ýòDu£R®æ‹ð³Þ(Êö•…záòDÅ™(­\n—òïŒþ Âìgßqûw3Ìðá},ë Ü&°FrIÈEì-'gž$\öïøvµì®<û[Û±l?ò8Köó:‰|ËÞÊáü7(xLïÚó¶…ãÊ0÷^~æmîfööTÒ{„[v1d~î^ËÂÚ•·]x-j¯Î!_“Hì›;¼‡ʦô~À ÿ€3{ŽAÁw½º÷ba:P¨QÚîóÝ»£hí9E ºËvxéÃëü"x;`â} |~)¼o„÷àý x¿Þ7Àû–yfÿ“ð¾ Þ7Ãû}ð~ ¼_ ï×Áûõðþ&¼o…÷Oá]„2¿ >ßï7ÁûNx¿¹ƒd¯‡¤ ¢o…÷=ðþ*¼ßïÿ…÷ÇáýNxßï¿tÈýÒŸÁç_Áû=ð~/¼¿ï‡àý0¼¿MiЦÝÂûúýCðù£ð>uý|þ¼Kðý'àóáý(¼ƒ÷ãðþ¼? ïÏÀû³ðþ\‡´I÷ T>Ÿ„ï¿ ï”ñ+ðù)xÓ¨[ ïoÀ÷?€÷ÿPúC‡äçíôù{þû÷‡ðùGZ¹¬?úçöð~Þ¿„·yÿ–Ò½œÊy|þ=„ý¼ÿï?ÁûÏðþ;¼ÿïÿƒ÷ß(ÏÀçgàýOxŸ ùþ>?‡qJgõàyj?qwguƒ"¡e‚'šÚæÚH(ÛB[&ÚÖ',[ Á› •a|:{MÔP‚uO®-Ò®ö~½{ƒRê÷ìƒs‘f«ÝÝ{Èw2^™2‹9Äîs áçÚŸ¿çPóîïoÙó=jø ä®=稂n'Ü·ç­ª$Ö}º3Ã{Þª<ýÓ[…ž öÚÊJøý€—…´n壟»çìùˆ®È’{N/ÖBåm(æï>Ïæg¨ñ»·ÚG5Ñ&ßF÷¼M~¦WíésØ-÷†pkû…çàv>}ÏÇVžêøvvÏé[ÎÏÑ=o•¾_âVe÷œêiß`žÞs9§‰k Ãs{Þ.ÿÊ…ðJíùž` jÑ[4²Žî^‹…¼¶X7¥%Iï™.éÔ>€Ý²»þ=—¦{w «{ŽÿÁ7.Ú'Ò˜ ½jhî'-ýŽ=_Ç!“ÓÇï´ Qò¼œÀ@öDs9q^´1/Fu1>ƒjÚ·”¾$vCÒƒ^@ïKàEtéS©?ñÄ`ލTf¬lé«÷\¶­©Â3ubŸÌˆ Û\¨‹¸ÿõ~Ÿ±äáRÀ›öœÇ ’<Ïïùú0O³aF@Jê;Hki{Í‘ûoÊœß'²£`û•/Ú7²ðpéÛ3÷ï¶d@íøž·HJmwÅzxŸ`Y°æÈKöœbÔ¦ŸÙ®+{Î%™ºZئ\ˆ$k?ÜwÂöÝB1öCû˜bt†àÛ^Ûl»m¬PK>úÚ»çÔÌ«‹trìƒå¸xâKZÖIÈ%êbÏX©®@ rç1!ê™ûà_—]_eÒOÀ¶ ï´’¸¿í:qG1ÚÿF¬û7håý“£>IÓ ðü¼Ÿèߣëuÿ¥åû?ßß!mô5«8æý[ôÑŽ>&ãÖŸïvã›×ßÜßÿUv†›?h‹þgÝ_8xõghDpdð+ÞŒE+‰¨‘ûKêÛ')ìSæÝüŽZpÜ ü×#Tîz‡º {Â^Ga¨¿úz ;|È#ð¦C\®wæàS¤ÚPž=&•êŽ.ûì»–P=Û 0¾‹—L( çú ¶Ò: åe¬<¥…¦°I Ãr§(lžÂð:Î…±$èÊNÜ[)îû´ú¿ŸÂ~Y«ë“ö› uWóÿPŸ‹~㊿¦tÿAaØŽß!¨þ'…Eß?wÿÛ„òæ¸ø‡§ ¿cþ§ãùÿì@ÍÞaÓO$ùþ[tý±æËôgʼnýOÅð´•úQ†Ö þñè·VêGÞþý±êon ëG,íMĤ•ïˆUs `[ÿ¼ÿ–ˆS¼õ[‰vâÖÿ(¼×]ÿ»QõDzÑrÿ‡÷qêEZ®ÿ ІF×kþuà(á:·þ/NÄ›©ÖÿVú¶ãÙ?‰GJ¸fÆ­}ØÄñ¿–Þ!þ×ÈÿˆQ*Þüï@™“¼¯þ?I¨µ9ºþXô¯åþÿ¼?¬•¸]‚’P—Ãg6á·æ€af-ûCB.§×ßÏ££Ï •îó€mb±m嗪(¸>4‡>}uþ+úÖ$¬„ºQÏ0@Nÿ8…%Š—æ‰-R áYî¾™÷E{ÉL¹ µÃ(R{÷FÙãU*㱄ºµÿ¥û¢„²½óÅön­¼o¥°QÞ<ý0…ý …a»x¯ó Ã~ý"Õû Åÿÿ¥ûZ?x¾™v*Øÿ[ÏìP0xQ‡¼ÇùÒÅÏ?‹Ò] 0Ä;´ËŽø–ïPV<^EéªZy¸C™x°ì¥û²«/§°¯×vmß@;´÷ìÐÞ×aâs´ýÓxü?òÓˆqéÚÞˆgugìü{Búh^ÿÎð?¸÷zg¬úãñ¿÷&$îÇ­½…ðæÉpOå·n~Ïï$ú‡óioe‘a Þ2݇>Ë?ìUGYþi÷„{?Èû£´¤áß>ø]úØñ:ÃVZöúôÐÔüz勵ýMÕÚ8ùña»\¸e»ql9ègRØ‹µt/¡°vûßî™/Z÷0¼ÏÀ5§C®u¸ÆáýÐNø< ïÓàý”w£CÚ¸zÞËð>„0ƒp»Cݽ} |ÿ;x +ÂçÿÀ» oÒ®ÂçYø¼ Ÿð–á]ƒ·Ò!yä…·ï7ÂûD‡”²^£ò¾>7éûãØßCªî/„ß?ŒíÞ¶ùÃÔú¯/¿äÓ>ýé õؕӽ>sÛkúcÞz÷Õ“ofX鞣ØŒ¾?»ÂØ"‡ÅåäÍÄ“?à­“Ó-Ô|¤CÚ`k^,ùCËü×­Šÿ‰¶¿¿3ò‡cÒA³ú³1ÏŸð-“Ä­ÿÙÒç>{=ÿü·Óî?zB¸£‹C?Ø£1J?½1ïH(‹˜ÏK¨9Å>~yþà)Ë‹(ì.-Œ-¶òÉ–Áø0JaßµoïÑýÐǾ×õþE¶ï×9XyÃM_þOÛs]«ýxä_6þº·3,È'Áž×Û­¿]ü‹¦?ñ䟹Dkç?‡bÒßì}6oÿ=¸Cë{ýÙ™óWhõï”ݼÏû\–šÒ|Ø' îØO0s1BÎi†ÂL(=—WSXƒÂpþ­SØfBɾ÷zÿeÞŸ?ôSïGS¸¾ùÏ^æõù/Wóvçïußø}öƒ®÷àfãÇüoOÂÏÿ"ñò¿HLþ7zý‰§€vâ'ñ÷wwÄ]ã¿£eà³-Ôÿ2¨ÿ‡b­¿ñøŸV×ßlÌýï`Lù?ÎÏV¼¨áYÁpÕäý¯Mˆ#ì9 /¡(B¿V‡!Å@‚“K¨}Ò8…ñ2Š€ÙŸ8Ÿ¢´˜ 3ÚðqyÞvªåkv½¿€J´¦IîÑÂÈåR¥XÝp.¯• õªS]nôWìÆååz~ÍÞ¨Ö¯^¾–îOö&‡Ó×לBµ^.-õËeËWØ ­°½¦?æ­íÏŒþ¡K»uùó:ý±~ù†µ&ÿÙ~+FïúŸÓg¸/L4硉_þ@öYÿðÙ¿ÿ\‡‡äyóžæ GZÈ\ îÙ™ƒ|E"Îéö^ë²ßó~÷[sŸbêÏa C‹Þ¬µÀž£ñâ™”†é=Ê3¼Þ¤ÌQßÑ„þìÌùç©y^OTýCñäo‚þ¢’GÜúÇ:¤ÍÒfõÆ”¿áê{¾…úÏvHŸðÍë'EqûX õß§­¿jž²¿„Þ„âìú(ìDBÑ{† k{| ¡4JSä"…1Wˆ¸Ä\¡òú²·ûÓ‚’ËAw=z;CF˜ÃYÆØ^ßäßo¨~ðGoÜðB®9Jö…æµDð}ªçú8ðÞ€üˆeûëvÔƒwŽ>=¨õáû‡ ùá3[ZdÞ¦•òâ€RÚ]¿¢éo<ýÔç(ŸþÌuH})|$œk¢íh³Ã‚Ýd^è°­ˆ°8õW’ÛŒ-ÿÓÒEû߉G­É?q/üòÃqêßýOÔi{ °v­½ÛÉÿÞoL ]ÿ‚/ò/8jÌۢϢt¼çÀYÏ{Ž{´t÷&¸õjF°6#NøñaŸƒ|Ÿ‰¹„ÿ¦pÔaùÏ3)S‡’ÿ PX¦CÉt/ö,­`Éêí µ3eßÍ–Ö6ä»ÚÖIHŒòʉ‘î2÷™ÕêæÉr2¾¥†ßß•p1/ÊËðïqˆOàSX&ËÙîM(®=Ga,{CIËÞî§0†‰îgùEnâÁ@ɰV–!±×Ëþ„ßë%îµØë%óŒç:æLÓ(/RB5apþ>Ø¡dæ¨Åƒôà :=øBÊË®Èi½™Â¾®CíñÞCaßÑ¡Úþö%ûn û…ážïÃTït(ÌFi¦ÿ C› )òã C?EyƒÂ¾'!=àó†Xó‡ö§†üóŸQØ_vè«øÓ©¥Xº¾¯í$(yÂrŒ«®fJ'…K(ùÖíe?iý …-¼Dìæý •P’Þ;(Œ÷Ñ8îì5¹1LãÝ#àXð½˜bû˜Ê\ÒÚ÷…-%Ô˜=HavBq‘ËÆ78±Ž×'ÔÞŸµé^¦•Ã÷XÓÿ9”/‘P¾yAœâµžg6Î8ž™÷héÎQ½L-±Nœ‘¸¼:¡öçSË»|ûs…ÂÒ”Ljo¬b›^—2‹/N¨ñø‚„ä¿$¡æÞ¤Âyó¥ E6©Ž/§0\ˆÙ£á ®RØWSbÕ›)ìíZ?>@ýý …a>Dé~0¡pù#ö#Z›ßA}û±„—OPyŸL(Jû”î×jžþ•÷‡Zy¬¡ÿi ¦IaÿšP«Ïÿ£°£ª¿O£ù÷ôµ}F·ÊKƒƒ˜ŸÕZŽÂX²©Ë§X§Ï×/× Ìáú… í9Ê÷ÖÓËÆ3±¤@aÕ„š_Ba_‘Põ•öUZºo cB;oõì/Íiœi{mÁØ+ÑDh?Ør ò „gçûQ†‚ói?X}Û¡Ûs¸[ŒÇUe7eÒÛm¹ÌõMøš›æ°øéH(žõˆÒM˜ŒÏ³4jûl cÝ ü|…Y µ~`Zä3kaÌ—0÷ŽÜsï÷R˜¸šàêï#Ýeý}–µ dî‚OÇpmàÓ±—j-Kha’o>VæýÊ—»9ãêoìœm·¿ùÖÕ_ AÞgËó©vqUñ`–V‡ºÍ®Ë¿x_¸úsͼΖîïe(¼˜p×QÞ!uk×CmJkéù›OLq6JaÌW ÇÂ|Å µ_¾Da—j¿Œ\%búkÜ‘až±Õù#-ŸDËÿâ¿·*úxÿ˜¾GË¿âÝ?G^ OâÖºêwÆ’¿íŒýçwHoÍëuþÖ»VêGnx½ÿ˜Ë–o‚°™÷JH?(Œ±ù»Ú^C›ß.Æ}#îAY‚x‹ÚGô¶Ó2S¾ß;ú[ÿ7‘_»ôóŸ§%õâø -Œï~±ô䮄’žÜ®…±œëŽ„ÚÙ°t…w°w$Ô6è”.•PkKåÙÄv‹°}l·hL«wœÂ¼û ½¯WiõÎSØZyLÇÊ µ£_£°/ÒÒ}1Õñ-ÝWQºo¦°÷'¤œ Ÿ%Ú¥ÿëûÎÆäÒ}›_‡}‹«*CïL¨äUZØ¥æÑ@úÿš„ÄÞe¶íçù³öW'_¢÷}þÜd„nÿ‡O¯Æÿ!†±<ç»Á^k?ð¦ï9Ô–ôö¸=ðÛ›¿ã‰÷ÿ†ž—{Êýº]+ïY.ý¸;/ €À  p{n€À ~8Èøîá3Ï{+fŠåˆç(GÄåjº –«1ÕÁt5 CÙ٣ƚªÈƒ³Å¸ CÊú: cY¢øõ„Ä –µ!déË›) ÛÉÒ—·kaHÅŽ´½~¶{?šÿˆ¯ÿˆ2¬¸üÇÒG0>Ñ÷?âéÿàšs²…ú_ÒÏþT&æýĘVN¿:fýC;dÿb²C­¡»á á§þe —þP~ ÷Ë^~ !ÏôO/ d+ïÏåMFü†táÛ¨¤÷%Ôü~åx?…!N¿…¾G«í)Œå×8ªl%äÇ) ññç(ì—DØÞÊ‚-Ç?ïï?| ÃWß?i¡Dã_<ûw¨Ù‹'qñ¯ø¢öç†vHÿ¡¡átýñö_xbÕJý}êþmtýñôO.µZBÚXh^¼ý7Ê,NÄ´Yt¬ñß™ý÷ë þ¿M4¯8æúƒò™Vê{G¼ûÃ1å/xFôšD ÷/êþÒ^–oòI/îÄ‘«Ò%ªÈ_z÷™XNšÒ±D©&Ÿ¥ké&æþÓ±>ÉÅ„¢®÷SºG´¼¯¡tú©é*…1'‡|ï£v°í|úú„Zk¾ˆÂ¾,¡Ö•/§°¯I(îîk)ì­ µKùF {'…íÄÀsïëæ©y½¼•`Âú·Ñø°6ŽËÇ)íÏRRΟ£|l÷L·¨Œ«ã ß¿ÄýkÏó-"ä¤Y/‡÷ ‡PYOs¿³ùµc:Dùa±[éd) ¬W§bˆ ˆs%ˆ¡Ì•𠋘Ìr}ÖoC })AOÒ ÿ­U]i0¡ö=C”÷Œ1š»'¿h¤ƒ¾)H¿òÁá? ‚ô­ZOª·ké¼z^(#G:‚8λu„¯¹„Úçòh±³K‹ãs¶ì€#Í–pÞx=š>Ú·jéíï$¨ó)Ž0k$Î%Ô®ÃXöé™z³fÌÝZûOSØÞÞ?É7Yvæþjwý³ èúãÝC{Ò­ÔÿÑ„´#Ù¼þxû/\« ‰øëïÂû÷±ê§Ý*üQ+î'h!05 x¿ø£ÚoûõwM_GŸ{ÎÛÅUÙ’8øÛþù¡zâÜ#ÃV£,þ ß^n/?øâß‚>CžÏp÷Úû²nýçýõÀHT럮µþV÷^ˆ~~~[BŸ7³8±·ž=Í»+ß™yóG¸§ÏK¨}7û˜Ð÷Ý̼@ë÷KÜ~Ço)×å•c,;fã:ÅÒgÖ[À:- Öž|½eKëE©JŽÂ/$ÔÚ÷* cÞ)ùýÆZ’ÌI±Ì'З'ü2ð—kpKR;yE®k„âø†rg|COGPBÄgUù„Ú/,QØrBI†V(ìªÖn> À~ѵbw¿ƒ0› °s %uš¦0ÖD~…uÿø&Ëñá›sw%ü7ç߸"B°·?A±¬?‰£÷ëö[ZØŸRëO"–àQ'ÎÇ¿ÕZ€:•HëÿNƒÌoS¯ÿAkÕRyŸM(H¡‰VÖxTÿ‰Ò=­CÉÓŸMénïPPû< {‰–î¥ÖCaؼA ý†·*»§;Ôn­.bߨÚ2ζ¶¼Ò¡¨)ZZÄþ–;§v7¥«SÆ¿žV/îP»É/¤¼¬³Žñl•ùM†r‡Â¾Fk3Z‹DŠðŽ5£¾‰Ò½‹ÂpµzÕÁo¥ïÆ:ð¾Õú> ~ßKa¬ïŽ0ø. ûHÛƒ|4çÈ!éiߟ·ÂÛ ïQ û<ø<†ö?é÷Cðù"´ÿ ï³á}¼ÏE—ð¾ÞÀûBxoƒwÞx_ ïKà})¼¼wÀÛïËà}Þ;©ì»à³ÞxïFûŸðöÂÛo?¼ð&)í«á3oÞAx‡à†÷¼'áwÞSðž†÷ ¼9Ê{>Çà‡wŠÂ¦ÏGàó>x_ oÞóð^wÞ9x/ÀûªCʦfÔ»3¿+~•òìäÍÆ»ÿôi¤\»š?(‘7}®gìo¡ 'Žÿ­1åo¸öã>1nýß³ïÚMqêßû_h{ýÝô©ãw&$eÀ5÷ýÆ6õoÓÒþ@BI-ÓC ö‘„’n *äy~5¡V´³ñS µæý|BR=^­R³þßH(¾äcÆ+®y?Da¿›P”šm™ðªfÁû™„¤Žÿ£õƒo tt¨UíQÂÏ£0äEºˆ²Þ¥Qôn ;®Qê^ KiéÒ6Ha(9¢:F: ŽQØé«3ö*­Ž•·ª…½–ÂØ_êÎSÞ%¹NaOh«Ú%Æq{…ái6ÊCñÓ<õB\Â;xšú8oLH]”‰"Žàé6ž¢} å{$‘0ðçØÛòÄçû7%¤ÌõxðìåM”þ[©ýxr‡sòÛáýŽ„ÄIäÑPC÷TÇ»òÄqo£ ¾Ð‡;O#ÿ7?:/‹Ü †%ññOíë¯@ÊÁ¼C4ÒÈ‘¿;¡f!ßÞüv†²z¾ÉÄ4è‹(÷—j¹X>ÿF­FÄÇ á¡ºÀOäz¾Q CüO(™=–÷-TÇ{´òÿžï¶LÆ#þ=˜P·Ÿÿaê)ßjBš÷ãöÑ„¢UHgNK(zóÓös %çüNjç/$ýbÿ$¿Ba¸ú#Êûç E3˜¦1§ŽZ,ÿDmáQ¸Gù{Ê˾MðûQþ[«÷3T^BãR‘^¾.!i%‡áÍ*\÷˜£Ç5áó àÏ¥0Ü_!'/°¢Cí#_H阖âÚñ›Tí…¡Œ6I´Šï £_Þ' w(úŸ£ò&;ÔÎä,å½OK7Ké4úÏ·<_­ÑföÍ÷0…áö cº‰xÊ~VÞNa(¯þšßFa¸Î½³ÃôÇ"ÖY*ïƒ ÿð–*Öõý†{ܧ¼?­…ýÕñKŒà®7IÍ…­%ü»U´” Ïðg4ÕéPrܵî‡=ë!:{8s÷Ÿ4 ×Åý¬cÍîŒþîXŒp7ºþáÿqî½/Výñô?pœñì9nýÿÚç>qêïÿo­…ú½CñÌRr‰’² Õ»=·Ãï“!]Þk[«~[8?öVƒœ¿©6=­%H)é-Ÿfâj̶Ùž®+¸2á:Â÷÷庂ßPêö›r­ûÝ%¡ú= ûC CNðSÄüQ‡âþ˜Âþ¬Cí£~™Ö¸?×ÖÑŸ¡µð/´uô¯iÿƒöOöo?ð û,…!?ùErŸä]1qÖU(¬žð¯¢Žšk¥íÂö~÷y`š%˜b /ü:)þ em˜ê…!7}3Õ¡œMÖ‹\¯¼‘¬n“Mkõ¿’ÂXÒœMø%Íz¶~LqéX{ÕþJ-ý(ŒuŸq÷È:™ÐÚüÝÆ’l3{óÓí p›QòÀ7£î/ñý"ܹðy.߀AîžoÀܧµå<…ñ‰¶Å{¢ÁmÁ²;ÇJrã‚Í'x#ˆi¹~‰ïSñØÝ¦Õ÷÷Q:Âc÷&-1k,a»Ycém 5㾃Úò] 5ãXÊóÁ¢”~¯@ˆ{K¿ý†xäìÚÛààh÷&”gÕuc=ævÚuÍh—Ò®š¯]lW@ÿÖܳίýtúŠsu¯µiä?ïh^Ús, Ö¿CÒ£ED#0L®4fOÎìyOü'°'Ý{>öa»R¤ÜïÛœuØ|Þoúƒd!é$,§hþ·O\¦xÑü8¼9ñí¤J¥ñxôOnú¡CG_ÿö+ò;ñÕ=î Cë«Äwuãž Ãb< åÃ;ïÔ‡¥OA}âúÑ$´£êƸðm>3â`7§'!çé´æ‰@¦üšè˜Åû AWÉËc|åÃßñv ã“ÿBžL—%mÿk™ëž·»åGæ1jÑ€~[B8`mRŽ,aÜÉU?kÉtÄ©_§½ø(~qêç¾>¤õUÑjŒÅÝÔ—…öÐô´k%öšK ²q„ðÜk;ý¦•cÜ=“?ºEЖ²àïŠ"¶L}ëƒ}H?Ž~ 1a¡2ÌíºdÄÔz™Öy&±6©$ö ŽÉÓ¦eįíGä—Y#Zî ç¶:6{mƒÉø:|+i·ðÂÐóÑw3UÓŸÃîSån/LjµÿðË?t‰k×ý'„YÐîH˜wÊ•P3° ê·&ütóÝ8†5ôø[ñŠ1œq8›NÃ^CW˜ÅðÄÑaì¦Ù£[+Ð-#)ûþ&$w†cÿ‰SÎ{¼С½(áû"^{›‰„º‚¶÷nHwÂ7O§xíãóSG>+e,˜eA6ùÙÞ&ÊUØÞ&¯1Xk² o(ÑL_úå!áøð!åÍ\éWÞ¦åÃ09vþùÛ•Pç‡|Wƒ¥8¯ey,ÅAÉKmt¬f›Å|§„ÃdLüž§_HÕxåÔÃQ½/ €ƒòÁãÉþ6žCa˜ë¹n}êäÑ«‰‹¸bQ[qÀÞó­»!-Ë’øf Ê¿î¥0–%!N±ŒhAËË8ÀZ¸8·ñö&R·×hy¢t¶–—í°–µtlÉe=¡hѵ„y‚x‹r*œ3_¯ÁåÍT/S!¼ûôJǧõHøÖÝ·$f|…µc?|>ñ%-¯â¹D]°Ò‘ê À×L‹+ö„¸Íüë2Ô'×›2­èHqPšüÁ¯¹WˆIãžàèk0 ¼¿ƒú©ktý,Áø—4xþ2åem+œÉ@a’Ptê)Œ5 pö±mÕÏ$Žzõ€ïNõ²Ö€àý;”ž/s­¼ïxN‡ŸçÒ̺S㪇)ŒOùqÜ¥•8ŽsŽ­cãÙ ÚñÀ¹Î·DWpEüz4¡d³6µm€`¶ZÄ6@ðEm¤T¹åézöLËT°5L¹c™¾±X_óXO¼+¡ kŽo¤Ï¯¥pþ?Aa<‡tûøßœÐWwù÷ÞX5?LO™êã'÷”ÃÂËÆu1—©®dlû–õí˦ /u†ö–œ§“ôÁ;JkH@uÆÎ‰e3DßIr‚™çÁyø}^ô'/8ûEH³±ê[ ¨Ñ’ 8%Ñ[žô !Š#hT?@¯$r¨TÑçÏñïÿ•cöŸÃ‡âÙ?8óþ?ÚC¾ÖBý¸Úüã ›×2Þýÿ–õð<ïÞŽ8õÇó¿ˆg”ˆwqëGIÌ?»¿.ߤhû¥›$õzø&EC¯PXþ&uvÏMrÖnRó}…ÂJ†°»JŒV…Âw½“½IQÆwÜDk¾VÇ×Rºo¡0䟿Úòí7)®ñÛ)ì;)ìVúŽaßu“Z£¾’Ú÷þ›Ïô#7IÚõã†g ßOmù ­-¢ò~’ÂNS9XÞÇnRëïÇo’²ŸÒêø ªã·´:~™êøm­Ž_ þþ®VÇÇ(ìÏnR¼Õ&}ÿKúD~³î Ãén’{„¾I­ñÿÚüì?Cuü6æKa7Ý,Ãû}:-UϾY­¿·Ò÷ÛnVmùë›Ì0„½Ey{´t¹›åXÍia¯¢°‹Z½É›e›ó7«¾õQyÅ›Õ;YŽÑU ËÁûº›%œ¿ôfÞïÀÚH龊ÂF›TÇ[( -®Q_«Õñu”÷m7+žà›o–ã÷­ï»Yòüï×¾ûfÉk|ÏÍj.|ˆÊû¾›çðÃ7K|ù±›ûC”î'nVcù^jóÏjý}µù´6‚òþ …YðþåýÛþGö§<¦ˆwöi VŸ¢:þ¯VÇ_Sÿ¤Áå¦[äþõæ[Oø¯”÷ù·¨¼/¸EæµnQóhàIS’·(¸do‘Õ…!|Ó$Ü8Iax?Bå¾EуӔ.w‹âß"ëš 0„ù$…»Eq/£¼¯ÔÚ|Õ±p‹šç¯¡tE-l…®jå]¢°Ú-Š|…½þÅ“~1µåKµòÞBaoÕàòÍ·HìÝZº÷ÜB2÷[Ô<'µù»oQxð=öÁ[ÔžìíÔ–kãöÿQØiýX§°ŸÒúñKÔ¾Ojmù- û} CÅÏPÞ¿ÑÚòö™[Ïú´[IæV5æÇ(ìé·*\{Æ­rýz&…¡ÞÅSyÏ¡0”<Ä/¥0”LÜAawSž#÷RØà­ ¯NPØ9-ì> {èV5Ï ·ÊÏÚ­ ¯½Ur±×) ¥yÊû¸–÷‹)ï[´¼_Cyߦå}=å}'…¡Ôâ=ö}Zy,ûÃ0æØòÒ«…†‘ŸK¼lðt¾ú¯¿#lZ2þóÃr ÄW¶™È'1ˆ¸'ÁõðªM_Hé¾KK÷ÓTkÀ#}û¥c s¬÷õˆ¸TÜï|PÁ'V߬…ñó»jý: û –îG)ì'Šã`O'×ÒáÍZœ5¿­¥û©„ÄÊßK(nêï(Ý¿Sžzñ.û?) {ô_ö¹„Zñ –w¸CÍ–Ïq{zJ9ʽ5ý½íð€(Ï(”áÑ®]Ê9í6O»p,÷ú\É´ü„<Á»¶áT§}ø¹j }¬;"Ûøù{µ:ä”;bÙ"¤ríúÁÛ)½e”çD¨âÓÎùó^(H©ûÞžyÞƒV)dk÷ßäË:l·ôZ- ¥‹ü0ëÃ~LK÷q ûU­¼OQy¿®¥cZ¿¯¥ûƒ=>ÅþÔõÇx±3ž›) ¥«l}Žåü¨[kQÃúÙDÍæÌ“ œýձŒc e„-põQZ„W.¡Vï…ñ™¶e’ÂØ2>Jwëp•çS§[é;†ñšŒg,l{œuŠqífù{ÔDz…ò>¦•÷…½žÂP.Æž@ØGò…l%„Ï]ð}µ™oDâùýwR^æ~°o?Fu|4¡x°¥tÌýèùF«o)"Ê7ºοNy“†è;†ñî[è;>Ì9a<šÃyÂ7qný)Å}ZËûi ûG CÙ÷/Ryÿª•‡ü"ŽÁ1â¦/Ø{-Å9‚¶H/îPýx&qb/íPåá qä©^Ö¡x.¼Íˆü:{<=Jß1Œoˆ#‹vEp<Ò ÿðÆ!âüh‡Â—Q ;Ó¡Æc˜Ê»§Cíîí²¶œVï=”n¼CyšêÐÒ½‚úËg*·Òw ;KaXööóy }ǰWv(®õ<…½Jkó…]ìPøòÕÁ·.1þr‡„ÏÃZû¡t¯ÑÚ÷ +RÎ㇨[Ë»Lé®RÒ‘2…9Z?lƒõ5·®QØf‡Ú·Ñ¡n™bXоcØ'µñø$…ý*…áz÷ Tǧ(ì^x–êøõ5·þ¸Ã¼ÑƒyÿŽð”oôtÒw ûg­ÍÿJ8þ_ü…%èöŒÐ‘8$Ãn>¤Æã_¨¼[©¼O£t|óæ(}ǰ§Rt-Úà8ß~HÑìÛ)ìņri´„ƒó÷%Z[,J×¥åí¢°îCjî¿„òöR;ÖçP[î>¤ð/My‡µzSÞÓ†ò¼U$æþ!…ÏÅsÿ6÷ɰs þ’ÆhúÂñiº¥tŸÖ ›;¤ÆòwiÌ_Ea(§0å2O‘ÚW:¤ð¥@åÕ´zkV§°±„´ÈƒOã—/§°7RkÏ)ìM†ýüZ‚éÛ)zõC²ŒïÕÆüC‡$,¾ŸÂïxï! ³ 0äÞC°ÿÈ!5§ˆêý‰Cj®~Õû3N¾ƒ`ð Ãï¿xHÒÕ_Öúö J÷+‡Ô¬hÓOSØÏjé~œòþÜaE#~„êýùÊv~„êý Ã=Àû©ŸÐ`õ ‚Á/V4âÛ¿ªÍ™ß¦°ß;¬èËïSØiaLåýéa5§ÿœÂ>­ùßPûþN›ƒIíûg ¯>Myÿå°¢M¿Nõþ›Ö¾ÏRXÇÕ–C¤ìx“v3…uQí;z„øí#jÝzÖÙ¾çPØ}ǰçQ4âùöÂ#ªÇŽÈ~ÜvDõãó¨ŽÛ¨9øjóK( yÖ^ÊÛDÍ…{È1?{DáÁY {%…á^rôˆÄƒóG´µ–Ú7{Dy?Õ1§õ·›ÚwAëÛËV ZÞ7‘p|ã…ão>"çç[) ÏO¾âˆLÿN ýé‘°øf C™ÜP?ÞEaxV¶Aýø6 Ã3‹uêÇ{)lÞ:µï;( eì«Ôh°ÿ…}…uÁûåýð5•êø?†ûÆORºßÖÚ÷STÞhuü¥ûc­Ž¤°?;¢ðô(ìŸ5œü û7 VÿNu|Fçß$aõ,>«FÒ9ýsoR¼Ïs)ì6íìþV:»¿ý&Õ#¤ð" C Òÿ¦¶¼DÓ‘ø+ ë¢0”iœ¤3ùÑ›_2v“¤G&t9©Þó7)¸ÌQØ«nR|SŽÚ2¯é\,PØE-ï«)¯˜sªn´VÆûJÆýÛ‰€u(|cðèûƒ!÷¶2ÙÁ!qw«¹>˯ඳû‘­Éù§Ô˜èÆvf<Ú‹KO©±WÜóä©Å 3íÊìk^ø©µÆûÇdO×øèû‡;ãõðŸG’ðèúãùoµ~Ô¤™8§þxþ_ð?Þ[?j”½3§þxþ/×­ù¿D­ŒÐ÷ƒýiÂ4$ùTã·wVNþTãK—v…/ÝÚXÌ>¥ÆÂ4¬»sr'ûX¸vAØ‹r•¦ð¡g×ÏÖÎ…QyÏqÏ€£Z¦mçþ~>˜P«okö½ù[ï?æ_Ôê÷÷_Çbœi±Ä›_þ?-dþûÝü­Š˜¸ÅÑö3û#eð£ì†lÕþ ޶­Æè=À‡½’…çÖû›×RÇí¿|þoÇÖÛÿqúÜÚý¶õ7vƒKÃ8û•?µöŸæXì܉e¦ùÞíàÙû'71»0 þì\Ix†“Iù9”5>éI¤RÙTvp0“„t©ÔðP&a5ßýnóî4òuËJlT×v=<]³ø'飯mùJ½Þ¿ºuàyÆ]ÿT:•‘ãŸNg³C@ÐR™ô`*a5·¾µ ÏS|ü_VZ®íeë\îþÉ+3SWæç¯œ;vôeTªØžP/U åõ¢muå‹GàK†Wòk¶SËl QÉ:vôñcG;këKåRÁªCé…rÞq,Q5bÍÛNu½^°çíBµ^´DÚzéZ¾aXXZgçÄÜLnzöÊlnfòk ê‚òG1âþj©h]¬!í<üÉw÷ŒŠ²®L"jážrÎÚYÅŠÂT¨‘ºbo` L¹Ð¨—*+X࣡ç^¬Žç+ÕJ©/S°¨þk¼\­p=€a „Ùm(,_wl3°;_¯ç7Om6ì3XÅêZ¾TÁVôZ§+ÔU¯_il֌߶2 “¶²ŠD])Û•^Ë(êªÝèµ /”ç@Ãh¬Ñc€§·ñu»Ù9Ñÿˆ|7ĸ;zC •])––›#ëÁ³í¢ÿµF't¡VÛî:šÐÿÌ ðŠDÿSƒHÿ³ðÿ€þïÆ£(: A\Ù ‹ó@ÛFFägw!íî$¢d¶`X|ð¤H2JQ’ö‹¸ñó¹……‘‘éYw¡QtâV @n-þåôRúNA.$éåÖç’L ^¬¸-Œ¬ªXé;kìXBêí¬ÛõzE5Á¨‰›rVkŠ‚ŽÈiqDßmie¹´–á+W.€£kë Ñùz#’ž³óE»N ¥¨ã§µÕ²¥5HTÜÒ²Õ}‡X00 ¯.Hµ%¦[Uí¶ïÌy»²ÒX•­´ËŽ­Êè;ËDé1»[üêm’[P#Éxµ¶¹X¥B’fwCúi¬ß^lé;3“¿j{øêFÅ®G5GY¯j·fŠxÖë.dy¾‰ETß5çè›)šQÔT¡À&@<üõ”É“•¿êÑÚ$ DfNÙ+ ?Äè¿ßø"ï襬ÒD4ò7Öjâ·ˆ…Øù2TCˆ(³ªŒS#@¥ÜN›9´AëfÛcŽ'5[‹¤È„(ª^]» ÀÐÍÐÐ ÑË=2› S`ùž\FSÁÒC[ü²}¥w§hˆÎtc*ð5Á¹(v5ne^º~c¯×ö8âÿêu§´²#"€&üßP&9ìÙÿg!ô€ÿÛ‡÷ÿˆWÄv~~aú¬O âݨ0I€ …À«öf4C9p·…ôÆšž\œêŸ›?kÍO[Ùd&‹‘–e-®ÚÖüDn1g-WëV¾b‰úá¯U¨Vœ’Óp¬ê²•·ÒVµÐ°Ö".ˆãÕkvÝ.ZË%»\/JJQŠ\y¥Z/5V×Üh7ê|~ ˜ž¥ð¹zi¥TÉ—e‹ÏûS,”V*y ¶5y½VªÃv¸Z‰H% š®ìš™{qŸ½i5ò+½Vº¹ìú]Ž…<Ž›¶RÄHQª\DöèŸTÀ¿tÀ¿Œ•‘…$E‚ ôaв†­ÖÉVÂD!ÇûÚü'Jy‚û`Œ±z ^­›žÆïD[|ãŠÀ“ÐgÚˆ’{Þ…ô»ÛœQ‹ù£®ÐÑ‘Ï@¼¶TóÔ,e I]Íž˜m‰—íiKd)j¼Û)%v[¶.ÇŽÞ= I‘5‰µ\ð„ÖÌ L­W ˆÓŽ)…æœÄß“`eÐHÁˆ€yäÐz g ©,6{%wþìÜüôâ¹,Æ%wžBT¸'“— q³‚HâèÉM"M™6µr9˜¼uódÓc(=l`§á-ÂEE—ð§GÚÉѱ£{½zÒ>jÿ_ÀI³#'@MÏÒIíü'‹ûÿôÐðÁþ7µcwÇ?hÃ~ìèãÌ»q¤(R`Fß"OD¢fç@šT^xþ`P¯Bc­F$CœKˆæÓ¹ Ýñ¦ƒZ žÓ=k¬# ,§…3 ornJÌS ï “‚ ô`<ð€©rºäìç7Ê/¨³²Éø SºrÇ‹žª¡ÙñUì¬B«§Wª ç:…:Ôáju xvTóhGM#êÞÞï¨qßîƒ 5öûæÑý–ŽwfIžá”9x|U|+=*OŒ£•x»{TÉ.irÖã¥MU}¾†V`Üq‹}â㙢mWhÒÛ'Å™þç?vc/ô?“Ãé!àÿ2ƒƒÃƒCÉ´Ðÿ̤ô?wå <ÿ™\ÔÏ¢ŒóŸrYqëÌjKñŽ ›NÃ^ U) ’¸Ù ¡jÊÓ$%öLUÜÄÚÄR˜²7ÛÐÒÌ‹þY^wÅvã)Q+Ï-ãNZ ßàGKî%3-"‘2šj½áð `ì†då|B’èôf2 %©J¹Åí°šÿ•u9Û¯Ølÿ744äÕÿKìÿvçQó˜Ç?j"cm_o„OçÙ‹çÏ‹µ•¾Dî1M³ÍaçDØ~,ÕãÆ?”|˜x°hA·u0›0Ÿ‡õ¬Šnò§ü-jq7xø£•õÍ`'ÐÖnÂÝÙumní!Œ¦¸ =K Þ»›(?tdƒõÊj¡ÌéÝ}ú6Ṳ¹íñlír ãÓÓ“•Bµ(’å•~¥ãnn¶ªÉ˜—;w™]ô-ÎnÐmu›ÊŒ~XFîü½É}Ào¢ŸHÍÖ îÙKº Ì­¤;å<{¾ÝÞG†ÎØ&8©eçÉÓæ¾S¡í~Ývª¡âÛlÓ) "Ó… ºŒmewéf‰±¹tÓ†î-ýƒîB†T@ä˜ó¦SßsrY½É^ON·r&Þî^ÓÀÇ(Öê®Ç)ö.Óœ»íV·ƒš…Šÿ“˜qQc›wÍîÿ Ãf÷™lrp(3„ü_6=xÀÿíÆcÜÿ;=ZkzDlú˜Èñj¹lË3>äq€V• L¥¸F¨Íá’ñ+¶SÈÃã ¶“Ôši\1ìôÑX¾]¨m!5½ë˜y ê¿Z´–øqƒõxï‘¿¦5 vœx;^]wñ½º"A7&õWhž§û#Pú×½^§ÃEËY…M«¥•$êÕJ`V×s^o¨5Ĉ™·¯Ù0LAÕž·—ã«Õš®N0íL>º»d#a>m¤XX_’KÞÄú’Õx—ß ·¢¨™|£°ú@©\,ä0’nP¨[bçtÖv»~ÍÛ8Ža°íÖ tФ”á™?æH©ãýÎÎó%X t Y¨•KîYˆ{ ÞÆI¸Wþ·×ÿšê&ý̤á?Êÿ†îÿíÊ£öÿ$ÿ ¿þGR(’®Q`'dò0~^!]w2àØLÎ*2D>§oÕD5§WkÔµ­yŒúIT€I¥¨@näFœ÷rniîv¾÷ŠßrËb·ô‚ô˜>+eëï.ÃOæ…¹Û”Þ³Ë×…›HøJ´3@ùî’ƒX%딥µoÔ:~¼¤ŒàùPéamƒxÚ­¼“·Þ}gp`dÊ×|»nlõŽe¥M†KJz¶ÕÄk]0·öT‹GÐêVF`!ªïläk5Xâ ‡õuÛœTOò£Ýjµ\äÝäñ4¢scµTÜeêxèÖ²œ‡~HDñJQE Gçãàúˆî´sÞvv<õp/PÆÀG6W6âG)Xþâ`ÈoD'l¥žÊ?h‚ÐßJ__(v{†%ðð] Š{TÚ"Æ:%X¹½HK0aßdk¢Å…ÙmOµ wTȾ3~á=àKÝÎ_ (pfÊW 4ô°ÕÅ9âˆå-T;^ÜZ¹ s9©ØVçÇük«À³þ6Μm«Äù€çÛ)ñÂ⼯×î…¿­ynzvjÎßNÜVçE¹¾î·]ì%™—Ú)PhúúÊtõ·ZììÂäxÀtŸo·ÐL`©™Š (xîÂâH“ºs#Að…O,† Eë ”-…/^âv1•Љ2_´—óëååX\­W7,§ºf[v½^­XÖö]uÛªÕ«XÔP&€±UüÖXÍ7¬ ¶Å•»°§«Õp#º ¬¨,¯!J“¼ÏäuVà’/VDǦÕVXhUùK›;º¨é´€…¬c-œÓòÊæG€ `âi|g¸ÑõT§/¤ò,ãò–yàùPS™rÞŒÂZg35¹0£Ôbõ’{Ë@TÌÜ­§îÇu>™]÷Š8—]äÄ xžAܫƵ)––˜{:£<ÇÝ <§z*Ü<:“{´öDòÆûV/HíÿùïnŸÿ§’ÙÁ4éÿdÓÙ´ÿ¦²òß]y‚ïq‡ ngIÛ&DB0p7ü]-0ÇZÍ_³ÅfõJÕšU¶¯Ùe¼Ë½$ßY…õÅZ²ËÕ ºÌÂO o*kÿ1ï"ã´ee,+kYƒ–5dYÖu²Núc1Ïñ¾¾Öþc¦fC½Ï˜©Õ›Œ™„¼:4Ó–š·€bŠÝ¨I@îRŸÂnk?±÷ ŸŸ8?9{vñܶÕ°ÒÖBÐ…°¡ÏÀ×qQ.rLü˜R:Äee‘c±.7«Ëß•‚Iü;ާ×ìº`ª‰{ƒÕ›t²²¾&4qb£´–P,Q*öò±yÌÌ’Wy•Þ¡‘u4˜Ãá!= “ÐbìX¸>Q‰ »B§d¢Un€¬yz¡š¤2ë’ÕdϨ50ÜÎV…½¡}!U.êÈka¬Œi”ÍV„ê5•4¨vÝå§îé ¹b±[KÕ]¬kÕúÕ¹:"T·{ÖÃZ ==>þÏ× Ùñí¨Q¢NŒ*pévª"ŽÇ«+»]],êš@ñê>¦ñûãâ½ØN‰ŸæÅSÑœJÚ>ƒwSšZ™‘Ñ踗@ÌÎ+áî­6ç=  :ÍÄÁ=h¢T700[E½ÖâjɱE×”ûw1iësÔmA»¾¥Šdÿ`k‰éËu¨tC ¼5¼`¿(:Wvª•Ÿ+`~!¨º6z¡„²5‡¸áôŠ ÏŽ´„3޳²œ<ð“ÖôÄäìâôxîõ´Àsš–0•„šŒ5ÔŸ¹¤‘ºëæ;qƒ~ûÂÒ†¸k­Ta—yŒ$‘¢Ú¥ ¬;ï ˜¶îPA†@KM…€¼O'Â[¤—@å×·(ϼª902&¼Öº91„y*¦vÓÒÊ}N˜–Ú:ès°ïÌ4*PÌ-ws‰£Œ‰"ñi«/qm%JËJMà‡ ¨‡M}>lLjXÕ€–ãG³ß†Â ‘cŠ.pI.Ì)37¯U–Tû ¶iH=èä¨Rá³®afÅ»ãU5RÒ {ø sCe 2öúi­,â‚@4Y·!€¸ÍÛkÕkvð¼èê.Y‘ˆÉFÌpˆÉæä˜1 ÃþèØ½œ¯­èDº¸¦æqþá¦hQÍÑÍyÜ*z¥É4ð¡¾~õY¸“ê¾Åí:ÈÐ*ÓIm“•¢¯Œ}È›5—x¹B†%4§"y™‡¨ÄÃfâÌÃÛ4,„!Í¡tB- Ít`ƒq-ˆ”»Ë±±”†žA6ª|™PuKÓ¼³©ˆ †xUºŒy/ @ù.WªJŽŸÖÓ I¥ŽZõÇIm~Õ¦„–àÉ$‡Icá7Ôw©ã€ÓL¼µÞ·Q:áv5<Ç\.‰eQ‘Ü^l[Åž‘Š]¿7{t¦àÊFµ1ö2v,’b$<¢Sòiy<ÔÕÕãÃvöã!S¿ï”©½+1·v ÂêÏ3„sYMã8úðŒ‰ÛÄi{õÖtwÁ‹ŸÇ­®ž.ÿÀùÎÞ丩ñóœr™tˆ›g^¼¹IöîÌ‹…á~æ½[ÏîGSE‰4Y€aáWæi5QјØò‚t!Ѓ/A¥gíA€¶ÄIl½»‡¦Ûª’gSFÆ4V? /–ÿ†ÖãXgŠÂ—GÚíÒ¹ýz¨ÈsàïP‘7×øO•̽¸Ú{ègŒÆ´—qâHD˜×µ³³v¯Ÿy+5¥8\°µ¾”,_qÓ¤V, ˜1ETZ~W¸…¦mç=·wZäžî”‰:0®¥bÆKXCAMÎ’ot ”2”‚X©Ø¶Óµ(;Ä̹–š•Œ ãÎxpªuV‰µ1  8¬×4ìÌí`\Ö¬çk“"‚{iõŒ‹f\ì5c©m³²Ýw&¤ÎðOÿµB­^}m®l_Ÿ°«jM|ï_wÚ8ûhbÿ3=84Lç?ÙtÃÓÉäàÿŸ]yNÝs}­l]“TôtWª?ÙeÙä·át×¥J±ºáô¥Òƒé®{Î;zêþ’³ž//4Ö‹¥êE@Š) Š€­kì‚ð`}ºK¦±ÆïÂM3—}²?™Ä€…ÕêF®\ÆœÎé.!Ã`(½ó¦åÒʺô+ë`'LÜ$œîš°—ÖWž€&fÒ]"X$ï<%¬à•L¡ ÓÙ9^][ƒíîé.™°ó ;Q‚iרÖ7ÝJ˜«¯¬¯Ù•†ãFä|aUk.<¢¢».{¡PÓ5àwÊø=¹KΟ¼41¹pßâÜ#·‰çÚÅzÙý}abìB¾±êþ^xÕyY¿( œ¬\+Õ«lzPØŒ]_&àRçéÂT9­ZwóÌ\˜ž_¯x›$Cý°‘á¡0ÍÕäýE=o‰Z”¿Ø…ÕÒZ@r46+…?p &)‡Hü0(§æí²wì¬:Àª–±Ê„ÔëÔ@½<³eÔúúo3vãzc»ëh¶þ§†¤ÿ‡ôðpvPøÈ §Öÿ]yNoÓsì(šü™xp673=nŸž½þŒÍçæ´F¤ ±Ö0×JöƱ£ÛW÷±£0ç(=–¯­Õ¼cêv¾aå%aQûÄùóB¾Y]ï·,Ì!¬X,㦎.Ú;VÞrÖ2Ô7Q«vïÒCrt P†„aÑBXº [Ì, `;º–¿j[ë5ÌP—5æŸ5þZK4 äˆ¢P¸€ö1„D£°±÷ š޵‚Ž2D·¤y¶|ÅÒ(%»ßoɧª[¥Š´¹†©ØN€Í<vF1lÒ‚€ª‰»)í È¢ƒ‹«•ó wz±b ʬnß``ÖaŸj96º*6JU,AÐ#x…Z-r8ºd|[«²¬j¼c-¥E>ëÚ09޽¶TÞœ†^Êaù¦< Õ5+߀}æÒ:ÞÃQZfyySŒåµÖìF…¢Äí|Ž××+°¸;#&毣”®Å¹‰¹‘.´k"Œv ÝØO7”í '!l=vÔY­®—‹V¾XÄLÐ!ÙMØäïDó÷šà<Æ£ùª8W «ùº#„(Û骹ÿß$ûNe’°þ¦3ëÿn<þŸà?—›_XœŸž=âÊ—¦׿ì×Éï²É(ÖðÚä|ªŽ3ü6™%°"3Ððå÷Á4çaeªÓQœL%/µùcÍ69щ=5ù2Ûjúpòú jÏó¯|4û¿µZ½°8ÖŒÿϦÓ^þ?uàÿ{wžk¦T¨WêrCç èšus õR Ͳã2®ù ¢xÒw½†_XX¼81=we~2717{þÁ+ ÎŒÍ_ØžâeëÒ‡ù.V p›¬¬”KΪÕ}±¡¿Ç…“#•…¶½>QçtÅUøÃý‰œwÆi¹TÇë€uÉP—«x;pzMÛ­ÛÖ’]¨¢¹>mWb•DaÇŽžÏÍž½˜;;iìEkË/«Õó+kyÁ!^©åWìnÿö;šÒŒ»NÏͺ?ºv@iJËÆ`LÏÞ?wßäÄNAdqòÒâôìøù‹“ ˜”ˆ›½±É³Ó³r' ¡ëe”F‹0ñmrv3§£2+¬ïÊ/_‡¢é».×/W‚JÊD•¤'”´[˜Ì€Û¶CNþã•·ê¬KQ–밉­ˆŸŒ;úy·ŸN耆T °÷š"ïÿðˆ @Û^G3ÿ¯éa×þW6;$ì føÿ]yüü?:š¹2?Ìøk‘: ûf÷ýÌ>ex¬?l¿°Ýéê6<‚BŠºb±ôßµ½U@Ì3ÿ2öéi5 _>ùÝÃùs¨––³{“ÖÄíS£L6²òêì;%½±FçB” ¢:¥<û¿ljø€þïÆŒC”˜ º{À©Q¶ìiŽ‘Àé|¤bá¾S³ ¥e˜ÞF2y¦¯Û( FîÏ~tÝ®4Ê›2ÿÒºŒ,¬æ++ÂàšJ!f:mGª•‚- À^ÃìÓ£æű {âÿ &~Ö{ÿ?•9˜ÿ»ò(ŽÇ?Âl'yU”îÙi¼\ÖÇT£j6Àz]r0¬›ºuã-ûzƒ\Âë-`ïë+’2ï P©‚[sK[0J3j¬è¶ëµRÑTeÑ,:¼+¥÷a¬ÔXË׺Ãôê—¤Ñ,y kI¤5o›œ;—ÖÕðeNú=’ÚýÒšºÆÌ¥Sõ|óÍ4j¾tK ÕÑʤý/=f_ѯtº¶5]­d¨îŠr¸œ¤¤.žE¯å¯_Ùꊪqë^†^©ƒdž£R,P¿ðk ]©P ÷&(¬×Í{úXd觬“ʦyš¥"®@§"aÂÕ™· ;âã¡]÷’)xÂòE-ß]Îî^)?.<¿wR4*´Ûß¼7¿²¯*m–Avå·*‹®Ë :ª‘‘ÕPªî|"Œ¤¬â>¥‚­ºÙ:ä²v÷Zd§q-RÜÝS E º}#¬“ÈÙÚ›ìõÞ”o}È伕56ƒ¯ºAŽ-4Úeã¥ÓœC` 9}ÓQjÕÝmM¡'ó’hHÕâ©|÷€Ì$o_`ý¨sîtÎÐ(I¤Q£˜3§2sn•ÝpKÐGîT: —·ô[SNÑaLeSø•9ìûFöâOûP—è ¬†+•jåÊcv½zm ó@—zeJq)YÜßMY,Ó¶TgB_:tY·W1óa-å‘»¸—\Vôt˜WBCªÝ\0ðÄ t”›O‹Œãz ©Ý ºÎ/ì%u=D˜qü8ÞWˆ0Н~¨yL—¨½½”‡Ag“ªéøqF ¼SˆÂs>p—xïYçô…\ø"B›þÝ“ËsmÖˆåëx>“Í1Œð-d%óçkõÉfÜeòpž¥*¥Á‘3j$•{È$‚>ÉÚ¡§´öÂo M&N {Gn9€t¯}Ž0êºéÐŽm …%¡™ÇNpòI…3ô•Sq€†„~Úš$+â0Œ‘ÒG;Oh7/õÊ›u§Õ¼ž²NêF*ÑÓãæÓ2ºn‡ñê"ßk»5ÐÞm¥‡zàÀt·u§}‰/aiH¬¾Üp‘[~¡Rd ¬ö]æ˜(¾ÎËzËð"àñÚµ8,­y˜Pµ†¢5ßZ‡A̳Ң،ý6ûçµÙÀ]r%›¾iä]ÇÜÎ3Gåf;~Ú3•« í‚²ÍƉ^Œ‚–‘5%ÌÕO‘u±H_7Ë%»®µY·ãaÈAÝd ¬ÕcÉÁHÞYš a½ ²eÏ—0ã@&ظtX¤›ã"S~¾RÐÇM” ±¯`N-µRˆ)Ųpë”*>ÀÒ¹w©(û)¹À‹ôAkŽÆøGM0„ ÐÖ)‚²yigÙy`©2G[y(»÷Ø+ÔxÐ[[j¥ž\ØKøŒ£WƵZðeºØÂöZjw7zŒ]–n/Ôa–Iž¼ÆÒý¢‡`óçQÕH£mñƒš !­²A­p“˜æ"\IÐ(µ5Â`D ‹Á&#šÙŒàx&LÄÉ£–«r£¯á‚P°+› |ï¡—"ûíÈ/h±pÓ†mÃ8Ǻ„¡,4Édt+ÆÍUžæÍUbÆ5®ÁÌc6\m ›Z÷›%@Ëšép2bšXTúÛ~—_ïÑHÏ%~F} YÌ+ûæbÙê5zÆÆØ—öM2×nu»mÛuþ³†÷zvD¨™þOfxЫÿ3<œ<8ÿÙÇÐÿ™™žš ÒýÑ#ÚÕûᲚ*þàÔ3ÎcæR–—„]3bR‹ˆ¡Ä-`•{½(tõ&K ‰4bYó‡ó˜çGö†Z€8ådÓ”AŠB"·ÁŽê=y’*I†}—TˆÔ‡‚Mÿsg”?1èF馅þÄÐÿÝxô?Õ?·KósgÕ>5OüJ„ŠÕ0¥÷“pUPJ®Ô@syvÙUQOë•D=þIEâüþ~Lý¯ÌŽ(€EÓÿt2™õùI§èÿ®<¦þW¦‰n|3®X¦™p‘h”"Ãô¿,Ô«jH×ë\ÞYµ‹s(퉴W(Êó`Êô|‘†å£<]ªÆ.øk´¶ q†Oß‘š/> ƒT®Ç‚-ˆøzHBOxo@)˜ß &Àx³¹šcæªÜ©À¦àu.·pîJîüÙ¹ùéÅs3æ0c™¹òJµ^j¬úKç!& îfnO=ÊÕ4c5q4ힸM›«5æÖSåüŠéCaX4iºxhæû& Z¢×òe£.úÝÙ)+=mÉÏ'D忀›)°yS“c4D´ÎýŸnØdËÅ7.**ªsZT¾Þ= ¾F®I›·4œb,äËÖÉæ2§ i ˆ¶x©€Æèb*ßÔ—ÁóÝñ5Ö~Ùjšäø£7 =ÍlGï¡HÛÊtöô¶UW¿1jcMׯ?ʤ¼*¾Ç´ÃÝ@ÍÙÅÙ±€ 1óüG×›5Ôf :4ך½ñéÌ6W™Ö˜©0¦j¤.¤-ÛLY¶u]Ù0UÙ(MÙØŠ².’˜j²†–¬OI¶…Ë-©È¶¦!«9ëØ‚~l«ê±7x΄+Çztcc©ÆºÄ«™b¬®;¥ÛÊ(mQ+ÖÕ8kªë׈US;P6Z6JVvɧ GVfmª«éÁJŒV´`›*ÁŽm·l,õtÌT<£ªMÊ¿M°cq`C)ýW¿úëX„úë †¸GùU×}½Â’¿„µWw Ò{€Ý‚Ö«WéµÙBäUyõ;XÒ^ }WÏÂnÌUݘ_ÛÕ¨Ö/RÄÒu%ÜC´T…ø4])Õ¶è¹F«¹rM- Wru³mƒŠ«_±µSéØk·F»Á‰â½4[]>Üà#ȺW™Õ]¿‚)Š_•UÓd3Ô‡B6¥ºšD¦¹g¦Ñ€iXV…¡(è׿‹rŠ$¼›öˆMúV²‹êV2ªcó܉æbõœ}±á&¬i¶1XP2éÉŠpDâ‘}ÈÜ‘J‚͵$å<Ú‚Ž¤¿Õ.C2+<’hÕÈ JΊ‘‘]S‹Ü¢l$ÔÍž¤ÃCË·BŸÌ¤/m·½ ´!wÓéÂ7•wøõ !BF­5~„†2µŸWÓÖb©çìr r&²´Ì+&ïd[wØ£M·Pu’Z§ý}\õI8Òµ€lJ\BœÚùrÝСæ©Fö;©Ò…c`¾ðA ’«F7;ª¬–{ aöãÆº܆g<ÉôeÅã0N%ñkýföƒ›8’èºOÁ† T0„¦ô’“„ÊÝšHµìçpq„ø[:¥.ßS{CÈeâ)9–ÛµcÁÚ—™}«áìE|<‹ç{™S¥ë,€E„NŠoEY剡ά›3,ØÑ™Jí;Wñ¬ô‰L©åß6HŒÂµ3%U1RhÛéàL_ª4©•jöî¨@’WMïÛ?‰´lÑÊÓÇSºú´?›Ñuqp`jQßÐZ­·õ8]jÚw}𞆶ָúì1ÔÙ[Ñf7z¨Í®)³3aˆÜ¥mE½<Ó²:»¶~·]á“X¡ýàiéÑôÿ¶æWì]·ÿ”Mg‡ØþS&9œ!ûOƒú?»ñ(ýÿõŸ™dd„¾¨}ÂÚª»¬Pœ!NzÕºí0Ó­I9X¦U.‰sgCc„æç³2äzc¹‘ÍàØbQþóåÀèy{ªµëvQˆ.BDÒ=–'ñü¼`Sëž gíÊüü„]¶W€ †Æ{ë€lH·}ùhMˆÌ)°7#ÑöÐŒ&ÍwôÃ7r̰;˜Ä:?Z,Q•”¯ø‚*Ž?U]ùóº˜_0ÍÆ/¹Ðë!v¥èþ¦ `9vw—*H1¼¼€dÄêzw£l×ʃ‚Ö£«RÏòp~­±ÿûÇ1ÁÀ€Åûâ²å¬×jÀÛò¬ ^Ç™ÎSt>0ˆjØB|kUŒîØ*’¦ÑtuÑ$±ZðÀlEïP²´=¡¹¶%õ0‡»Ý%Ÿà6×·»äT²Gáµ1hÒIJ€ —C¦ö´)¹©óJß™¢y„ïª6g+ß7ŽyíweÊ"¤à¨ÒÕ—2Žý«õêU6y½K¢ëë®Éz½Z±¬õÊRYIð!üéXÅŒØ5œ V¾ážn[]°!òŠà"ºÐß,îÕ5tË#[ØßÅgnš:n{tUlxâô!Þ¥dtÎí‰äÛ5ü¡þÈ=ÍGÚß­ @¶µ-pé½<ù|tÕµz5/©½‹ªn"jòÊêAÍl‹´-AiUh²ð4'îÉÕ:¯ãK;8ë"­õÄV·*Dé&>9ÐySÏÏO; ¼ÐvS}±`•«X6‚˪ ëu b9xôöز ùÅŠZÒùÌn#ï¿Ý€Cv’á‚nM!ð1 †"ºÜPáCø˜ NC˜LE ¼G?‰ØrYðcŸ^\@‰².#£%NM4]æá5Á FN‚¤]ü`!êŽS.É•6¯)´ŽL:¼Ž¬ü¥³ÚÙ•ªT7zºáÇ)U´€›B½•¼µTZ¹«Z¾Kĺµ¼^DãVlIÇ꥕ՆàKqš»§$¿Ú/»„¼rÐq+Ã#\îåÁì•VfªzµžpÓ%.Ix½nöOí$æ„v—[§î¼IÚkêþ¤âHHøN‘pÌ­§T÷­«¶]³Vªèô€dÌ@’ɯ-ª©¤Lqý€lÍýJ6èã} ¤.i‹M %" ¼öæŠî«”êväÅF%r×Åí£ž( #£-à€Û+t ‹è7:ê¡ðKKá{¿,lmµï ·3äêä–TuœÒ/B—¶ÇWSv›jâÍTêîñ×4´]5©55¼²ÛU™† áµ¥’Aƒïî°¡¨ «wpäE+µvÞAb7ÕC¥‡¨YrÚâKºÆ%‡‘šµÓL ĪðØí!fï´ «ê# -‚{èEŠàr*Çnì‹>}Ñ{éî[%M í¯5Cº¬î—^ûú¬¸Î&˜"Þ^#÷£§ãN³ìš%Œ¹ ‹&G$!ÛY̶´¨¹¼Œ×ž¶l°R‚I…!zöK'¢ïyxÝuvßê¤bx¥ˆ÷œûR§Ô ÓyxûÎLÖäúܲvO‹Z®”71çîvçqm~º‡ÀA†‡»u˜¸ÀÐÀ ú¯u<ÀR®¦hê‡lªkö*Däa³¥¶bê­Tñ4œàr©Œ’dà Ùµ ·;x3åöR¿²¾E$’gÓ&ù• Ü¡IϨó0Õý¶bÍ4AMm (@Çò˜Ï}r ëlªé/Ôb\ÀÅ;ï˜JË;޽‹©8ƒ…Ñ*ä+bZÎ×WìzÀö ZUö×vñ…„ µ34¡ò† ûÏs¤¿ç0Ü$Ⱥ véš­Ôª¦/LVŠPŒ‹ræ¹­ã=¡ŠïV€Ì0›E5CrmÝ—œ^&»xa¿"€CJHdÀ/ìu·ð$*ð_®W×dQ²à*~ß(9P‚㬯A»Ä€ÄçæL¡b3nît7×i [ ìÚ.ä7ËÕ|qÙšš»O¹ƒ©´9+dtà®ÝÈËC!@bbúuŠ'„ 38Ý…*Ä#–#>ÝJep7M²©üZ©¼922Ä…öž½”é×ÈÈΛ^ëB½Ú¨ªex±H¦/;eéòòƒø:' Žþã¼}Í.ÃD¯JîAB•‘‘y‰Û‹rN÷º“›…3ú¦ÎÖª:+Eà# “{õY ¤~î¬á\T™ qN!RáRT©2+ÝMàŸ½É^–šôz²Hþ¼oV-‚Kœ±ìëÆ>£PEÑøº-ìV ? ‹ ¹SáîÀjî¨É+—,î´rÇæ?4t4Ržrò#¨@2—tŒn(»äÜ”,›œvS¼¼oì+Ë×ðʲjv˜ú¡Z`\ýÌ‘CÉzŒÂC—æäÔ)%.JT3t0»ïÌ…]²ë WÎÔ‹ó¨fºÊà€Bˆ!ÔËðhir¬i÷) À.ðl 4ðl;tÜ2Û£qTÇ‹ $‘z+P·LZ¡mÁI•(`Xî›|06¤dò­€JæÜnX饶,­ (h-ćÔ– ´°íZØè,4ƒÌ9tµ8"õVàsŽ<:l+ˆ´BÛ‚’*'P3c±¡43¶ÍŒm7|¸Ä¶€C…DAf*>d¦¶™©m‡ÌÔv@fª)dÎÆ‡ÌÙ-Aæì¶Cæìv@ælSÈ´Dvf¶Jvfv‚ìÌlÙ™‰EvæãCi~K šßvøÌopæ›BæR|È\Úd.m;d.md.5ƒÌl|ngvKÜÎì¶s;³ÛÁíÌ6åvÐ"@ °™ßtÂý\n>¦Á-CÈô£LK@ÊlJ¡ÆrÚSf›à”i ¨‹çÏLJ$Þ˜ ß¶CÉ-³= q10R’ñæ Bñó $%ÒÛ ·È¶àÃ¥D€çÂbüåÒnÂ6òU²0|ú´Ç”Ï¥•0…ä¦G ÖãÉ‘¿èYe=‰3S=ˆˆÂÑ EO=¬Wà½_C}BSÈW=v•‘d=FºÄjT-çj©†Ÿ¨1+4ü4çSýªFMU‹;sÚ(N]xxÝû:²ŒE¼Œ«.Ýæ¯ÚŽt;”/Hûoú÷Bu­†ú¡Bµ7ÍCLÚXµ+V¨O‘LMhx9?”‡5'Ç0–e´æ|,Æ=Y¯)¯qJ™\dL˜Ö¥& £Q­”7¥6¸µ.¤ÍÉ…úØC:ñu§áf—ÀjT7òx ÛMÀfø‹Žhˆ®»N ž] w>JÏxµâTËöÈÈõRÃ>›»î.yIžÆJdG5w¡q| žü±u5¿.ïV¯S_ÑzÏ ÕGºÓt%â÷ý8® lF4¤h¸y¨¬ ‘ù$#=¦PÂum}ó=3éPÐÕ¸UvýH§6šÉr—N*bcÄGaD0ÂãüK¡™PAE;-jM¢fðÂ@*2ÛâV\ªG :Æ'¤n=8Z]^†uKæ»á¡jžN„MYù¦m=Ô›çµýî£lÌŒú[¨]wã!xê0µ#lÐG¨w «ò$jL,3Öwj½ï1ÞEg560· .Ç¿ÿbø¨2bœz!˜ .eÒ…Õ¼fPU‹}ü®ü]½w-Á[€·¯ ï2¼+ð®Â[‚÷µð^…· ï¼x«ðÖà}Þ:¼¼ x×á½ï¼×áÝ„÷1xÓðfàÍÂ;ï¼ÃwÝ ¡Ús9}7tÒ¼ê5t˜.Ó‹[6¦üb©©  ù¢ØaÜuú.“HhmCÿy\Ñkм>ýPRxo‚义Ž[I9é–aº9ceFÝÔ)‘:$yrXÌÑ4ÎQ™&%# IQÙ,¥ƒª¥ä[$O©Ô™ÀjS®‹¬6«ªMSóeµY­Úl`A”>¹, J©‚22â„,hX+h0¨ý”|¸ ’+) VKÉ“QmFU›•¶¬vP«v8¨ZJžZîq7'D`r‘IzsâÙ÷y"ž1Ò¦ZH›n!m¦…´ÙÒ¶v¨…´Ã”V®¶EÃ%¿ ¬¬ÂWÆ«dEd˜L»Y`áÖɇš“úDžÄ£l©æn”,C›Çhe{¹ÑOnz[œØØ0U-0è)vP¼•9žéßâü¿ÜÆ´ÑÆ „î{hEH¥£Ò‰‰æ{èJ‹„%¤Y£-R?Uñ¡&)âýAKô&ßZ!Ežr€éI!ÏÃØ%x fhƒË«'vÃBî±I·!í’:vkÒ¼Ò¦)š"+4¶ÅÖ5­Ðlÿ`ex°wi°÷h°²­l¨­Áj–ÌÝ2DY?q7ïñ·öÁ`l(°°ª¾«r¸¤F¾^Â;©BZÓðßúÇß"Æ­‰søeŸnNùÉ&‰C‡Fµ\ݰëÆ"C®ûÜYStAôÇså·“9.H5¸322í<°ZjàyDÁ†Œ¦ÙG÷ò±65Ä F@u3—Cz lå‡Å•~û›b"×e¸³QjV»ìzÈw¶&‰•1©ƒg¨€ß)æÇðY B–– -í Yœâ|i$gtZvPã†8='<~ÜÛ thƒÒ êæºò·ÀLh™¨vS³=‘}|Bï¤dȲÍ;™ mS6Ô³±¡.ÙÒáæ  mÐ`³!oî-nH/a(F—2!]:îéÜ zë‹è¡¯CÃMšÓXI (ÚËùõrƒË ™¶ÊVÛÝø×ºÛzÀZm[ÅjÅvÏ Ä2×dVP‰~Ë:oãžË±m ņ¢`»HT+h'Tœ'¢œ;_ßìEiç@µ. µ éÙŠ]]w¬F=_*cñXl¾€ú†ý²%¼6È¢ê…m"}D×ClG5e‘z\ƒ=S(“ÀΜòætm¾.t*AsD;;I~Eï½(ÄRd ¸°6 bÅwT¥Ïµ€Uos D¸jƒNsÔœn`Ò&û.Ã-)¤.|n(2Ì13êQ쵟kî$##¬ÚvÖnœ³¯c»ƒ¦ë&AA2L›œÚÔÔ¦ 65ôÓOC= ðâë õõ¤ê€ÿl 5ªZ‘4’w庴¸”7¦Ç¥Í¸q=.cÆMèqY3nR4ã¦dœ±pÜ¥.+m´(Ô´Ì–C–}± cÅftæ^©Ø˜–Ø”•"™©«KãöMÖýZJûΨóaöÚºúºôd®tð´×ö 'Ä0¯ö…›Í«{q-…Ëyþ¡ÒÃ’·’«ú”œ×p“!âÜPN½>~ZÇëkÌéǦ{ÔÏ¡¢¹×:jÏÎ=Jÿ³(ô¹·_û³©þÿð`*ëêÿ§Qÿ33”>Ðÿß•GéÃõùiMFRÄG·®ÃÁ&ò,Í8ŒNÝIòºÏÞ\̯eHÒ##ô¼BËr.¸9©Ä« ­­¸*õ{:½÷ÜjL!Üøüƒç®äΟ›Ÿ^<7£µs¼¾YkTså´k½ºÐànoî« 2]ÉC®ˆŽx‹öµB?ÒŠ„þ­Æìž»¨©M”VlG˜ã 苊Œh·V‚([‡¢¦Zi¬èÞÖê- ÓåRr©;Š"“kŸ1À]”jÌí±5Íþ ü«f$䔯U¬R0Ü–GÙ3°R8Ï-z™ß%?óËûAÅ«R9##SÂÓHw×ãÉ‘Ké}]½KhFÕú†NCn£n(LÇSŸg“Fˆô¦?`ÕÂÉÊúšÀá/×KÃGFp],{µ!ôÑeuyƒü{>5Îù»±€°"Ph6”¥‚9¼…˜c–ª«Çµ®Ú›V ­ Æh6áú(/µáƒ$Ôji„&]Ï—…ÒJ%©½Zñ^DT”ÅÝL8ÕîMÈL–ü~l½==³ÈÝÙÝqZ¡lDN/š{h™×UM¸£ÃJ±eœÏØ( BL³¤ÚþMÀÏEtº‚¨-Ï2&h]9ž'nN–/¢4›Ç|ßЈ­nT„NªøVcÝ›ŽœDz£‚¿ÞbÙ%5â]Nã9Îä€|$‘R ˆ—6Rš¨E5Æâo”âRm ]:%Ðu„÷^Œ 7Œ¸çÎ'Lô)BÛˆéòž²Šß.é‚ÑLD)Dò»W4sh¤ùú6‘‰’zPBÕb»|˜é°êéñVæåò¶ ¤1¬•#´—|EiŒw`– gÑœF°?VŸ{j¤Em–íu]¢%{ƒŠð6S9Š7fÂSÄgÚð ¼4|Œ¤|T’2´.ÑRXÖžJ»¡ì¡Ã´ôÙNUá{òÊÉ4û×÷ÊþC&3ÌòŸlv(òŸLòàþï®<¦ý‡Kö.m—ý‡K[²ÿ0y½°š¯g ZÅjPª]·+…øf!.…›…à(šê@ n5“Z·ÈLàiÔU¬´nOâÒ=‰æö$ÄhØ”hýÑè}äÿ™ìPJ“ÿ§¥ü?{@ÿwãQ]Ž„üŸ,ÍŠåÌ"@ø?3?J1̬3¯>22=+âȺN óODØ»•ÒŒPK€ÌÎÊr|T–[UO±"üðÉMOH¥¾ëûFEÔŽ³ª^Þ‘ê÷3‹ÊïØ¼G*õ¸¾@h‚’”Á¸õ©•EkW…X¦Wˆ+šá•«†‹UÝŠ]ˆšÛhWÌ$eά£‘Â/> 0½ÆêêA‘¾33ù«¶wõ%GPTs\µº#¬Ä1¢ZŠ4…14·xŠ„Ëbš‹b%1M1­&Mú†Ë:¼¢”VìÀ i﹤C™µ:ïUÃÄìMM\æ%ô¹ÇSÄ´"ô  1d”ÒkM hN!Àg/wÆh€Ffýv÷ù ¸° §u­î½å¨ÄÞæ›fÑ۩ʤÜOÊM~Ä£ø¿ŠcvFЄÿK z÷ÿC©Ìÿ·±ÿG<¸B¦Ï}bodli€àî¶öXÓ“‹Sè^ÓÊß–µ¸j[ó¹ÅZAÛÂøüü¼ðéXÎ*LkÉ.W7Fd†à'ð/ð/ced!I‘ ce­AkȶNX'[ …ïkóŸ(e ¸G³hÍGÒm ™ž°ž[;ßKªŒ•ÖL¾æ„¶dÛBÊ÷>)¡ OŽDä\ùPÊ¡BW×#ÛÑ"L‹ Å€»eg…ý³µ|ÍSž/ÁzB#dˆåŸ¬zÒzl¨…KŠÄY©Ì4ŽFCq(@µXzá~qÁä@ ÔT äÊ$}ȃV¶Èê’!¤Õ¶p©dg§'ÎJ÷¨’G •Hž%-Ð ¯”im«jµþ¯–*ËÕašÉÿ³ißú?<8|°þïÆc¬ÿìßÍ·öëížpYM`ÖÇ1~.7¿°8?={ö«P[ §ûh1N¸r^<¡ÊgmÝCÊ1ĘâPªÛ–Ôö”³Ò ÙfžRÄ'à=—wV­\y¥Ÿ~[ÖT9¿"·bO¨^N– ¿õú&í‰ímËB¾Ü°H1R¯[{D’Ý Ê¶°·EìŸ1Þ.ZsBìêÝEïÆÆ9îÖyÛÚ"Êal‘zgb¦X¬£eÛªv£ŸÒIZ.Ùå¢?Q¯˜nsµFßÜzÃZ†¤˜Ä_Qšù.-ïÁv¾Cf¤g’wÖEvõ<1‚¼ ÿ£¤™øb‚Œâ ÏåÎi×pð¾$ÀR»d°ifœ'o1’çy[:^·sïa(ÿ½>ÄsÄ|+¡ðü£¡­}]Ûx~ !*ììœhÅlù󜸳ç倜ýiY®¯ Ø„×Åz:ÔþV3<û÷ñûÛuýT:™qý¿ ‘ýÁƒû»òøå§ÏO/>,þÓ"]GY¥d} ›NÃ^ U Žë+¹ñ˜ÖDÚ­:"üÛíŽ ËlÓ±ýÞFÅ·¨åkA´‡‘äaÖˆGŸº§-ûïñúÞ‹û™¡aßýÔý§]y´ûKÍîŒÉûcMïŒIõaéV9âŽGÔ ‘Èûc|ÿ#Òu371ª!þ‹[» 2Æ7A\ÓõbjDÔM± › Þì>Íg"m^âp+ÙÊ%ŽèÌÚ8lùÇXø%·èí¿Ä!ýySåÞKcA—84ä{w‰C!}æµt‰ãX€zýØ>¿Ã!fmiKw8–Œ;ÚpŠ˜–îp,žñ´3w8–ø¦Øw8–‚ïphTªå‹c­ÝáÐæ\{Uý¯0Õ°#âÿðOÿµB­^}í6×ÑÄÿ{j8‰úŸ™Á¡ÁÌp&%õ?‡îìÊsêžëk°¶ëèŸ÷tWª?ÙeÙinÿt×°‹­n8}©ô`ºëž3ÇŽžº¿ä¬çË õb©zPÅ. ãPú†çe§»dküøñ.\º¹è“ýÉ$àʺ ±­Kå<{qzât×ãS“¹ñÜ`nª/—žêË&'ÇúNæ¦Nô OeNdNœ89>4qâf›¯V !˜TUÚ}öæІÓ]3ùJ~Å.Žcñ±˜¯¯Ø©:dAS?n£R'‡†RLë0=›I^™˜»x–ÒΣ;à5û|i©žÇ¡ÍPøEúbd•Eyc\Õð@¾^I~Þ¾f—UwÓ•e¡‚5J]<7> x‘öw4<ëVò@ÇΗ*Wcc&6Àž+Hóå »†~C*…’í༘­NWVíz©Aó¡óNW u{ *Ë—ÝéÐIHb{vº móqEŽc¯-•7E"wnEšÉVKÛ ï@[ ó•Ò2Z ‹3Q&ÆqW'é˜Sˆ›tê:ìêâ$ÌÕj@‰KË¥˜c^uátãÔ€A¸¢Éë¼lö“œÀ>°Z-#¹ZuÍ$#¸ Ü„ÖÎFÑZ&Á´–chí–i-ÓËX´ö€¨î‹ÏH&’õ0¤)ŽKI…•-}ä3ÝI/³Ã5]XwVQ+’ý {-B;n¨¢¾3¹b±»àÄfñ<%ºWkZ½ŠÑ‚•¤Fö¦}f¨uòúì6j¼º9û¬”äVØ—Å?©5z1o¯U¯Ù9 ÿÕ&}ñ¹õ¸h : ~r}ÅJt^[ÆÛ|b-½^É9ý)+˜Bë–è'úïv &Ðue=$g®5;¤ÝÂù;7QóhÍ|ô/:C>«ÜÅÆ3>æ:éâJSçmº§z¼ÎÜ0ÒëDÞìr"/;¡œ¿uY]£ž néac-f'äAÔé‚ÁèÚNÄct-»fvÔ-ZÇ[ì›Vƒ§7 ¸+1:¤cÓãIÝz/ôfK%o¢-ž’;á iÚm/A“æӳ1ˆ›»&ï{¼½ieéhqHÌäš¡ƒ™zàº}¯w.­Ø¯Û)Fàâm¨xÄïrcà± ½,5Ãd\+[.ÎcÏÅIMôl¼ü$"ÅS]‘¯ÎÎÕRÙæ•Ä…³†V’JH?¤Ù:n¹+<–xü¸üÊMp)ôº¤©S–&ioѼ›4©%.¨ÙbE·›@l½4ÈÝR»hî«à!L<êæj¢(bµlu¯GØ{_iP¿6+ûß|{<Àÿ϶ï›íÿÒÃImÿ‡öß²™ÿ»ó¨ýŸ¡grÀ~eFF”#žE…Úz4í©6¡M›HQ GnÉTjq›rsè^÷FÞŽ[U':I fs»ª¡‰Åp&y|b¥nÚÂ0¿—7PCÃn—<YÔä;J‰,½,a)úûå+ŃÁnž4Ô\5 ͱ|U(§NÛ]º×¡Tµi ÕÖkp÷¶mÎå¨ò·Éºh޾ÕõïU¢F|O骭çSGPÞ© üs©2=û4•ÄÜ›y<˜íÝîLsÏÜâ8¹xço¸«ÉI”†$ûu÷¤†K¬£[ÝAá/. hÈQÿÓ ÀŒžXæç-©‰ea6=+*•ÇDc«50`q«Æ/\´ Lh/®vSEFcÛ$¶Gr«¹Cs7=­lTˆ›ϾFëÐÜB`ö¨å@ˆÍ†Ó<Òq/’ζº#rÑ;öÌCØÚ®ðàxoGMÿkÏö©¤ïüï`ÿ·K¦ÿcÿ7ãNêßþ/HÌݾÍÃrS^º¡ 6Ù4E¤¶˜Î¦ReÑ cQ-Ú.…1}gÂò’< Úè„–5RÖdhY~ MÆRÔ lH®šÉvóþ~ß…®G˜~2(}³}ÁÌvÉÜÖúÔë`×?C¬ÐFÉÚdi¢ÕçâKxºðvD«Fï¼ÜRƒö^“Q‘í© º<ÿLØ.n&d7³_vqŠ "N¥è@‰i[ÑpÿoïÔ8®ÅßÞ)C}»‡¿Ö¼[<>¨ígo·¶…½ÝZ+{¸µàÀÌXkj9?vɳÃÙªÚ¢¾£á屩æ¢lȤjˆoK M‡|܆ —á œŒÛ@V­ ÝŠÍ´·›iy+6ÓÞVÌWáÿæó°§Ú£ùäÛÑÛ^G3ûÏÉÁ!ÚÿeS©á!yÿçÀÿã®<~ÿOažßý>ß½·Âµÿ•u©ßHŒp"4¬ º LÏáfVÁR!"ù¬-52÷³wß ÖÝÒË|±´,Lo5Pª*ÖDÛéñÇ\Óve}œLóʤJ‹¶°ZeJä뜞µ:O[©^N2¾š‡5K!SŒŸƒ7Á9`Ý«E«{b–øÃ=”êܤʺ©f [Äê7¡иuÁ‚QúÙ¹ÙIéDû´•Ts•M£öÜ샘b°Wejz~a‘ò%E.èä"—448˜¡ãsgµÐ¡cìWÁÕVäÕš¥:L­¼µZuV¾X¬ÛªÙ–T+_±òëUôÄ-®] \°»~ €HY@HhY,\Ô­"Þh®» V÷Ü’S-ÛÃ>kݱ­™K ý™ K#μ\­oäëÈ£Ed²ô8Ràí†l'ª¯aÊ¥¼‹È]@ÆA•q-_¿*°KN§º Íx ñ¿Qï7)ÿÂBhÈÛâ¥êub£eÍÝ“—.LÎOÏLÎ.æÎ»-ƒ¬Ã¾Î®Ô«ë5kÍ^[Âþf< Oø2Âèc]Íë‡ì'õ쨜‹x˜|öâùóˆI=dž 9®Vн#íÉâ꥚a™óûR:þ­«UK8‰)õ…ElWJC%e†”§(òJ˜4£š:Œ°€:0È:ÃY³fV˾¤´²Â³zæ&Ò¢a_o°º#¥Y¼´ˆ‰´±ŸŸO¥Nd(~þF‡Eç¦&R'ÂR\Jbüɰøé…‰YœkÉÐ`Ó)3z89äÎÔ616d²'´Wä°¤5X§6!…AÏs< ¦%ÓÙÈD÷M>(ˆ¤Q]:5Äͽ€@O{à9œJSôÙ s‚´h-Õ® y <˜Jƒêù¹qd¾ —Ežf` ¤=ÙìY1Î ÊÅz~¹ÑW²Ë}•ÒZ½Z샵¸/™Âkç”irZP²TK™f§gd‹2Ú,ÌßÏ­Gp Ÿ`x`$ÕfµÑ¨ lllô¿vÕ©.7ú Õµúra ¿Üçäó}À"¢‡ˆd½±ÌðZœAxe²æ¨œL r£r2žqKg’<®8nsÜŽŒEã“3æLHŸÎr†0Úœé¡aîç‘èŒ6LºR¥ØwµÔ(¬Ú•>øqµ/™Ö@¹0={®Ú¨]pìõbÕš»°Hðìïï§Ô‰Í™’I¥Ý¹z)`68šÐ }E»l¯è´f±5« ÏÂÂ9ë>{Óš"b×k¸£äÖ.œ›Â©˜Ízk¾ X¼¢S­ô•jŽ »è;z½/¥£Íô……Éq9¹²ƒ‘M¬³UèKóÐÎÏËy›•c7 Åà/9PÀÀQ™rd&Î œÎž$“gpéLº¹3ró¹ì÷`ŠR-\Àuù$gºÈ8)s]e¦’ôgé—ôÅÙ… ¢E©d†²/¡¡:§/M â4(³çø§6P9laNE¬þ´LôÕÑl„]$Dp¬î™±^ –UH23ﮓ(þåe¢Ê³ò+’ír îı îÊÊyXDàE6«fuo”ÊÅŒ3'nÑҹŻ#?€¢À‡³½¨Þ‡ãu¾Z½šwJ@­î¾¦h àyA ÒÃC'U1¢>¤n޵\¯®YÂ4,5`ñ¥9p«¶š—Rná¡Á ‘vs1|°—j“ ­ÉÌúÙÓ–ˆé³dòãV*€Ÿ=—wVq£‘/¯ ¯µºæ ¯‡Þe[KŽ3¸,î¹Ü¹+¹ógçæ§ÏÍ0§»p.—²Ì\Ëb'3L– izpÈ“4­%Lžä¥inañd¶ÓL™Ì`ÊJ9ÈåR¡©©·þÏ?xaqÎßæù…ÜÌÄ`@›õF÷ž×ç,ïÃ,ùÄBÎ%Ñ{r|Ü%‡Zà³ÌPà‰'ZÔžKf~WFàEŽVuip8Éô_¦>@ï~²7(-„¿ç@²‚‡vÓó“ã‹fz¢æ§ïÏ-NâNVÌè‘s@±ôÈlÔñšUÃkmy|£‡#l|÷`8"£Õ‘°;7“PuÊ:‡{;=‰ï€½pÉ‘D>‘Dã’Ñ+Åô”‡0áOlSI,ò¤€K±ÔhTéï»"'8¦zÝ9¾Ç$~J!B/Ü7}©Ó•…ˆ à´ ºpöB§+!çešA- Ð[†eZîZ­šWÔø $V%¹‰^‚Õ©€ ²€AÂBó X‚`­)U+_h '3Īg½ ›¸~Ëzµ]¯RNhìά|š‹nô`dÖì|ÅrÛ…‡8°•2¶‡2‹×xÑ­z¾âäÅ!.Ê5tfã9@¾RäÖ àæ–}‚æÀÒ;ªüZ­ è‚bÞfb«òåü¦J—Ö¡q”}˜”4C_}€&C«%„‚ð¶´B]µ¨“ÐÊ›/;UŠÛØî£{'èܵ*ZH,Ûb…•cíá‡õ sjHŒzÄp—¥JS‰ë&TcÜ3—‹\™9ÅóÐúz)¿TvK’bU,€Š•Jqò’¬Ô3—úåQ­ë¢fd84l¹&üÎ0t ~¬`Š3‡QNjºUû‰í ¾ÃÒN[ˆiɯ ‹#X’à¡ ©x&úƒ,!..aÖáÇÒ¦%OÚ.×íe«,ÏŒ¯°|Fwy½"çÜ3ì)q‰˜‡Ny Lò¸J7"€#äsuƒ’«k5Dt@ÉÙšJ’‚ŽªÌ‹%ÁkYe<â.:¡Œ‹Õ[·&}8†¸–/'̰ºÀC ’]‘¨¢U+f¨‚&²ßÊõZ3—,»Q`¹^'suêª^2ÿ¸€PÈÈ[Z~‰"†þvËúfCˆ)H,!;#ðÐªØ t@dUÅ¡&LÆ@AlÝ·²€0 ë#»(GÑP‘yIªs``ŠqÅ;ôF&©ì¹X} Tg…3W—Ư jæ5s‰^ ý´iç< ‘_¶¶¾°4åvð\±@zcP-o¦Y¼˜ŸÇ«%|º7¶9])–ÐÝ]·0_!ó•(¬WÚ´ðT Ê=.”î¶è›$+eØ"àh¬ÙÕ*ÑmyU¬ ëNAI­0 EàìŠ%ÎöÅq¹½a‰²é°[P áIÐÛ¨±n¯@ÃmQ"® ˆ3Òä9Mp¹D\C音^«`DEؾZ¾îH„Z4Ej`9‚Ø`|±”_©Tvm½^«:̸cà£}§7h`Œ¬!ÚW£QÝ‹RÛb<¡‰La˜\s0&u˘bfCLpùÊ®³òócG_KEi¹-CÃϾ|´û?×÷Èþsv0ôÙNèíÆ£Ýÿ¹ÞìòÏ%yóçRÓk?—¤â=ë-lñJÏ%÷ª dÞU)VÔ5•¨šŠ•¶ïñ\r/ÞpK|7o("àê ­ ª uvðè+¦æF…CËM%×ÜRTv¼”ÚêmœKÛyg¼Zα6È€j\ók; œñoçSûÛ¼‚£jº)“ŽqÕ&F ˜w¬Ô ÙuX¿Ó=}!'uFFFÎUÑßð¬d±çÃîîvw=8Ã.ã5ÄH˜6á ÐÀ7ªìí½UÓÉtÆÅGï…šKA·i.퇫4 $œÎœ¥ÆŒoÛÊOâýÆ{†oízë<ö»¯×g41-ݹûrÌõЛ1Š,k Mr­MmšÔ‹Uœã¾©m™´a±*Î7Ut¸š—b5EF±,ÜI·{7Æí¡»&ƾs=øZÌ¥6îÄ\jíBÌ¥6nÃ\ú_uFñÿ>ÇNÛVGþÏQÿÏ f†††SCxÿc0“=¸ÿ¿+ÿþÇ«.N.,NÏÍ^97™›˜ ¹ H¿â¡{Z ÙMø$¯"ü#o—4kõÒ5X …XÐ`ÊÅRY¡}‡õ¨»Ì»¢ÑG™v»Š‚̪hÝ0Jrʉ$ç$’¶hÁåiUÑ&­œEh]H9"г4zÌ>hEÁpH2ÎÍE¥pa¨! " &u îy*=^ÿ_Ûû¯9ýO§2,ÿÉf‡„ü'=˜> ÿ»ñô_8Tñ|746…?vôñ / ²F<âmK'ótÖaÐTòm¤¨žwwdwÝ——¦»Ž» é`,ŒX’üªwƒK^‰ô}ß“êТÕ3‹­YÐZ#V^oöz*<%Eÿ•“êí®£)ýO§¼ô8“: ÿ»ñô_Ü8 ZôˆvW.«éBà!ß…V®$dXÆýk@¡Ò2ù犟¤+€4vµwkÀÁžc—Eÿ]oäÛ^G3úŸ‚ïú?”: ÿ»ñô¯Ó‘-¼]êOEÅÚ$kBjŽÅ¢þTIw€ ˆÿ„:UaÚ/‚LÊAú©ø')‰ßEßyÀèï÷GÑÿj­±C fö3CÃ^úŸ:ÐÿÙ•Ç/ÿŸ»°jJÅmŸá¦VÎ PÏ/r¦‡†µ;¦“×vÅAÝú#KΚԄÅlÝxK6ÙCIsë+0âVêäÉ“’.ufû3ýRe¿tÝFeT²«Sæ`©*9x `½ÐXGu×¼CJ¸ÎÐiM -q< €äé‹ '”é‘¶oKÈj\þÑÕÀc¯Õ›Vw½ZmP”Ðt1o¨­_)ášq¥!BÿDã’Ž'Û®ßåX'.l6ËÕ|ÑBmYº~3Gä̤9§ƒRˆÍÏMÈ+ ËåüŠPD•¹BªT·+Äý J¯ÝÔW1pLìüü|<ß ë*½âòÉ hg o¨ŠÁÍÊÁu/vޝ]ÁëFâ‚k©AõŠ—bÄE´±€7„HQßUÍV8'­î™…±+â9ž²ºÏCQËñ>qíkë/”bYÉ+âšôzzn¶O JèóÄ66'ÕjMøµ¾moN6:±Ùœˆ€Ô«Ð„âhVJ¬g`»@#€ãÅŽîœCw^–6­éÜl®¿Ç“’G“ZÝ0äE©œú=Ù4÷‹ËPxóP¯Rë—ËÕöA.@¾ÝC³Ãâ¢+;bIIÉ® %óolt…AD‰+2zU¤üЏž¨¢õì*Q±ÉžÅܵȾ±žœl'ª‹Ê¦jŽ_y×¢Çp¿œà=ÏœhØæPJh"öAOîöÑÍÀ‡Íââ̇ºE`žmGU(YŽZRsÆ‘n ­Ò2ÅÊ—n7È8Ç-]ú»¨ ²°bÕv*w5da¾ŽKˆ¢•vðq–Ðå•ëÓxü¦ÿ³CÞâìÿ“>ýÿ¡ÿ?»ò˜ú?Þ}ÿlI÷gaK»ÿY§¥Í¿¨%dïOEyè+‡¶»ó5lü6þO¢GÑÝ›×öZjâÿ-=4˜ûÿìp*;”Åû¿Ùááƒû_»òÄðævª€t§õLø.ddѾ¾›?¦nù£í7ûŠíò5»›e¨E3úàÆ®/¡£‘kù²¤«%à‘»-i×Àé;3 KØõ¹åî»._¾«§Çºã´Õ'6œ²LØVíÂUö±U- ' ¡*"¢Ñ8ŒÕ=UŒŒL;¥•R£Ûy ?n¥†òî¼S¤ë K”Ž“(ƒ‰¤õÙ*lV¾\XGob£(Û[Т](­Áׂ°;ØŒÎÛµ2BU¥tÐÙZq-ðåƧ§-4õ½ƒý®¬GÁOBka}É!“Œr¢ÑæÅpÍk’éL·âF†ƒK’ì‰Ñž¾žÊŽN¢¾•ˆÍ«–1Æv–Š‚ž8N­\’–cT”L8Œß*LÔðpC½ÖfDàäõ‚-´ PñƒH i×¶¸û‹ÕóU–.`‚¥º¿J¾ø„‘àõš•ÖgE„uõw üÍ÷„5Ì«s­TDû¼°Ñë|”è”VÙþÿ.¶î"¨¦eç «2–GÈ.iA÷åjµÚ£×XWôbÍ¥¥z Fš©D1÷ÔŒq ð¤ÔúÖ;»%Ðö§h8aF­ãÇKÝ•±•g ºïFМÓ[%>ÍsÌ —öuSÜëîË­IQ*ñ­¨±ØÖGµG¬. Þj;«õê†tÏ$jT­H?1œI#¿?$ÇúaïowÝÆª…0INFcfÒ^uHšô6?1Õß:$MÁúÖÕÕƒr×ÒJ5ň±ÀB^XÚ^Ú´Êv^X–FAd=_*ãwÀKê»;9ŽŸ†Y(Œ„áÄG©¢6BHqQçxÊ•h’mì%H-@&/BÈ#¬}WDº’²ÞHúã¡(šØ±aU‘t§W)ú„Éôiß>XÛ*a*Ë€©ãÃxIÍqý=޳r¸mtË0i.¤å¼b ÈÄLHl^ŸÑÉ´kމ²©ÂÅöýüä¿¡гWç½darÝ¢l”›é®±2) 7ô™G[fvÊbi¿ÑßóH3%b{9McÁ¨¬¯]‘t™‚£{Èõ'å!1¦V7ò€{F£?”Åà ?l±€ÒºîV|ü¸Kc•ã8Í)Tv¤©xçj©f—.íßÖëÂÏ®w†œ‰ªŒ@ÖyÌcðҞǟ*ËrÒ´\”Õjò[[Ö8!E1«ª¢0Þ†eÇ{7߯°Ÿ6æR0=ϧ5ÿ8¤ù´o·@­Šâtî ¥¤ Êù´N¢Cø;NSMö#xgdÙ¶S`„d:e]ÈêdÛW‘bï8¶'l'º3Ô ëKÒ¨§ ng}É…·!÷ÄÞa`(A¶fðæ¤ú\;s+hharû²ŒÖjÞã8´'W!Të_²aãI䯏ù(HÎ[T¦Na‚†Çט`úO9dØFج‰VÂöž\ô~0É—ì:jºÈV‹vÉú‰1çy¢AåF~H"A€®xKâÙæ]°é°1¶¿yGýƒn¢ø å îÈ¥÷$šnb7)o'fXöm‹UV\ŒIPu[¶~ZêÚ­õí2trV ZB&³¹bQY²5Ⱥ4Gìã¯ÕòÔŒ˜)X×í.[H®£Æ§X†@Ráwè. «»áØGtuÊ(7d¹ ]DQq k„ݷɯ"Œ<Œ{½hÐõr!eâK!íþêm½˜R¿ài•À\+€¿ ZA|²Cü=p·ð‰=?5.œ,KAGÉQPIP( áyÇY_#vI}…± j•ÞÝ À«„Ú™Ð[ª¢W5‘¼! cX¶ð¶åç+äv)¿„–®…O–ÁÃ\/úˆ1d_Š:&nP6œ¡M¨*‘àƒsQ$†ï=–Ž@ÉQ½-œÞÀ1Ñ -IP1)· …È÷-mZkUGúö+-—|¡™DŸÝõÒÊjC$ꨭB()äõËr 6AG{-)!­0á®Ø×¾ÒÉi^ÕÇ,Sö†4> å(ó9–³†Ö¯ë„¦ ¡¦6ÿ,žæp„¯š›4}}<â›N ˆg„‹ ð¿4â—O‰beÍAz)LéÌËáLsxšÂQŒ)f¥$†ÄÈ㡜¯¯ §ø’t $Ù© jÎÀ,O£R£žT§‚Rõ¥¸^mMs—LY{/byÅ–Sc¥*dÖ8êâg‹l±Kµn§äºOù™*昰mòì…õÐR”`ž±<Ái ¦–{:^Ê©8¥0nò5ìK¥SÞ Ž^«\­Ö Ô”x.{.þôõÁº_Óúj£M;ˆ1¤µaßEz®½ô½T„và<ñÏâzygÜâtÐh«„ìã Ò(ôs3ùFaõR¹XÈ׋ær°A¡ÁÌgØ¥š]ôSmÎæîú¤»:ljD‹“ÅáQõ"½ø§¹;Åv«Hƒc<#g*&W¥õ"…Àå<¡ èóî»ôùËÃÕ^Þ ­$1UÄ’É ³Ù.Tä·îG=´`¯8 ±©“lô×àS%&#X!¾{ œšìÕ# ÃYC €;ÈÚŠ Je–U?au#Ãø\w¨óa{aèY½N¸1â)ž™ük¡*] .U‚‚ÇÖKh†N¦Uè¼}­ÄéDèƒÕu)eªÙDÂ<ª{­v¢^Ë&%(ÚËyäË…s*EKôŠQ¦ëÓ¦ïU:«Õ ô½&Ñüp¥hpMõ'ûïfઠ€U÷Cõx5Nlü Î/ æ•KùІ¸×ð%eê hC7åCb&œa˜Kkëk½ÖÅÊZ¾’_±‹xö0¢Ü½¦Þí?jýÏó3€›ÝÿGg¿Êÿoõÿ“Ãö?wåÑntÑø#`…ÜÊÏÁ# UÑ—‹¥`=æ!º÷Ê:}K½É^Ì‹Ê[£ë)±›®Ê8ÆpûmdïWÀ,ÌŠ¸ÿ¾n˜ZCÊ¡nH« ETñnÂG,·&¼£L¹½<¿·t¬TlY(@jöx5§Ü¢TÑZÍqzVK¤_æ z·~f5m:ôeãæô9È}®Õ.Þ@»Mkæ+cyKîúɲyîÅ Ú†WË‘Z¡5Ç£©ç&0åºS—äWÂá¬>–ðiÄí+ÝXþoù{ª‘Ùo,}ƒ‚ä¶™\Œ‹<Öv[!$+§Óm¿·XýœÛ““ZãCóÜ›RÅò•ë¦5Çß ŽëŸW| dQ²U®<$±ÝÇš®ÝêL²$KÚµõ_ñë{dÿ=•rýÿ ¦ÓYaÿoøÀÿÓ®<~ûO‹—Âí¿«¸v½½Ê’B ùªëü2¡~ñþº³ŠG±´Lb»ÆÏåæç§gÏ>bHMÒ~¡ZÓri&XÐ÷STq’˜»ê—ÞgìFÒ Û²?Vš[ Ð @‰S äñ: ¼ž£pÃÏQ޼‰z4ù?üé¿V¨Õ«¯íË—‹ëõþ|¥T¨–ËýëN[”¯™üpü§Sƒ°ý:ÿïÊsêžëke‹®™ŸFù[—ô†óêt×¥J±ºáô¥`aîºç̱£§î/9ëùòBc½Xª^´˜*•ñXì`]h ×‹Ó]25~ü8Þø¸ŸË>ÙŸW@V«¹rs:§»„<ƒ¡ôÎS†¸ÙÁ O˜Øí¡‚Æé® {i}å hb&-o–ˆä§D8õ’y7^][ËWЧ»è ÊÕúUˆ(µiTë›n%ÌÕWÖ×ìJÃq#rF¾°ª5QÑŠ]—½ÎP(Þ)oÀï”ñ{rÃZzºk,w~ââ¼çmݹF£v±^v_˜»o¬º¿^u^V-ƈ'+×Jõj[6c×W v”\zZ?UÎ_«ÖÝ<3¦ç×+Þ&ÉP?Xdx(8sµ¬ãbà¼%jQþbVKkMÈðÞïLµhûC`~rø€Dw¢ÑiÞ.ÛyÇ>@¨„j¡ û|xvêª< ht{ƒç%H®µV:)€ã ¦³QO³¨FJVñšC•õ†ÅbíÁqÔ†àHn‰Û‚Ù>9v;ò-8RÙkêuð´û¨õ_¨< ×*r°}zÍÖÿÌíÿ‡†“hø5™>ðÿ¼+ZϽã±®¿Š’ÊÓÌ‘ó·:|Ô°ôcX=S§+Æ"æ-YA¦Å:Vy”még(ÇèÙ[Ø‚§0£æG+¾f?Z14½çÁ¤‹ÕhÜÉù͇¨ñÚ*ÊàºÔIâ£t(Ûk›tëѸq\†ü­sÏðè^y³öÉbÜ ÕÑ×£|FXl¢±ÀyËgÓåÇ‚ôKÔQ¸8Ö0XDø!u­­ãVVŽä£c-®["ë¥Y3$ÈI…W‘adä\Õi,VgíÆìXçêˆýÝ®ýŠ9Ò=¾âVmWUØMêBc•MÔ ˜‹ðHKºT©Î|y•&+ëkÊ•ÒÜAˆ•нÔxY¥Fç0 뢵sºôOÆGóÿ³¼3ÚÍõÿ2锦ÿ'öÿCÉùÿ®¶>çÚ«ÊKMx»ÖÅÿÕi¶ÿ¨ ÿì^Æsÿ3›<ðÿ¸;ÏÀÀãÏÎ]™˜¼09;19;>=¹pㆸҥ®Ñ)}ÍóË¥²-î%ZÉBr¾Vë¯öåiçÁã}4ÿ/窽¹{À&þ_†²Ù¬÷þ×`ê`ÿ·+ÚÿÜ7ù ¬­!WÀÇJ+x{Å®Ÿ/-Õóâµù ìñúf­Q]©çk«òFCàÖÒ­{dÄýªmB7,$ÎC÷Ýõj£Z¨–ÕÎÒ»+•7ÛwêæGT£Œ Œf=”F»4†œ;žò ŒŒc­vIÓ-y«FÅ´ËE¼œé·¬ée´þÖëZ‡*U®åË¥"ÄשhŽ®'tGd¶0ÇFéºÇç¼°8w%wþìÜüôâ¹+ïitÝ0ì±ò»[_Z]gõº¼Œš¯ò‹ë ýš%ßgo†H}5Û¤Âúnùø”5aÞPšå ¹>£™ÿ trmïÓ¶4‹gz“½šÁ}•\‰„ vÊè PZcn¶äœ¬uS¹j{wÏÆÛ›’š&‚Œíu6l{-mxÃðj`«¡ÕSåüJ·0Tº87172bM•*%gUZ6¸Ã²reÀgH#Í>f׫–-œs <^ØÞ´–J kø«[^7'ϹÃÖ2ìu¬²½ÜðÃÁ5ž¥(ÙÒ€î‹rûA[K³'Ø'¥ƒ¬×5;Ë$¡ THk˜ÂÆÆÑ¦«ÙBS¨¿X•íëE¸·C‘F1Bèž¡Ð(Ò)t‘ÎRåN(&V@W«Wí¢Ä ÿ¸¥¶î´’×O$ƒFÎ?n¡=׫Q=ìâãZo„Ñu÷ë¢%¢â]7c³‡§)a`TJ+•&`H"p `Ыi†P$ÇÝßù©ÉÀλö¨TÚyÎäš\{õ„øÝ‹©¼•ܼFo=o¦µ¼cyÇʪ¶‹å,êÈ-€hçËÈ×б+À:~¾ÙØî™/c2Ê®.#œñ¯œYŸ33‚KnÁ»¸ŒÌ/äf&=ÖÍÍ*Îp2A'5<„:JBë]šÙGÝ ½­X‚ËZ øL‡Å“±o·u’߉RzØQ_O²Nè-rs‰/gÎX©¡9±àá6êl’@{(3çÒäg^t?òˆ(Þ]È-œË¥JäÑBÉd8ì± »ÂêjÞY%ü†«¬ö\ª®UänGx¾5Õ¢@ƒ¶` 6“J%-4¢"c{di³Uá×0ß°˜‘µªKNµl7lƒÒƒ™ATÏ´ëèÄPH0!F:•Ð3èĪbý1Dn(È 0å×Jв8£±êŽ*%,•*äB¾»éFÍÉ×òõ5ǘJ.é%(ã ø#kW N :_B§fÀg’½ÉëéT/}KžÄ?Cøg#ÆðÛ$þÉàŸ4üIå86)rd1,kÝp[ZY_[^6Ǽ¡›Ì¾^F£Ò@ŽÒ \«×ËëN`Ê¢ ê¢Û_4ªá¢ý1Tѵµ1Êûƒ€,¹c¨"º]] •T€>nbÔþ™´lwhR&šÝæö™ù@ª‰È,mP¶áÊìÂäx¦Ç ØºY[DEô€°*ØÖ5XfìsÔ­Oyw,ž›Ä"¥u"ˆO"¿ÉÈÑÐÁ¡ÖÑó+=8(Ì":ŠêêÈ„&d•ú )®,VQů¾²@KzSì2ÔmGË®×LéÝ(&ÓËI€HíAï ìª|SÃ]g,XÈ:¸„ z½CûãH<]A7-,'VèÛÑÓTk=M…ô?4: ›¨-Éz1£Zâà£eUl…Ùd½,þ÷äâ…j¶ºaICkÒ»ë*­THk{ÑôÀš×’^Ë]˜„•\,7k¨4Š™˜”z"ñ†?8­ ŸZÂî©ÈsŠM ?4e•ãÕ*åÐåÞ}Îe°hÍmHnb<ÂÊv à0HÊ% Õå ´r”7B²j«'wáà)¡Ä4*ºP™q‚¼­0Ã1^h0Û!ß->ï†9Ô£a<0sú@x §+›V«nñé–M™šív,Ôª\ñºÅ§[¸›­IñdÃ*p×ÉnúæV¢ãLIóØ(9X± ªõodd;œ¯OLKâ*œh7ÒŸÎã’;:g`IȯØcÕë°Ñ]­ntÓ¦R P<–¢›F‚&v]®\®tIh‡ÆaÂâdŸÃb±—fEÉ~@#;aÁB~vdäXºíó¥ŠÝí/“ûwCa]ÁQ¢oíúê,ášÚSHv,†è Á-4Õº ÛN¸,!{Æi•‡Ç<Òù<Î:4RU§kÄòDøü¡¬~­#­Èi"?O£ÜVW̃åòîþyH¢e¢„~:ºÏû§ ô_ izF#x§Bþ3}ÔâŸ@D|ŽKÛ SwÙ3’ûa0…ó²Öi½åÆbj„“äÛYÀqeš§ÈÅãèl”…Õn«„«0ÏoÈ€jD’çUáŽ%ÞÖTãÌSMð¤SxjŒŠÛø®·~ÎHc¥þš!.~ÝdýuD/Cœ‘Ôm0’Ý0ö ÄöhÛi‰L;í4P2b{¦u~ÙíôÎtjÀòhãE z`üþ׊z4‚‰Î2žÏžËxâKlŸÚùñF(.a>v ¯9×Èkä5òšyÍ.Êkž´rï]ƒa¿ÞmѶAR7Žh7eè¦ÉMÑÊý-SŒ;.Zj}så‰2”%|Ò@¨Í ñ a+-¾&ưñ2x AlU‚ÙrdºLs؈¤þ&Ê?rÞšéz]“ˆš®Á%¢§8S¥È×2WOHج,ÖÒ2ËÒU¯¸,mšéhy¬™’P«7{úǾHä)´_¥ïBÑÿî‹ šþ¿³CæßšÚÿòÛK§ôÿwãñÛÿžX5ÿíFµkNjü[³G *P¸ÅüŠ k>Åô‚ó\AÑ­ÜÌÂ`I©ù"KÍÕ]ÄJ¦uj½"vbOÜÔÔ,Ñ j]¥ÆÉ ùbžŠ³a2 4ºÐÜ´!.º¡IŒ²¼±¾HL :ïžHë3FAZ„HK&Ä ©S‡ ¼V‰n`˜[²ÌIÜX;!RKòî#`z`­‰ýµ1e®Ùÿg®;°4³ÿ‘T÷¿†‰þøÿÚÇOÿg&rg'ƒW-r NBgíFtìÈÈB'Z”wÏqôÇ)i6Â~¦T5—$BeÝ’Y´3m5+—y1S¸ÂVöˆî$ç 6ÔSbÕˆXÕÊX´Ëö ¬:>šý›ŸŸ Ø½'uÞæzHžÛP «f¡€MŠ b(HaÄòòÂo]„¾ÍÛ+`×í"®€rë*’p~ÄH9?/Vº–ÚÓ]_zŒ62x:æÍ ¢ëŽÙ ^ÉÛXk«ªDÓ<×#š5Yíü<,ØX¹Š³a×õÆ*2›F`±X¼d;×Vs¹ Znk·ù+³6öæY€…ŽÊº8qA÷o³Ïöì:aª m¶ÉW : rMg}H¯S×óá‘29ÝÁÅïOEðbóóÓÎÂz­V­7ìb·Y·Æaqà0å©ð(þOîâöÂþ[vÈoÿ-}`ÿuWÅ­4ÝÅÏ.9ÛìB3ûo³ £jÝmÖif.Êþµ–.*Çg [UO±Ò®Õ7jÇYÕ¯¤‘Â#¬¾QÍoUƺQéÖ§6âZk¼¶>u`¶i:έx+¦ã¢3kãØªé¸NO'mǹeÙŽ#%²Xfå|È2+T¹Gç"M}·Ù…ý ë¦fMþ¶kaŽ1~¿1JÞqš¾Y˜¹‚‡ÓiñŽ2Ä8}£”ÛmaŽŠÕÈl\ s.ìÂi]«'5rTb és®½ª<þY÷zÁÞæÇ°ÿ¤ 9¶‘lÆÿ¥ÄùOf0“M§†ÐþÛà`ú@þ·+O¤+\·h_—GÀaæœ4GÂô’ö[-T] ÛvIO(…2T¢´Ê£j`‚ã(¿Û ãÓÓ“äØð+¯XB#&HaÚrt}a>&/Ùi°4¢äUe/È:ƒš…’‰Rl‚øI] äªô޳r› i—AK8ÊMs9$Jß›RšÁw ’_Û|ОÕsŽ…ß l?Õl²‚n`€Íýf̪·‘ þFm+8&/+{†@ÆÈVõ4“‚ÂÙºý"Þ–Ánfp|cjúXS®0zîÙ0´†ßl?Cb.ÎE“^ϰ¹z•AsÏß2ÿÝ#¹]¼´aT¿X%˜ï!æ6áÎ݈E7ˆÙöT\ó°U\rÇDÈ÷zõ;xÿÇ'_Û_G3ýŸd:-ø¿¡ìðp*•þä»ó˜ç¿çÏêþ¸Áaz?Zh@<þÐrŽG­d…ÖP×j©²\õ¯-„-„­„…Y»î ‚Hű Á¡™€àõ óçj­á¬5U¯;¥€n±oW#°q½¡$¾§=OÍGÑÿ…F1¿|}'€šÙϤ’ûï™áìþç®<–ã¼5bI1™°ê.oô¹p¬×¢-cqÁ§‘¯óu×¼#¬¿#õ× «ÖF©\¶–l¾ŸÔW¨®Õ ´¢%õmDbª²ºôZ™¼P­4ò¥Š?|#MÆËcÂ_»AÖd1HÁöŽOÖǧÿ·ýî?›ÍÿA $ÿJ ù_6{ÀÿíÊ©4æLWK1~jg‡EíÂøŠse½VZP¹ºá¹›ËÈÒÍ æÎ 6Ö¬±í+ÌTjo²§ÇßxŠ|(ý°¿' ‡ø°2;'½hÖ7¥yß%CVµ$wýFõÚͼ±+ KëZ7j—¨ÚÓ®³Ü.£EžƒÍ,ª‰~À¨ÂÃLã·šq¦™ó‚dÖ™dú–%O ¦Ö_ZD3ë…õBË@KOåÉ)Uޱ”{Ê‹áý9Pîíz¸hÛr©èw¥œÔµ­¤ã…÷zTæa¨Ñg¤­â‡ètÑÎR±)bL»š½œ’‡9Ašï@ÿT~ÔþOlàwBý·¹ÿ¿Ô Wþ“Φö»ñ X‹«%m"¡ðuĬ‰óçÙ­_ˆ´Ex#÷º3OËæÿ“¶DÏÿÔðP*íÑÿÏf2ú_»ò„…Ê~æç¦Ï ÕJþ¦˜áÐ$X·•¶Þþ»¢ŽlÕ<•b©Fáæ j¯^³= ñOZœ‡‘RE,˜EpJ?X‹EuÛ¨B™³Ú%}£á.ôpØœ®Än´Qe÷Tâäõ¡‘Á|T;Oo´î|~ vK¾¦Éà(ØQFQbÙÍ.C¡å¨f^‰Ñ¹zi¥TÉ—ÏûZS¥8Ryk’^Uø ™Üò´‚$—ÌJÔ-4Ôµq0y½Vª{¤Ô`H£b£šTU ƒj_¯©›"z‘8Ð"zËŸ® ÷¾¶»‘±š®ŠR-j£·ÜM"±Íû£ályÃÓXe0$¬™¦uŽ«jzË´ž9µ‹@>XÚõÙ ë@’B6ƒe6jp*~2ëTÌ{!-56ÏÁ£ØPk¤}¶ˆM¥K Òºtë‘ ÜŸ»{ˆ Q½ÔLó‘ò¥2ˆìË%hg¯’%›_;S¸,%ºTi›¡W*¶]´Õù‡ _‘fÎlè.i ñCDfó[Ñ2mùðµ,ÛÓné…÷•b;Êwé°¯øTºòµÑ#ûG¾ò‡è‚:¡¸ß©À™ð[b#}½©½K攞8<_Ì #ç!k$áÓ~¶ê#žíR€pwžÛ­ÐbšS-MýQ]³:ÞïÜÁ‰.T šººduæ.5nç&/U°c³—Êß¹éË ±­Lya”ÑOçK"®×â´÷ÞìõÍz®Ê3íõ€×§Š{mBMÛf7¬¹uÇz²²¾&/}csÝ,îlKÅ^Ù=ã8õà~EÈé±¥tg²æ iZÚbiÍ^hä×j‹Õ `‘ðg·94s¿]›ðÌÌ‹çέ­9N×–‹W3 ­Ò£@០M‹ã¹ Åó§X»š{V¢—<|kàýwnæ¶_¢åe2±håg}Ív¤^!J›K즼¥\]F× Rû°.-ì Yø|¹³p¿¸–¼ðHR­ B¨ ªxjo`ìb¿ôM¿aãÀ­—‹.khs¾XEYw­n×lÈ‚­à±6J°DVªÖüDn1×+J¿FÎW\kèhþØQ6¦Ã@e-!Û!nø;'¬ +³µÂM‡Ú-¡s‚` |¯å¯'¥@%ýú+Ô1YO Œ ú1E“ž†ö1“quØÏ S†í®ùDtÍê`»+†­oPÍ$÷ßTÂ:‡¸Né/Í{B²01 ó@ƒ<>ÒIAS³<äõGQÃ˪Û@ÝS.I1[ì3ÃmV§ l¼æ]#¼ ’»0k×i_䮾U?.ymNÈÞ´]¡×Üž©áöøæí6×ÑDÿ+ʸþ2iÔÿÊ¢ÈþÇ.<þhoŠûà7ž–ÀÃÜDp¡FQ3@½¦_=ieýê'“ªߕ„ë&Ø›„nOY9Xb߸Až¼>\ÿîò”TˆΚ>~<¥èQ"ùrY “Œt?<žô(£-»îÈ“]ò×ïuÁ®&ÍL.E2IÍMÖéx‚Çó唨P  ÝóÆr{+,¯òð[w¥ë)Ó (å<=8>Â÷¨‰›¦'Œ'—+Œ–}alÕ†aåÝEÍ õj£Z¨²ˆRžÔÖÜfì5ÉÝWvÿ·¾WþŸÒJÿÓõÿÑëÿ.<Æú?3dþÅ íõéØÑǃ–jQÏë“á³Á’Ëqà {:òŽå¡IÔBÀ(OìdQ¿Fê5"--i"£q–2êÖ|àǨ)év‰òYÞóG³ÿµSæÿ›Ñÿl*“Õôÿìíæ`¹+Dó?'Ä9Cã?_,* ±+Rëfm<¿ºŽ#ZUõ×j'rWª5k¤ˆnGóº â¹c5s•²sîíYbÎ!§ïb-Ä÷¡TªéšƒoQ¾"¼—Eª RE¨‡›é^CȹW(£Vi…Õœ*[ư ´Öå¶Ó ƒ_D‚V¹¹5ŽE ¥ ˜ÛtË¡«ë^šA€XžhÚ0$=‡¸¹€ÜÜ~8¼ Ácv•lõÐ1·¿ååãøôÃÏ÷¶~2@9òú‘¤@ óH ÷x1p´˜oñ<3ï2>ˆ–öŒZÖÀ@Ý.®WŠù @v Ú_± x¿¾‰ŠF¥ Šé„î†4ÖšÝX­ùŸ<ãÈmý|#×ÒÙFnë繨3ÃO‚Çsÿ'Ä?Íïÿ§SÒþÛÐP:-ì¿¥‡üïÎÖWÅF¼Vϯ¬å­j¥`Gë„ù3½q`àIö¨©ï”+;TG3ùïààÇþGz0›<˜ÿ»ñüÃþä±£3¥B½êT—Öý%g=_¶ëÅRÕZ¨–×…úÞT© è”°ÂjÝo ƒWV*ÙŸLÑðdJ'“'޽P¯¾Ö.4º»?16~r|rìD߉±l®/•šHö˜H¥ú’É\rüd b³é]=À˜ S"]½òó²@Êk…„aOMæÆsƒ¹©¾\zj¨/›œë;™›:Ñ7<•9‘9qâäøÐĉ]ÇŽNVŠTù±£gËÕ¥|ùeAúîæ~W+Ë¥•u©ùt¡œo b¹ƒM©ÕmN$äÈöÒúÊ”*ÀnŸ¶´_9o—í¼c»ÑÆoH 2ª÷5‡šÑšªÓЛýZ;ûsPÕ5{|yÅßþ-”6¶^*û“[.Ë‘Ñ6/ð¶V¢j_˃Áp†A©ÙõFɇs¥¢û{¶ZÄ-ëTîüÂd`nÈÁâxð<ÏÁsð<ÏÁsðìõóÿÊÉ.(ldns-1.6.17/linktest.c0000664000175100017510000000021012264060151014105 0ustar willemwillem #include "ldns/config.h" #include int main(void) { ldns_rr *rr = ldns_rr_new(); ldns_rr_free(rr); return 0; } ldns-1.6.17/config.guess0000755000175100017510000012743212264060154014445 0ustar willemwillem#! /bin/sh # Attempt to guess a canonical system name. # Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, # 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, # 2011, 2012 Free Software Foundation, Inc. timestamp='2012-02-10' # This file is free software; you can redistribute it and/or modify it # under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, but # WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU # General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, see . # # As a special exception to the GNU General Public License, if you # distribute this file as part of a program that contains a # configuration script generated by Autoconf, you may include it under # the same distribution terms that you use for the rest of that program. # Originally written by Per Bothner. Please send patches (context # diff format) to and include a ChangeLog # entry. # # This script attempts to guess a canonical system name similar to # config.sub. If it succeeds, it prints the system name on stdout, and # exits with 0. Otherwise, it exits with 1. # # You can get the latest version of this script from: # http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.guess;hb=HEAD me=`echo "$0" | sed -e 's,.*/,,'` usage="\ Usage: $0 [OPTION] Output the configuration name of the system \`$me' is run on. Operation modes: -h, --help print this help, then exit -t, --time-stamp print date of last modification, then exit -v, --version print version number, then exit Report bugs and patches to ." version="\ GNU config.guess ($timestamp) Originally written by Per Bothner. Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012 Free Software Foundation, Inc. This is free software; see the source for copying conditions. There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE." help=" Try \`$me --help' for more information." # Parse command line while test $# -gt 0 ; do case $1 in --time-stamp | --time* | -t ) echo "$timestamp" ; exit ;; --version | -v ) echo "$version" ; exit ;; --help | --h* | -h ) echo "$usage"; exit ;; -- ) # Stop option processing shift; break ;; - ) # Use stdin as input. break ;; -* ) echo "$me: invalid option $1$help" >&2 exit 1 ;; * ) break ;; esac done if test $# != 0; then echo "$me: too many arguments$help" >&2 exit 1 fi trap 'exit 1' 1 2 15 # CC_FOR_BUILD -- compiler used by this script. Note that the use of a # compiler to aid in system detection is discouraged as it requires # temporary files to be created and, as you can see below, it is a # headache to deal with in a portable fashion. # Historically, `CC_FOR_BUILD' used to be named `HOST_CC'. We still # use `HOST_CC' if defined, but it is deprecated. # Portable tmp directory creation inspired by the Autoconf team. set_cc_for_build=' trap "exitcode=\$?; (rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null) && exit \$exitcode" 0 ; trap "rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null; exit 1" 1 2 13 15 ; : ${TMPDIR=/tmp} ; { tmp=`(umask 077 && mktemp -d "$TMPDIR/cgXXXXXX") 2>/dev/null` && test -n "$tmp" && test -d "$tmp" ; } || { test -n "$RANDOM" && tmp=$TMPDIR/cg$$-$RANDOM && (umask 077 && mkdir $tmp) ; } || { tmp=$TMPDIR/cg-$$ && (umask 077 && mkdir $tmp) && echo "Warning: creating insecure temp directory" >&2 ; } || { echo "$me: cannot create a temporary directory in $TMPDIR" >&2 ; exit 1 ; } ; dummy=$tmp/dummy ; tmpfiles="$dummy.c $dummy.o $dummy.rel $dummy" ; case $CC_FOR_BUILD,$HOST_CC,$CC in ,,) echo "int x;" > $dummy.c ; for c in cc gcc c89 c99 ; do if ($c -c -o $dummy.o $dummy.c) >/dev/null 2>&1 ; then CC_FOR_BUILD="$c"; break ; fi ; done ; if test x"$CC_FOR_BUILD" = x ; then CC_FOR_BUILD=no_compiler_found ; fi ;; ,,*) CC_FOR_BUILD=$CC ;; ,*,*) CC_FOR_BUILD=$HOST_CC ;; esac ; set_cc_for_build= ;' # This is needed to find uname on a Pyramid OSx when run in the BSD universe. # (ghazi@noc.rutgers.edu 1994-08-24) if (test -f /.attbin/uname) >/dev/null 2>&1 ; then PATH=$PATH:/.attbin ; export PATH fi UNAME_MACHINE=`(uname -m) 2>/dev/null` || UNAME_MACHINE=unknown UNAME_RELEASE=`(uname -r) 2>/dev/null` || UNAME_RELEASE=unknown UNAME_SYSTEM=`(uname -s) 2>/dev/null` || UNAME_SYSTEM=unknown UNAME_VERSION=`(uname -v) 2>/dev/null` || UNAME_VERSION=unknown # Note: order is significant - the case branches are not exclusive. case "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" in *:NetBSD:*:*) # NetBSD (nbsd) targets should (where applicable) match one or # more of the tuples: *-*-netbsdelf*, *-*-netbsdaout*, # *-*-netbsdecoff* and *-*-netbsd*. For targets that recently # switched to ELF, *-*-netbsd* would select the old # object file format. This provides both forward # compatibility and a consistent mechanism for selecting the # object file format. # # Note: NetBSD doesn't particularly care about the vendor # portion of the name. We always set it to "unknown". sysctl="sysctl -n hw.machine_arch" UNAME_MACHINE_ARCH=`(/sbin/$sysctl 2>/dev/null || \ /usr/sbin/$sysctl 2>/dev/null || echo unknown)` case "${UNAME_MACHINE_ARCH}" in armeb) machine=armeb-unknown ;; arm*) machine=arm-unknown ;; sh3el) machine=shl-unknown ;; sh3eb) machine=sh-unknown ;; sh5el) machine=sh5le-unknown ;; *) machine=${UNAME_MACHINE_ARCH}-unknown ;; esac # The Operating System including object format, if it has switched # to ELF recently, or will in the future. case "${UNAME_MACHINE_ARCH}" in arm*|i386|m68k|ns32k|sh3*|sparc|vax) eval $set_cc_for_build if echo __ELF__ | $CC_FOR_BUILD -E - 2>/dev/null \ | grep -q __ELF__ then # Once all utilities can be ECOFF (netbsdecoff) or a.out (netbsdaout). # Return netbsd for either. FIX? os=netbsd else os=netbsdelf fi ;; *) os=netbsd ;; esac # The OS release # Debian GNU/NetBSD machines have a different userland, and # thus, need a distinct triplet. However, they do not need # kernel version information, so it can be replaced with a # suitable tag, in the style of linux-gnu. case "${UNAME_VERSION}" in Debian*) release='-gnu' ;; *) release=`echo ${UNAME_RELEASE}|sed -e 's/[-_].*/\./'` ;; esac # Since CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM: # contains redundant information, the shorter form: # CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM is used. echo "${machine}-${os}${release}" exit ;; *:OpenBSD:*:*) UNAME_MACHINE_ARCH=`arch | sed 's/OpenBSD.//'` echo ${UNAME_MACHINE_ARCH}-unknown-openbsd${UNAME_RELEASE} exit ;; *:ekkoBSD:*:*) echo ${UNAME_MACHINE}-unknown-ekkobsd${UNAME_RELEASE} exit ;; *:SolidBSD:*:*) echo ${UNAME_MACHINE}-unknown-solidbsd${UNAME_RELEASE} exit ;; macppc:MirBSD:*:*) echo powerpc-unknown-mirbsd${UNAME_RELEASE} exit ;; *:MirBSD:*:*) echo ${UNAME_MACHINE}-unknown-mirbsd${UNAME_RELEASE} exit ;; alpha:OSF1:*:*) case $UNAME_RELEASE in *4.0) UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $3}'` ;; *5.*) UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $4}'` ;; esac # According to Compaq, /usr/sbin/psrinfo has been available on # OSF/1 and Tru64 systems produced since 1995. I hope that # covers most systems running today. This code pipes the CPU # types through head -n 1, so we only detect the type of CPU 0. ALPHA_CPU_TYPE=`/usr/sbin/psrinfo -v | sed -n -e 's/^ The alpha \(.*\) processor.*$/\1/p' | head -n 1` case "$ALPHA_CPU_TYPE" in "EV4 (21064)") UNAME_MACHINE="alpha" ;; "EV4.5 (21064)") UNAME_MACHINE="alpha" ;; "LCA4 (21066/21068)") UNAME_MACHINE="alpha" ;; "EV5 (21164)") UNAME_MACHINE="alphaev5" ;; "EV5.6 (21164A)") UNAME_MACHINE="alphaev56" ;; "EV5.6 (21164PC)") UNAME_MACHINE="alphapca56" ;; "EV5.7 (21164PC)") UNAME_MACHINE="alphapca57" ;; "EV6 (21264)") UNAME_MACHINE="alphaev6" ;; "EV6.7 (21264A)") UNAME_MACHINE="alphaev67" ;; "EV6.8CB (21264C)") UNAME_MACHINE="alphaev68" ;; "EV6.8AL (21264B)") UNAME_MACHINE="alphaev68" ;; "EV6.8CX (21264D)") UNAME_MACHINE="alphaev68" ;; "EV6.9A (21264/EV69A)") UNAME_MACHINE="alphaev69" ;; "EV7 (21364)") UNAME_MACHINE="alphaev7" ;; "EV7.9 (21364A)") UNAME_MACHINE="alphaev79" ;; esac # A Pn.n version is a patched version. # A Vn.n version is a released version. # A Tn.n version is a released field test version. # A Xn.n version is an unreleased experimental baselevel. # 1.2 uses "1.2" for uname -r. echo ${UNAME_MACHINE}-dec-osf`echo ${UNAME_RELEASE} | sed -e 's/^[PVTX]//' | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` # Reset EXIT trap before exiting to avoid spurious non-zero exit code. exitcode=$? trap '' 0 exit $exitcode ;; Alpha\ *:Windows_NT*:*) # How do we know it's Interix rather than the generic POSIX subsystem? # Should we change UNAME_MACHINE based on the output of uname instead # of the specific Alpha model? echo alpha-pc-interix exit ;; 21064:Windows_NT:50:3) echo alpha-dec-winnt3.5 exit ;; Amiga*:UNIX_System_V:4.0:*) echo m68k-unknown-sysv4 exit ;; *:[Aa]miga[Oo][Ss]:*:*) echo ${UNAME_MACHINE}-unknown-amigaos exit ;; *:[Mm]orph[Oo][Ss]:*:*) echo ${UNAME_MACHINE}-unknown-morphos exit ;; *:OS/390:*:*) echo i370-ibm-openedition exit ;; *:z/VM:*:*) echo s390-ibm-zvmoe exit ;; *:OS400:*:*) echo powerpc-ibm-os400 exit ;; arm:RISC*:1.[012]*:*|arm:riscix:1.[012]*:*) echo arm-acorn-riscix${UNAME_RELEASE} exit ;; arm:riscos:*:*|arm:RISCOS:*:*) echo arm-unknown-riscos exit ;; SR2?01:HI-UX/MPP:*:* | SR8000:HI-UX/MPP:*:*) echo hppa1.1-hitachi-hiuxmpp exit ;; Pyramid*:OSx*:*:* | MIS*:OSx*:*:* | MIS*:SMP_DC-OSx*:*:*) # akee@wpdis03.wpafb.af.mil (Earle F. Ake) contributed MIS and NILE. if test "`(/bin/universe) 2>/dev/null`" = att ; then echo pyramid-pyramid-sysv3 else echo pyramid-pyramid-bsd fi exit ;; NILE*:*:*:dcosx) echo pyramid-pyramid-svr4 exit ;; DRS?6000:unix:4.0:6*) echo sparc-icl-nx6 exit ;; DRS?6000:UNIX_SV:4.2*:7* | DRS?6000:isis:4.2*:7*) case `/usr/bin/uname -p` in sparc) echo sparc-icl-nx7; exit ;; esac ;; s390x:SunOS:*:*) echo ${UNAME_MACHINE}-ibm-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` exit ;; sun4H:SunOS:5.*:*) echo sparc-hal-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` exit ;; sun4*:SunOS:5.*:* | tadpole*:SunOS:5.*:*) echo sparc-sun-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` exit ;; i86pc:AuroraUX:5.*:* | i86xen:AuroraUX:5.*:*) echo i386-pc-auroraux${UNAME_RELEASE} exit ;; i86pc:SunOS:5.*:* | i86xen:SunOS:5.*:*) eval $set_cc_for_build SUN_ARCH="i386" # If there is a compiler, see if it is configured for 64-bit objects. # Note that the Sun cc does not turn __LP64__ into 1 like gcc does. # This test works for both compilers. if [ "$CC_FOR_BUILD" != 'no_compiler_found' ]; then if (echo '#ifdef __amd64'; echo IS_64BIT_ARCH; echo '#endif') | \ (CCOPTS= $CC_FOR_BUILD -E - 2>/dev/null) | \ grep IS_64BIT_ARCH >/dev/null then SUN_ARCH="x86_64" fi fi echo ${SUN_ARCH}-pc-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` exit ;; sun4*:SunOS:6*:*) # According to config.sub, this is the proper way to canonicalize # SunOS6. Hard to guess exactly what SunOS6 will be like, but # it's likely to be more like Solaris than SunOS4. echo sparc-sun-solaris3`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` exit ;; sun4*:SunOS:*:*) case "`/usr/bin/arch -k`" in Series*|S4*) UNAME_RELEASE=`uname -v` ;; esac # Japanese Language versions have a version number like `4.1.3-JL'. echo sparc-sun-sunos`echo ${UNAME_RELEASE}|sed -e 's/-/_/'` exit ;; sun3*:SunOS:*:*) echo m68k-sun-sunos${UNAME_RELEASE} exit ;; sun*:*:4.2BSD:*) UNAME_RELEASE=`(sed 1q /etc/motd | awk '{print substr($5,1,3)}') 2>/dev/null` test "x${UNAME_RELEASE}" = "x" && UNAME_RELEASE=3 case "`/bin/arch`" in sun3) echo m68k-sun-sunos${UNAME_RELEASE} ;; sun4) echo sparc-sun-sunos${UNAME_RELEASE} ;; esac exit ;; aushp:SunOS:*:*) echo sparc-auspex-sunos${UNAME_RELEASE} exit ;; # The situation for MiNT is a little confusing. The machine name # can be virtually everything (everything which is not # "atarist" or "atariste" at least should have a processor # > m68000). The system name ranges from "MiNT" over "FreeMiNT" # to the lowercase version "mint" (or "freemint"). Finally # the system name "TOS" denotes a system which is actually not # MiNT. But MiNT is downward compatible to TOS, so this should # be no problem. atarist[e]:*MiNT:*:* | atarist[e]:*mint:*:* | atarist[e]:*TOS:*:*) echo m68k-atari-mint${UNAME_RELEASE} exit ;; atari*:*MiNT:*:* | atari*:*mint:*:* | atarist[e]:*TOS:*:*) echo m68k-atari-mint${UNAME_RELEASE} exit ;; *falcon*:*MiNT:*:* | *falcon*:*mint:*:* | *falcon*:*TOS:*:*) echo m68k-atari-mint${UNAME_RELEASE} exit ;; milan*:*MiNT:*:* | milan*:*mint:*:* | *milan*:*TOS:*:*) echo m68k-milan-mint${UNAME_RELEASE} exit ;; hades*:*MiNT:*:* | hades*:*mint:*:* | *hades*:*TOS:*:*) echo m68k-hades-mint${UNAME_RELEASE} exit ;; *:*MiNT:*:* | *:*mint:*:* | *:*TOS:*:*) echo m68k-unknown-mint${UNAME_RELEASE} exit ;; m68k:machten:*:*) echo m68k-apple-machten${UNAME_RELEASE} exit ;; powerpc:machten:*:*) echo powerpc-apple-machten${UNAME_RELEASE} exit ;; RISC*:Mach:*:*) echo mips-dec-mach_bsd4.3 exit ;; RISC*:ULTRIX:*:*) echo mips-dec-ultrix${UNAME_RELEASE} exit ;; VAX*:ULTRIX*:*:*) echo vax-dec-ultrix${UNAME_RELEASE} exit ;; 2020:CLIX:*:* | 2430:CLIX:*:*) echo clipper-intergraph-clix${UNAME_RELEASE} exit ;; mips:*:*:UMIPS | mips:*:*:RISCos) eval $set_cc_for_build sed 's/^ //' << EOF >$dummy.c #ifdef __cplusplus #include /* for printf() prototype */ int main (int argc, char *argv[]) { #else int main (argc, argv) int argc; char *argv[]; { #endif #if defined (host_mips) && defined (MIPSEB) #if defined (SYSTYPE_SYSV) printf ("mips-mips-riscos%ssysv\n", argv[1]); exit (0); #endif #if defined (SYSTYPE_SVR4) printf ("mips-mips-riscos%ssvr4\n", argv[1]); exit (0); #endif #if defined (SYSTYPE_BSD43) || defined(SYSTYPE_BSD) printf ("mips-mips-riscos%sbsd\n", argv[1]); exit (0); #endif #endif exit (-1); } EOF $CC_FOR_BUILD -o $dummy $dummy.c && dummyarg=`echo "${UNAME_RELEASE}" | sed -n 's/\([0-9]*\).*/\1/p'` && SYSTEM_NAME=`$dummy $dummyarg` && { echo "$SYSTEM_NAME"; exit; } echo mips-mips-riscos${UNAME_RELEASE} exit ;; Motorola:PowerMAX_OS:*:*) echo powerpc-motorola-powermax exit ;; Motorola:*:4.3:PL8-*) echo powerpc-harris-powermax exit ;; Night_Hawk:*:*:PowerMAX_OS | Synergy:PowerMAX_OS:*:*) echo powerpc-harris-powermax exit ;; Night_Hawk:Power_UNIX:*:*) echo powerpc-harris-powerunix exit ;; m88k:CX/UX:7*:*) echo m88k-harris-cxux7 exit ;; m88k:*:4*:R4*) echo m88k-motorola-sysv4 exit ;; m88k:*:3*:R3*) echo m88k-motorola-sysv3 exit ;; AViiON:dgux:*:*) # DG/UX returns AViiON for all architectures UNAME_PROCESSOR=`/usr/bin/uname -p` if [ $UNAME_PROCESSOR = mc88100 ] || [ $UNAME_PROCESSOR = mc88110 ] then if [ ${TARGET_BINARY_INTERFACE}x = m88kdguxelfx ] || \ [ ${TARGET_BINARY_INTERFACE}x = x ] then echo m88k-dg-dgux${UNAME_RELEASE} else echo m88k-dg-dguxbcs${UNAME_RELEASE} fi else echo i586-dg-dgux${UNAME_RELEASE} fi exit ;; M88*:DolphinOS:*:*) # DolphinOS (SVR3) echo m88k-dolphin-sysv3 exit ;; M88*:*:R3*:*) # Delta 88k system running SVR3 echo m88k-motorola-sysv3 exit ;; XD88*:*:*:*) # Tektronix XD88 system running UTekV (SVR3) echo m88k-tektronix-sysv3 exit ;; Tek43[0-9][0-9]:UTek:*:*) # Tektronix 4300 system running UTek (BSD) echo m68k-tektronix-bsd exit ;; *:IRIX*:*:*) echo mips-sgi-irix`echo ${UNAME_RELEASE}|sed -e 's/-/_/g'` exit ;; ????????:AIX?:[12].1:2) # AIX 2.2.1 or AIX 2.1.1 is RT/PC AIX. echo romp-ibm-aix # uname -m gives an 8 hex-code CPU id exit ;; # Note that: echo "'`uname -s`'" gives 'AIX ' i*86:AIX:*:*) echo i386-ibm-aix exit ;; ia64:AIX:*:*) if [ -x /usr/bin/oslevel ] ; then IBM_REV=`/usr/bin/oslevel` else IBM_REV=${UNAME_VERSION}.${UNAME_RELEASE} fi echo ${UNAME_MACHINE}-ibm-aix${IBM_REV} exit ;; *:AIX:2:3) if grep bos325 /usr/include/stdio.h >/dev/null 2>&1; then eval $set_cc_for_build sed 's/^ //' << EOF >$dummy.c #include main() { if (!__power_pc()) exit(1); puts("powerpc-ibm-aix3.2.5"); exit(0); } EOF if $CC_FOR_BUILD -o $dummy $dummy.c && SYSTEM_NAME=`$dummy` then echo "$SYSTEM_NAME" else echo rs6000-ibm-aix3.2.5 fi elif grep bos324 /usr/include/stdio.h >/dev/null 2>&1; then echo rs6000-ibm-aix3.2.4 else echo rs6000-ibm-aix3.2 fi exit ;; *:AIX:*:[4567]) IBM_CPU_ID=`/usr/sbin/lsdev -C -c processor -S available | sed 1q | awk '{ print $1 }'` if /usr/sbin/lsattr -El ${IBM_CPU_ID} | grep ' POWER' >/dev/null 2>&1; then IBM_ARCH=rs6000 else IBM_ARCH=powerpc fi if [ -x /usr/bin/oslevel ] ; then IBM_REV=`/usr/bin/oslevel` else IBM_REV=${UNAME_VERSION}.${UNAME_RELEASE} fi echo ${IBM_ARCH}-ibm-aix${IBM_REV} exit ;; *:AIX:*:*) echo rs6000-ibm-aix exit ;; ibmrt:4.4BSD:*|romp-ibm:BSD:*) echo romp-ibm-bsd4.4 exit ;; ibmrt:*BSD:*|romp-ibm:BSD:*) # covers RT/PC BSD and echo romp-ibm-bsd${UNAME_RELEASE} # 4.3 with uname added to exit ;; # report: romp-ibm BSD 4.3 *:BOSX:*:*) echo rs6000-bull-bosx exit ;; DPX/2?00:B.O.S.:*:*) echo m68k-bull-sysv3 exit ;; 9000/[34]??:4.3bsd:1.*:*) echo m68k-hp-bsd exit ;; hp300:4.4BSD:*:* | 9000/[34]??:4.3bsd:2.*:*) echo m68k-hp-bsd4.4 exit ;; 9000/[34678]??:HP-UX:*:*) HPUX_REV=`echo ${UNAME_RELEASE}|sed -e 's/[^.]*.[0B]*//'` case "${UNAME_MACHINE}" in 9000/31? ) HP_ARCH=m68000 ;; 9000/[34]?? ) HP_ARCH=m68k ;; 9000/[678][0-9][0-9]) if [ -x /usr/bin/getconf ]; then sc_cpu_version=`/usr/bin/getconf SC_CPU_VERSION 2>/dev/null` sc_kernel_bits=`/usr/bin/getconf SC_KERNEL_BITS 2>/dev/null` case "${sc_cpu_version}" in 523) HP_ARCH="hppa1.0" ;; # CPU_PA_RISC1_0 528) HP_ARCH="hppa1.1" ;; # CPU_PA_RISC1_1 532) # CPU_PA_RISC2_0 case "${sc_kernel_bits}" in 32) HP_ARCH="hppa2.0n" ;; 64) HP_ARCH="hppa2.0w" ;; '') HP_ARCH="hppa2.0" ;; # HP-UX 10.20 esac ;; esac fi if [ "${HP_ARCH}" = "" ]; then eval $set_cc_for_build sed 's/^ //' << EOF >$dummy.c #define _HPUX_SOURCE #include #include int main () { #if defined(_SC_KERNEL_BITS) long bits = sysconf(_SC_KERNEL_BITS); #endif long cpu = sysconf (_SC_CPU_VERSION); switch (cpu) { case CPU_PA_RISC1_0: puts ("hppa1.0"); break; case CPU_PA_RISC1_1: puts ("hppa1.1"); break; case CPU_PA_RISC2_0: #if defined(_SC_KERNEL_BITS) switch (bits) { case 64: puts ("hppa2.0w"); break; case 32: puts ("hppa2.0n"); break; default: puts ("hppa2.0"); break; } break; #else /* !defined(_SC_KERNEL_BITS) */ puts ("hppa2.0"); break; #endif default: puts ("hppa1.0"); break; } exit (0); } EOF (CCOPTS= $CC_FOR_BUILD -o $dummy $dummy.c 2>/dev/null) && HP_ARCH=`$dummy` test -z "$HP_ARCH" && HP_ARCH=hppa fi ;; esac if [ ${HP_ARCH} = "hppa2.0w" ] then eval $set_cc_for_build # hppa2.0w-hp-hpux* has a 64-bit kernel and a compiler generating # 32-bit code. hppa64-hp-hpux* has the same kernel and a compiler # generating 64-bit code. GNU and HP use different nomenclature: # # $ CC_FOR_BUILD=cc ./config.guess # => hppa2.0w-hp-hpux11.23 # $ CC_FOR_BUILD="cc +DA2.0w" ./config.guess # => hppa64-hp-hpux11.23 if echo __LP64__ | (CCOPTS= $CC_FOR_BUILD -E - 2>/dev/null) | grep -q __LP64__ then HP_ARCH="hppa2.0w" else HP_ARCH="hppa64" fi fi echo ${HP_ARCH}-hp-hpux${HPUX_REV} exit ;; ia64:HP-UX:*:*) HPUX_REV=`echo ${UNAME_RELEASE}|sed -e 's/[^.]*.[0B]*//'` echo ia64-hp-hpux${HPUX_REV} exit ;; 3050*:HI-UX:*:*) eval $set_cc_for_build sed 's/^ //' << EOF >$dummy.c #include int main () { long cpu = sysconf (_SC_CPU_VERSION); /* The order matters, because CPU_IS_HP_MC68K erroneously returns true for CPU_PA_RISC1_0. CPU_IS_PA_RISC returns correct results, however. */ if (CPU_IS_PA_RISC (cpu)) { switch (cpu) { case CPU_PA_RISC1_0: puts ("hppa1.0-hitachi-hiuxwe2"); break; case CPU_PA_RISC1_1: puts ("hppa1.1-hitachi-hiuxwe2"); break; case CPU_PA_RISC2_0: puts ("hppa2.0-hitachi-hiuxwe2"); break; default: puts ("hppa-hitachi-hiuxwe2"); break; } } else if (CPU_IS_HP_MC68K (cpu)) puts ("m68k-hitachi-hiuxwe2"); else puts ("unknown-hitachi-hiuxwe2"); exit (0); } EOF $CC_FOR_BUILD -o $dummy $dummy.c && SYSTEM_NAME=`$dummy` && { echo "$SYSTEM_NAME"; exit; } echo unknown-hitachi-hiuxwe2 exit ;; 9000/7??:4.3bsd:*:* | 9000/8?[79]:4.3bsd:*:* ) echo hppa1.1-hp-bsd exit ;; 9000/8??:4.3bsd:*:*) echo hppa1.0-hp-bsd exit ;; *9??*:MPE/iX:*:* | *3000*:MPE/iX:*:*) echo hppa1.0-hp-mpeix exit ;; hp7??:OSF1:*:* | hp8?[79]:OSF1:*:* ) echo hppa1.1-hp-osf exit ;; hp8??:OSF1:*:*) echo hppa1.0-hp-osf exit ;; i*86:OSF1:*:*) if [ -x /usr/sbin/sysversion ] ; then echo ${UNAME_MACHINE}-unknown-osf1mk else echo ${UNAME_MACHINE}-unknown-osf1 fi exit ;; parisc*:Lites*:*:*) echo hppa1.1-hp-lites exit ;; C1*:ConvexOS:*:* | convex:ConvexOS:C1*:*) echo c1-convex-bsd exit ;; C2*:ConvexOS:*:* | convex:ConvexOS:C2*:*) if getsysinfo -f scalar_acc then echo c32-convex-bsd else echo c2-convex-bsd fi exit ;; C34*:ConvexOS:*:* | convex:ConvexOS:C34*:*) echo c34-convex-bsd exit ;; C38*:ConvexOS:*:* | convex:ConvexOS:C38*:*) echo c38-convex-bsd exit ;; C4*:ConvexOS:*:* | convex:ConvexOS:C4*:*) echo c4-convex-bsd exit ;; CRAY*Y-MP:*:*:*) echo ymp-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' exit ;; CRAY*[A-Z]90:*:*:*) echo ${UNAME_MACHINE}-cray-unicos${UNAME_RELEASE} \ | sed -e 's/CRAY.*\([A-Z]90\)/\1/' \ -e y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/ \ -e 's/\.[^.]*$/.X/' exit ;; CRAY*TS:*:*:*) echo t90-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' exit ;; CRAY*T3E:*:*:*) echo alphaev5-cray-unicosmk${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' exit ;; CRAY*SV1:*:*:*) echo sv1-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' exit ;; *:UNICOS/mp:*:*) echo craynv-cray-unicosmp${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' exit ;; F30[01]:UNIX_System_V:*:* | F700:UNIX_System_V:*:*) FUJITSU_PROC=`uname -m | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` FUJITSU_SYS=`uname -p | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/\///'` FUJITSU_REL=`echo ${UNAME_RELEASE} | sed -e 's/ /_/'` echo "${FUJITSU_PROC}-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}" exit ;; 5000:UNIX_System_V:4.*:*) FUJITSU_SYS=`uname -p | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/\///'` FUJITSU_REL=`echo ${UNAME_RELEASE} | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/ /_/'` echo "sparc-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}" exit ;; i*86:BSD/386:*:* | i*86:BSD/OS:*:* | *:Ascend\ Embedded/OS:*:*) echo ${UNAME_MACHINE}-pc-bsdi${UNAME_RELEASE} exit ;; sparc*:BSD/OS:*:*) echo sparc-unknown-bsdi${UNAME_RELEASE} exit ;; *:BSD/OS:*:*) echo ${UNAME_MACHINE}-unknown-bsdi${UNAME_RELEASE} exit ;; *:FreeBSD:*:*) UNAME_PROCESSOR=`/usr/bin/uname -p` case ${UNAME_PROCESSOR} in amd64) echo x86_64-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` ;; *) echo ${UNAME_PROCESSOR}-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` ;; esac exit ;; i*:CYGWIN*:*) echo ${UNAME_MACHINE}-pc-cygwin exit ;; *:MINGW*:*) echo ${UNAME_MACHINE}-pc-mingw32 exit ;; i*:MSYS*:*) echo ${UNAME_MACHINE}-pc-msys exit ;; i*:windows32*:*) # uname -m includes "-pc" on this system. echo ${UNAME_MACHINE}-mingw32 exit ;; i*:PW*:*) echo ${UNAME_MACHINE}-pc-pw32 exit ;; *:Interix*:*) case ${UNAME_MACHINE} in x86) echo i586-pc-interix${UNAME_RELEASE} exit ;; authenticamd | genuineintel | EM64T) echo x86_64-unknown-interix${UNAME_RELEASE} exit ;; IA64) echo ia64-unknown-interix${UNAME_RELEASE} exit ;; esac ;; [345]86:Windows_95:* | [345]86:Windows_98:* | [345]86:Windows_NT:*) echo i${UNAME_MACHINE}-pc-mks exit ;; 8664:Windows_NT:*) echo x86_64-pc-mks exit ;; i*:Windows_NT*:* | Pentium*:Windows_NT*:*) # How do we know it's Interix rather than the generic POSIX subsystem? # It also conflicts with pre-2.0 versions of AT&T UWIN. Should we # UNAME_MACHINE based on the output of uname instead of i386? echo i586-pc-interix exit ;; i*:UWIN*:*) echo ${UNAME_MACHINE}-pc-uwin exit ;; amd64:CYGWIN*:*:* | x86_64:CYGWIN*:*:*) echo x86_64-unknown-cygwin exit ;; p*:CYGWIN*:*) echo powerpcle-unknown-cygwin exit ;; prep*:SunOS:5.*:*) echo powerpcle-unknown-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` exit ;; *:GNU:*:*) # the GNU system echo `echo ${UNAME_MACHINE}|sed -e 's,[-/].*$,,'`-unknown-gnu`echo ${UNAME_RELEASE}|sed -e 's,/.*$,,'` exit ;; *:GNU/*:*:*) # other systems with GNU libc and userland echo ${UNAME_MACHINE}-unknown-`echo ${UNAME_SYSTEM} | sed 's,^[^/]*/,,' | tr '[A-Z]' '[a-z]'``echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'`-gnu exit ;; i*86:Minix:*:*) echo ${UNAME_MACHINE}-pc-minix exit ;; aarch64:Linux:*:*) echo ${UNAME_MACHINE}-unknown-linux-gnu exit ;; aarch64_be:Linux:*:*) UNAME_MACHINE=aarch64_be echo ${UNAME_MACHINE}-unknown-linux-gnu exit ;; alpha:Linux:*:*) case `sed -n '/^cpu model/s/^.*: \(.*\)/\1/p' < /proc/cpuinfo` in EV5) UNAME_MACHINE=alphaev5 ;; EV56) UNAME_MACHINE=alphaev56 ;; PCA56) UNAME_MACHINE=alphapca56 ;; PCA57) UNAME_MACHINE=alphapca56 ;; EV6) UNAME_MACHINE=alphaev6 ;; EV67) UNAME_MACHINE=alphaev67 ;; EV68*) UNAME_MACHINE=alphaev68 ;; esac objdump --private-headers /bin/sh | grep -q ld.so.1 if test "$?" = 0 ; then LIBC="libc1" ; else LIBC="" ; fi echo ${UNAME_MACHINE}-unknown-linux-gnu${LIBC} exit ;; arm*:Linux:*:*) eval $set_cc_for_build if echo __ARM_EABI__ | $CC_FOR_BUILD -E - 2>/dev/null \ | grep -q __ARM_EABI__ then echo ${UNAME_MACHINE}-unknown-linux-gnu else if echo __ARM_PCS_VFP | $CC_FOR_BUILD -E - 2>/dev/null \ | grep -q __ARM_PCS_VFP then echo ${UNAME_MACHINE}-unknown-linux-gnueabi else echo ${UNAME_MACHINE}-unknown-linux-gnueabihf fi fi exit ;; avr32*:Linux:*:*) echo ${UNAME_MACHINE}-unknown-linux-gnu exit ;; cris:Linux:*:*) echo ${UNAME_MACHINE}-axis-linux-gnu exit ;; crisv32:Linux:*:*) echo ${UNAME_MACHINE}-axis-linux-gnu exit ;; frv:Linux:*:*) echo ${UNAME_MACHINE}-unknown-linux-gnu exit ;; hexagon:Linux:*:*) echo ${UNAME_MACHINE}-unknown-linux-gnu exit ;; i*86:Linux:*:*) LIBC=gnu eval $set_cc_for_build sed 's/^ //' << EOF >$dummy.c #ifdef __dietlibc__ LIBC=dietlibc #endif EOF eval `$CC_FOR_BUILD -E $dummy.c 2>/dev/null | grep '^LIBC'` echo "${UNAME_MACHINE}-pc-linux-${LIBC}" exit ;; ia64:Linux:*:*) echo ${UNAME_MACHINE}-unknown-linux-gnu exit ;; m32r*:Linux:*:*) echo ${UNAME_MACHINE}-unknown-linux-gnu exit ;; m68*:Linux:*:*) echo ${UNAME_MACHINE}-unknown-linux-gnu exit ;; mips:Linux:*:* | mips64:Linux:*:*) eval $set_cc_for_build sed 's/^ //' << EOF >$dummy.c #undef CPU #undef ${UNAME_MACHINE} #undef ${UNAME_MACHINE}el #if defined(__MIPSEL__) || defined(__MIPSEL) || defined(_MIPSEL) || defined(MIPSEL) CPU=${UNAME_MACHINE}el #else #if defined(__MIPSEB__) || defined(__MIPSEB) || defined(_MIPSEB) || defined(MIPSEB) CPU=${UNAME_MACHINE} #else CPU= #endif #endif EOF eval `$CC_FOR_BUILD -E $dummy.c 2>/dev/null | grep '^CPU'` test x"${CPU}" != x && { echo "${CPU}-unknown-linux-gnu"; exit; } ;; or32:Linux:*:*) echo ${UNAME_MACHINE}-unknown-linux-gnu exit ;; padre:Linux:*:*) echo sparc-unknown-linux-gnu exit ;; parisc64:Linux:*:* | hppa64:Linux:*:*) echo hppa64-unknown-linux-gnu exit ;; parisc:Linux:*:* | hppa:Linux:*:*) # Look for CPU level case `grep '^cpu[^a-z]*:' /proc/cpuinfo 2>/dev/null | cut -d' ' -f2` in PA7*) echo hppa1.1-unknown-linux-gnu ;; PA8*) echo hppa2.0-unknown-linux-gnu ;; *) echo hppa-unknown-linux-gnu ;; esac exit ;; ppc64:Linux:*:*) echo powerpc64-unknown-linux-gnu exit ;; ppc:Linux:*:*) echo powerpc-unknown-linux-gnu exit ;; s390:Linux:*:* | s390x:Linux:*:*) echo ${UNAME_MACHINE}-ibm-linux exit ;; sh64*:Linux:*:*) echo ${UNAME_MACHINE}-unknown-linux-gnu exit ;; sh*:Linux:*:*) echo ${UNAME_MACHINE}-unknown-linux-gnu exit ;; sparc:Linux:*:* | sparc64:Linux:*:*) echo ${UNAME_MACHINE}-unknown-linux-gnu exit ;; tile*:Linux:*:*) echo ${UNAME_MACHINE}-unknown-linux-gnu exit ;; vax:Linux:*:*) echo ${UNAME_MACHINE}-dec-linux-gnu exit ;; x86_64:Linux:*:*) echo ${UNAME_MACHINE}-unknown-linux-gnu exit ;; xtensa*:Linux:*:*) echo ${UNAME_MACHINE}-unknown-linux-gnu exit ;; i*86:DYNIX/ptx:4*:*) # ptx 4.0 does uname -s correctly, with DYNIX/ptx in there. # earlier versions are messed up and put the nodename in both # sysname and nodename. echo i386-sequent-sysv4 exit ;; i*86:UNIX_SV:4.2MP:2.*) # Unixware is an offshoot of SVR4, but it has its own version # number series starting with 2... # I am not positive that other SVR4 systems won't match this, # I just have to hope. -- rms. # Use sysv4.2uw... so that sysv4* matches it. echo ${UNAME_MACHINE}-pc-sysv4.2uw${UNAME_VERSION} exit ;; i*86:OS/2:*:*) # If we were able to find `uname', then EMX Unix compatibility # is probably installed. echo ${UNAME_MACHINE}-pc-os2-emx exit ;; i*86:XTS-300:*:STOP) echo ${UNAME_MACHINE}-unknown-stop exit ;; i*86:atheos:*:*) echo ${UNAME_MACHINE}-unknown-atheos exit ;; i*86:syllable:*:*) echo ${UNAME_MACHINE}-pc-syllable exit ;; i*86:LynxOS:2.*:* | i*86:LynxOS:3.[01]*:* | i*86:LynxOS:4.[02]*:*) echo i386-unknown-lynxos${UNAME_RELEASE} exit ;; i*86:*DOS:*:*) echo ${UNAME_MACHINE}-pc-msdosdjgpp exit ;; i*86:*:4.*:* | i*86:SYSTEM_V:4.*:*) UNAME_REL=`echo ${UNAME_RELEASE} | sed 's/\/MP$//'` if grep Novell /usr/include/link.h >/dev/null 2>/dev/null; then echo ${UNAME_MACHINE}-univel-sysv${UNAME_REL} else echo ${UNAME_MACHINE}-pc-sysv${UNAME_REL} fi exit ;; i*86:*:5:[678]*) # UnixWare 7.x, OpenUNIX and OpenServer 6. case `/bin/uname -X | grep "^Machine"` in *486*) UNAME_MACHINE=i486 ;; *Pentium) UNAME_MACHINE=i586 ;; *Pent*|*Celeron) UNAME_MACHINE=i686 ;; esac echo ${UNAME_MACHINE}-unknown-sysv${UNAME_RELEASE}${UNAME_SYSTEM}${UNAME_VERSION} exit ;; i*86:*:3.2:*) if test -f /usr/options/cb.name; then UNAME_REL=`sed -n 's/.*Version //p' /dev/null >/dev/null ; then UNAME_REL=`(/bin/uname -X|grep Release|sed -e 's/.*= //')` (/bin/uname -X|grep i80486 >/dev/null) && UNAME_MACHINE=i486 (/bin/uname -X|grep '^Machine.*Pentium' >/dev/null) \ && UNAME_MACHINE=i586 (/bin/uname -X|grep '^Machine.*Pent *II' >/dev/null) \ && UNAME_MACHINE=i686 (/bin/uname -X|grep '^Machine.*Pentium Pro' >/dev/null) \ && UNAME_MACHINE=i686 echo ${UNAME_MACHINE}-pc-sco$UNAME_REL else echo ${UNAME_MACHINE}-pc-sysv32 fi exit ;; pc:*:*:*) # Left here for compatibility: # uname -m prints for DJGPP always 'pc', but it prints nothing about # the processor, so we play safe by assuming i586. # Note: whatever this is, it MUST be the same as what config.sub # prints for the "djgpp" host, or else GDB configury will decide that # this is a cross-build. echo i586-pc-msdosdjgpp exit ;; Intel:Mach:3*:*) echo i386-pc-mach3 exit ;; paragon:*:*:*) echo i860-intel-osf1 exit ;; i860:*:4.*:*) # i860-SVR4 if grep Stardent /usr/include/sys/uadmin.h >/dev/null 2>&1 ; then echo i860-stardent-sysv${UNAME_RELEASE} # Stardent Vistra i860-SVR4 else # Add other i860-SVR4 vendors below as they are discovered. echo i860-unknown-sysv${UNAME_RELEASE} # Unknown i860-SVR4 fi exit ;; mini*:CTIX:SYS*5:*) # "miniframe" echo m68010-convergent-sysv exit ;; mc68k:UNIX:SYSTEM5:3.51m) echo m68k-convergent-sysv exit ;; M680?0:D-NIX:5.3:*) echo m68k-diab-dnix exit ;; M68*:*:R3V[5678]*:*) test -r /sysV68 && { echo 'm68k-motorola-sysv'; exit; } ;; 3[345]??:*:4.0:3.0 | 3[34]??A:*:4.0:3.0 | 3[34]??,*:*:4.0:3.0 | 3[34]??/*:*:4.0:3.0 | 4400:*:4.0:3.0 | 4850:*:4.0:3.0 | SKA40:*:4.0:3.0 | SDS2:*:4.0:3.0 | SHG2:*:4.0:3.0 | S7501*:*:4.0:3.0) OS_REL='' test -r /etc/.relid \ && OS_REL=.`sed -n 's/[^ ]* [^ ]* \([0-9][0-9]\).*/\1/p' < /etc/.relid` /bin/uname -p 2>/dev/null | grep 86 >/dev/null \ && { echo i486-ncr-sysv4.3${OS_REL}; exit; } /bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \ && { echo i586-ncr-sysv4.3${OS_REL}; exit; } ;; 3[34]??:*:4.0:* | 3[34]??,*:*:4.0:*) /bin/uname -p 2>/dev/null | grep 86 >/dev/null \ && { echo i486-ncr-sysv4; exit; } ;; NCR*:*:4.2:* | MPRAS*:*:4.2:*) OS_REL='.3' test -r /etc/.relid \ && OS_REL=.`sed -n 's/[^ ]* [^ ]* \([0-9][0-9]\).*/\1/p' < /etc/.relid` /bin/uname -p 2>/dev/null | grep 86 >/dev/null \ && { echo i486-ncr-sysv4.3${OS_REL}; exit; } /bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \ && { echo i586-ncr-sysv4.3${OS_REL}; exit; } /bin/uname -p 2>/dev/null | /bin/grep pteron >/dev/null \ && { echo i586-ncr-sysv4.3${OS_REL}; exit; } ;; m68*:LynxOS:2.*:* | m68*:LynxOS:3.0*:*) echo m68k-unknown-lynxos${UNAME_RELEASE} exit ;; mc68030:UNIX_System_V:4.*:*) echo m68k-atari-sysv4 exit ;; TSUNAMI:LynxOS:2.*:*) echo sparc-unknown-lynxos${UNAME_RELEASE} exit ;; rs6000:LynxOS:2.*:*) echo rs6000-unknown-lynxos${UNAME_RELEASE} exit ;; PowerPC:LynxOS:2.*:* | PowerPC:LynxOS:3.[01]*:* | PowerPC:LynxOS:4.[02]*:*) echo powerpc-unknown-lynxos${UNAME_RELEASE} exit ;; SM[BE]S:UNIX_SV:*:*) echo mips-dde-sysv${UNAME_RELEASE} exit ;; RM*:ReliantUNIX-*:*:*) echo mips-sni-sysv4 exit ;; RM*:SINIX-*:*:*) echo mips-sni-sysv4 exit ;; *:SINIX-*:*:*) if uname -p 2>/dev/null >/dev/null ; then UNAME_MACHINE=`(uname -p) 2>/dev/null` echo ${UNAME_MACHINE}-sni-sysv4 else echo ns32k-sni-sysv fi exit ;; PENTIUM:*:4.0*:*) # Unisys `ClearPath HMP IX 4000' SVR4/MP effort # says echo i586-unisys-sysv4 exit ;; *:UNIX_System_V:4*:FTX*) # From Gerald Hewes . # How about differentiating between stratus architectures? -djm echo hppa1.1-stratus-sysv4 exit ;; *:*:*:FTX*) # From seanf@swdc.stratus.com. echo i860-stratus-sysv4 exit ;; i*86:VOS:*:*) # From Paul.Green@stratus.com. echo ${UNAME_MACHINE}-stratus-vos exit ;; *:VOS:*:*) # From Paul.Green@stratus.com. echo hppa1.1-stratus-vos exit ;; mc68*:A/UX:*:*) echo m68k-apple-aux${UNAME_RELEASE} exit ;; news*:NEWS-OS:6*:*) echo mips-sony-newsos6 exit ;; R[34]000:*System_V*:*:* | R4000:UNIX_SYSV:*:* | R*000:UNIX_SV:*:*) if [ -d /usr/nec ]; then echo mips-nec-sysv${UNAME_RELEASE} else echo mips-unknown-sysv${UNAME_RELEASE} fi exit ;; BeBox:BeOS:*:*) # BeOS running on hardware made by Be, PPC only. echo powerpc-be-beos exit ;; BeMac:BeOS:*:*) # BeOS running on Mac or Mac clone, PPC only. echo powerpc-apple-beos exit ;; BePC:BeOS:*:*) # BeOS running on Intel PC compatible. echo i586-pc-beos exit ;; BePC:Haiku:*:*) # Haiku running on Intel PC compatible. echo i586-pc-haiku exit ;; SX-4:SUPER-UX:*:*) echo sx4-nec-superux${UNAME_RELEASE} exit ;; SX-5:SUPER-UX:*:*) echo sx5-nec-superux${UNAME_RELEASE} exit ;; SX-6:SUPER-UX:*:*) echo sx6-nec-superux${UNAME_RELEASE} exit ;; SX-7:SUPER-UX:*:*) echo sx7-nec-superux${UNAME_RELEASE} exit ;; SX-8:SUPER-UX:*:*) echo sx8-nec-superux${UNAME_RELEASE} exit ;; SX-8R:SUPER-UX:*:*) echo sx8r-nec-superux${UNAME_RELEASE} exit ;; Power*:Rhapsody:*:*) echo powerpc-apple-rhapsody${UNAME_RELEASE} exit ;; *:Rhapsody:*:*) echo ${UNAME_MACHINE}-apple-rhapsody${UNAME_RELEASE} exit ;; *:Darwin:*:*) UNAME_PROCESSOR=`uname -p` || UNAME_PROCESSOR=unknown case $UNAME_PROCESSOR in i386) eval $set_cc_for_build if [ "$CC_FOR_BUILD" != 'no_compiler_found' ]; then if (echo '#ifdef __LP64__'; echo IS_64BIT_ARCH; echo '#endif') | \ (CCOPTS= $CC_FOR_BUILD -E - 2>/dev/null) | \ grep IS_64BIT_ARCH >/dev/null then UNAME_PROCESSOR="x86_64" fi fi ;; unknown) UNAME_PROCESSOR=powerpc ;; esac echo ${UNAME_PROCESSOR}-apple-darwin${UNAME_RELEASE} exit ;; *:procnto*:*:* | *:QNX:[0123456789]*:*) UNAME_PROCESSOR=`uname -p` if test "$UNAME_PROCESSOR" = "x86"; then UNAME_PROCESSOR=i386 UNAME_MACHINE=pc fi echo ${UNAME_PROCESSOR}-${UNAME_MACHINE}-nto-qnx${UNAME_RELEASE} exit ;; *:QNX:*:4*) echo i386-pc-qnx exit ;; NEO-?:NONSTOP_KERNEL:*:*) echo neo-tandem-nsk${UNAME_RELEASE} exit ;; NSE-?:NONSTOP_KERNEL:*:*) echo nse-tandem-nsk${UNAME_RELEASE} exit ;; NSR-?:NONSTOP_KERNEL:*:*) echo nsr-tandem-nsk${UNAME_RELEASE} exit ;; *:NonStop-UX:*:*) echo mips-compaq-nonstopux exit ;; BS2000:POSIX*:*:*) echo bs2000-siemens-sysv exit ;; DS/*:UNIX_System_V:*:*) echo ${UNAME_MACHINE}-${UNAME_SYSTEM}-${UNAME_RELEASE} exit ;; *:Plan9:*:*) # "uname -m" is not consistent, so use $cputype instead. 386 # is converted to i386 for consistency with other x86 # operating systems. if test "$cputype" = "386"; then UNAME_MACHINE=i386 else UNAME_MACHINE="$cputype" fi echo ${UNAME_MACHINE}-unknown-plan9 exit ;; *:TOPS-10:*:*) echo pdp10-unknown-tops10 exit ;; *:TENEX:*:*) echo pdp10-unknown-tenex exit ;; KS10:TOPS-20:*:* | KL10:TOPS-20:*:* | TYPE4:TOPS-20:*:*) echo pdp10-dec-tops20 exit ;; XKL-1:TOPS-20:*:* | TYPE5:TOPS-20:*:*) echo pdp10-xkl-tops20 exit ;; *:TOPS-20:*:*) echo pdp10-unknown-tops20 exit ;; *:ITS:*:*) echo pdp10-unknown-its exit ;; SEI:*:*:SEIUX) echo mips-sei-seiux${UNAME_RELEASE} exit ;; *:DragonFly:*:*) echo ${UNAME_MACHINE}-unknown-dragonfly`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` exit ;; *:*VMS:*:*) UNAME_MACHINE=`(uname -p) 2>/dev/null` case "${UNAME_MACHINE}" in A*) echo alpha-dec-vms ; exit ;; I*) echo ia64-dec-vms ; exit ;; V*) echo vax-dec-vms ; exit ;; esac ;; *:XENIX:*:SysV) echo i386-pc-xenix exit ;; i*86:skyos:*:*) echo ${UNAME_MACHINE}-pc-skyos`echo ${UNAME_RELEASE}` | sed -e 's/ .*$//' exit ;; i*86:rdos:*:*) echo ${UNAME_MACHINE}-pc-rdos exit ;; i*86:AROS:*:*) echo ${UNAME_MACHINE}-pc-aros exit ;; x86_64:VMkernel:*:*) echo ${UNAME_MACHINE}-unknown-esx exit ;; esac #echo '(No uname command or uname output not recognized.)' 1>&2 #echo "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" 1>&2 eval $set_cc_for_build cat >$dummy.c < # include #endif main () { #if defined (sony) #if defined (MIPSEB) /* BFD wants "bsd" instead of "newsos". Perhaps BFD should be changed, I don't know.... */ printf ("mips-sony-bsd\n"); exit (0); #else #include printf ("m68k-sony-newsos%s\n", #ifdef NEWSOS4 "4" #else "" #endif ); exit (0); #endif #endif #if defined (__arm) && defined (__acorn) && defined (__unix) printf ("arm-acorn-riscix\n"); exit (0); #endif #if defined (hp300) && !defined (hpux) printf ("m68k-hp-bsd\n"); exit (0); #endif #if defined (NeXT) #if !defined (__ARCHITECTURE__) #define __ARCHITECTURE__ "m68k" #endif int version; version=`(hostinfo | sed -n 's/.*NeXT Mach \([0-9]*\).*/\1/p') 2>/dev/null`; if (version < 4) printf ("%s-next-nextstep%d\n", __ARCHITECTURE__, version); else printf ("%s-next-openstep%d\n", __ARCHITECTURE__, version); exit (0); #endif #if defined (MULTIMAX) || defined (n16) #if defined (UMAXV) printf ("ns32k-encore-sysv\n"); exit (0); #else #if defined (CMU) printf ("ns32k-encore-mach\n"); exit (0); #else printf ("ns32k-encore-bsd\n"); exit (0); #endif #endif #endif #if defined (__386BSD__) printf ("i386-pc-bsd\n"); exit (0); #endif #if defined (sequent) #if defined (i386) printf ("i386-sequent-dynix\n"); exit (0); #endif #if defined (ns32000) printf ("ns32k-sequent-dynix\n"); exit (0); #endif #endif #if defined (_SEQUENT_) struct utsname un; uname(&un); if (strncmp(un.version, "V2", 2) == 0) { printf ("i386-sequent-ptx2\n"); exit (0); } if (strncmp(un.version, "V1", 2) == 0) { /* XXX is V1 correct? */ printf ("i386-sequent-ptx1\n"); exit (0); } printf ("i386-sequent-ptx\n"); exit (0); #endif #if defined (vax) # if !defined (ultrix) # include # if defined (BSD) # if BSD == 43 printf ("vax-dec-bsd4.3\n"); exit (0); # else # if BSD == 199006 printf ("vax-dec-bsd4.3reno\n"); exit (0); # else printf ("vax-dec-bsd\n"); exit (0); # endif # endif # else printf ("vax-dec-bsd\n"); exit (0); # endif # else printf ("vax-dec-ultrix\n"); exit (0); # endif #endif #if defined (alliant) && defined (i860) printf ("i860-alliant-bsd\n"); exit (0); #endif exit (1); } EOF $CC_FOR_BUILD -o $dummy $dummy.c 2>/dev/null && SYSTEM_NAME=`$dummy` && { echo "$SYSTEM_NAME"; exit; } # Apollos put the system type in the environment. test -d /usr/apollo && { echo ${ISP}-apollo-${SYSTYPE}; exit; } # Convex versions that predate uname can use getsysinfo(1) if [ -x /usr/convex/getsysinfo ] then case `getsysinfo -f cpu_type` in c1*) echo c1-convex-bsd exit ;; c2*) if getsysinfo -f scalar_acc then echo c32-convex-bsd else echo c2-convex-bsd fi exit ;; c34*) echo c34-convex-bsd exit ;; c38*) echo c38-convex-bsd exit ;; c4*) echo c4-convex-bsd exit ;; esac fi cat >&2 < in order to provide the needed information to handle your system. config.guess timestamp = $timestamp uname -m = `(uname -m) 2>/dev/null || echo unknown` uname -r = `(uname -r) 2>/dev/null || echo unknown` uname -s = `(uname -s) 2>/dev/null || echo unknown` uname -v = `(uname -v) 2>/dev/null || echo unknown` /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null` /bin/uname -X = `(/bin/uname -X) 2>/dev/null` hostinfo = `(hostinfo) 2>/dev/null` /bin/universe = `(/bin/universe) 2>/dev/null` /usr/bin/arch -k = `(/usr/bin/arch -k) 2>/dev/null` /bin/arch = `(/bin/arch) 2>/dev/null` /usr/bin/oslevel = `(/usr/bin/oslevel) 2>/dev/null` /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null` UNAME_MACHINE = ${UNAME_MACHINE} UNAME_RELEASE = ${UNAME_RELEASE} UNAME_SYSTEM = ${UNAME_SYSTEM} UNAME_VERSION = ${UNAME_VERSION} EOF exit 1 # Local variables: # eval: (add-hook 'write-file-hooks 'time-stamp) # time-stamp-start: "timestamp='" # time-stamp-format: "%:y-%02m-%02d" # time-stamp-end: "'" # End: ldns-1.6.17/doc/0000775000175100017510000000000012264060151012660 5ustar willemwillemldns-1.6.17/doc/function_manpages0000664000175100017510000004770412264060151016317 0ustar willemwillem# first function name will be the real name of the manpage # other names are aliases (symlinks) # all functions specified on the same line are included in the # same manual page. We cannot deal with linebreaks! # function named after the pipe `|' are put in the "see also" section # functions that must be included, separated by commas ### host2wire.h # conversion functions ldns_rr2wire, ldns_pkt2wire, ldns_rdf2wire | ldns_wire2rr, ldns_wire2pkt, ldns_wire2rdf # lower level conversions, some are from host2str.h ldns_pkt2buffer_str, ldns_pktheader2buffer_str, ldns_rr2buffer_str, ldns_rr_list2buffer_str, ldns_rdf2buffer_str, ldns_key2buffer_str, ldns_pkt2buffer_wire, ldns_rr2buffer_wire, ldns_rdf2buffer_wire, ldns_rrsig2buffer_wire, ldns_rr_rdata2buffer_wire | ldns_pkt2str, ldns_rr2str, ldns_rdf2str, ldns_rr_list2str, ldns_key2str ### /host2wire.h ### host2str.h ldns_rr2str, ldns_pkt2str, ldns_rdf2str, ldns_rr_list2str, ldns_key2str | ldns_rr_print, ldns_rdf_print, ldns_pkt_print, ldns_rr_list_print, ldns_resolver_print, ldns_zone_print ldns_rr_print, ldns_rdf_print, ldns_pkt_print, ldns_rr_list_print, ldns_resolver_print, ldns_zone_print | ldns_rr2str, ldns_rdf2str, ldns_pkt2str, ldns_rr_list2str, ldns_key2str ### /host2str.h ### host2str.h # and even lower ldns_rdf2buffer_str_a, ldns_rdf2buffer_str_aaaa, ldns_rdf2buffer_str_str, ldns_rdf2buffer_str_b64, ldns_rdf2buffer_str_hex, ldns_rdf2buffer_str_type, ldns_rdf2buffer_str_class, ldns_rdf2buffer_str_alg, ldns_rdf2buffer_str_loc, ldns_rdf2buffer_str_unknown, ldns_rdf2buffer_str_nsap, ldns_rdf2buffer_str_wks, ldns_rdf2buffer_str_nsec, ldns_rdf2buffer_str_period, ldns_rdf2buffer_str_tsigtime, ldns_rdf2buffer_str_apl, ldns_rdf2buffer_str_int16_data, ldns_rdf2buffer_str_int16, ldns_rdf2buffer_str_ipseckey ### /host2str.h ### wire2host.h # wirefunctions ldns_wire2rr, ldns_wire2pkt, ldns_wire2rdf, ldns_wire2dname | ldns_rr2wire, ldns_pkt2wire, ldns_rdf2wire, ldns_dname2wire ldns_buffer2pkt_wire ### /wire2host.h ### dname.h ldns_dname_left_chop, ldns_dname_label_count | ldns_dname ldns_dname2canonical | ldns_dname ldns_dname_cat_clone, ldns_dname_cat | ldns_dname ldns_dname_new, ldns_dname_new_frm_str, ldns_dname_new_frm_data | ldns_dname, ldns_pkt_query_new_frm_str, ldns_rdf_new_frm_str, ldns_rr_new_frm_str ldns_dname_is_subdomain, ldns_dname_str_absolute, ldns_dname_label | ldns_dname ldns_dname_compare, ldns_dname_interval | ldns_dname_is_subdomain | ldns_dname ldns_dname | ldns_dname_left_chop, ldns_dname_label_count, ldns_dname2canonical, ldns_dname_cat, ldns_dname_cat_clone, ldns_dname_new, ldns_dname_new_frm_str, ldns_dname_new_frm_data, ldns_dname_is_subdomain, ldns_dname_str_absolute, ldns_dname_label, ldns_dname_compare, ldns_dname_interval ### /dname.h ### dane.h ldns_dane_create_tlsa_owner, ldns_dane_cert2rdf, ldns_dane_select_certificate, ldns_dane_create_tlsa_rr | ldns_dane_verify, ldns_dane_verify_rr ldns_dane_verify, ldns_dane_verify_rr | ldns_dane_create_tlsa_owner, ldns_dane_cert2rdf, ldns_dane_select_certificate, ldns_dane_create_tlsa_rr ### /dane.h ### rdata.h ldns_rdf, ldns_rdf_type | ldns_rdf_set_size, ldns_rdf_set_type, ldns_rdf_set_data, ldns_rdf_size, ldns_rdf_get_type, ldns_rdf_data, ldns_rdf_compare, ldns_rdf_new, ldns_rdf_clone, ldns_rdf_new_frm_data, ldns_rdf_new_frm_str, ldns_rdf_new_frm_fp, ldns_rdf_free, ldns_rdf_deep_free, ldns_rdf_print, ldns_native2rdf_int8, ldns_native2rdf_int16, ldns_native2rdf_int32, ldns_native2rdf_int16_data, ldns_rdf2native_int8, ldns_rdf2native_int16, ldns_rdf2native_int32, ldns_rdf2native_sockaddr_storage, ldns_rdf2native_time_t, ldns_native2rdf_int8, ldns_native2rdf_int16, ldns_native2rdf_int32, ldns_native2rdf_int16_data, ldns_rdf2native_int8, ldns_rdf2native_int16, ldns_rdf2native_int32, ldns_rdf2native_sockaddr_storage, ldns_rdf2native_time_t, ldns_native2rdf_int8, ldns_native2rdf_int16, ldns_native2rdf_int32, ldns_native2rdf_int16_data, ldns_rdf2native_int8, ldns_rdf2native_int16, ldns_rdf2native_int32, ldns_rdf2native_sockaddr_storage, ldns_rdf2native_time_t ldns_rdf_set_size, ldns_rdf_set_type, ldns_rdf_set_data | ldns_rdf ldns_rdf_size, ldns_rdf_get_type, ldns_rdf_data, ldns_rdf_compare | ldns_rdf ldns_rdf_new, ldns_rdf_clone, ldns_rdf_new_frm_data, ldns_rdf_new_frm_str, ldns_rdf_new_frm_fp, ldns_rdf_free, ldns_rdf_deep_free, ldns_rdf_print | ldns_rdf ldns_native2rdf_int8, ldns_native2rdf_int16, ldns_native2rdf_int32, ldns_native2rdf_int16_data, ldns_rdf2native_int8, ldns_rdf2native_int16, ldns_rdf2native_int32, ldns_rdf2native_sockaddr_storage, ldns_rdf2native_time_t | ldns_rdf ldns_rdf_address_reverse | ldns_rdf ldns_octet | ldns_rdf # why is this in rdata.h? ldns_str2period ### /rdata.h ### higher.h ldns_get_rr_list_addr_by_name, ldns_get_rr_list_name_by_addr | ldns_rr_list, ldns_rr ldns_get_rr_list_hosts_frm_fp, ldns_get_rr_list_hosts_frm_file | ldns_rr_list, ldns_rr, ldns_get_rr_list_hosts_frm_fp_l ldns_get_rr_list_hosts_frm_fp_l | ldns_rr_list ldns_getaddrinfo ### /higher.h # ### dnssec.h # ldns_calc_keytag, ldns_verify, ldns_verify_rrsig, ldns_verify_rrsig_dsa, ldns_verify_rrsig_rsasha1, ldns_verify_rrsig_rsamd5, ldns_key_rr2ds, ldns_key_buf2dsa, ldns_key_buf2rsa | ldns_key, ldns_sign_public, ldns_zone_sign, ldns_verify, ldns_verify_rrsig # algs ldns_verify_rrsig_dsa, ldns_verify_rrsig_rsasha1, ldns_verify_rrsig_rsamd5 | ldns_key, ldns_sign_public, ldns_zone_sign, ldns_verify, ldns_verify_rrsig # tsig ldns_pkt_tsig_verify, ldns_pkt_tsig_sign | ldns_key # verify ldns_verify, ldns_verify_rrsig, ldns_verify_rrsig_keylist, ldns_verify_rrsig_keylist_notime, ldns_verify_notime | ldns_verify_rrsig_evp | ldns_verify_rrsig_dsa, ldns_verify_rrsig_rsasha1, ldns_verify_rrsig_rsamd5, ldns_sign_public, ldns_zone_sign, ldns_key # convert ldns_key_buf2dsa, ldns_key_buf2rsa | ldns_key_rr2ds ldns_key_rr2ds | ldns_key ldns_create_nsec | ldns_sign_public # signing ldns_sign_public | ldns_sign_public_dsa, ldns_sign_public_rsamd5, ldns_sign_public_rsasha1, ldns_verify, ldns_verify_rrsig, ldns_key ldns_sign_public_dsa, ldns_sign_public_rsamd5, ldns_sign_public_rsasha1 | ldns_sign_public ldns_dnssec_zone_sign, ldns_dnssec_zone_sign_nsec3 | ldns_zone_sign, ldns_zone_sign_nsec3 | ldns_sign_public, ldns_key, ldns_init_random ldns_init_random | ldns_sign_public, ldns_key ldns_pkt_verify | ldns_verify, ldns_sign_public, ldns_zone_sign # new family of dnssec functions ldns_dnssec_zone, ldns_dnssec_name, ldns_dnssec_rrs, ldns_dnssec_rrsets | ldns_dnssec_zone_new, ldns_dnssec_name_new, ldns_dnssec_rrs_new, ldns_dnssec_rrsets_new ldns_dnssec_zone_find_rrset, ldns_dnssec_zone_new, ldns_dnssec_zone_free, ldns_dnssec_zone_add_rr, ldns_dnssec_zone_names_print, ldns_dnssec_zone_print, ldns_dnssec_zone_add_empty_nonterminals | ldns_dnssec_zone ldns_dnssec_name_new, ldns_dnssec_name_new_frm_rr, ldns_dnssec_name_free, ldns_dnssec_name_name, ldns_dnssec_name_set_name, ldns_dnssec_name_set_nsec, ldns_dnssec_name_cmp, ldns_dnssec_name_add_rr, ldns_dnssec_name_find_rrset, ldns_dnssec_name_print | ldns_dnssec_zone ldns_dnssec_rrsets_new, ldns_dnssec_rrsets_free, ldns_dnssec_rrsets_type, ldns_dnssec_rrsets_set_type, ldns_dnssec_rrsets_add_rr, ldns_dnssec_rrsets_print | ldns_dnssec_zone ldns_dnssec_rrs_new, ldns_dnssec_rrs_free, ldns_dnssec_rrs_add_rr, ldns_dnssec_rrs_print | ldns_dnssec_zone # verification ldns_dnssec_data_chain, ldns_dnssec_data_chain_struct, ldns_dnssec_trust_tree | ldns_dnssec_data_chain_new, ldns_dnssec_trust_tree_new, ldns_dnssec_verify_denial ldns_dnssec_data_chain_new, ldns_dnssec_data_chain_free, ldns_dnssec_data_chain_deep_free, ldns_dnssec_build_data_chain, ldns_dnssec_data_chain_print | ldns_dnssec_data_chain ldns_dnssec_trust_tree_new, ldns_dnssec_trust_tree_free, ldns_dnssec_trust_tree_depth, ldns_dnssec_derive_trust_tree, ldns_dnssec_trust_tree_contains_keys, ldns_dnssec_trust_tree_print, ldns_dnssec_trust_tree_print_sm, ldns_dnssec_trust_tree_add_parent, ldns_dnssec_derive_trust_tree_normal_rrset, ldns_dnssec_derive_trust_tree_dnskey_rrset, ldns_dnssec_derive_trust_tree_ds_rrset, ldns_dnssec_derive_trust_tree_no_sig | ldns_dnssec_data_chain, ldns_dnssec_trust_tree ldns_dnssec_verify_denial, ldns_dnssec_verify_denial_nsec3 | ldns_dnssec_trust_tree, ldns_dnssec_data_chain # new signing functions ldns_dnssec_zone_sign, ldns_dnssec_zone_sign_nsec3, ldns_dnssec_zone_mark_glue, ldns_dnssec_name_node_next_nonglue, ldns_dnssec_zone_create_nsecs, ldns_dnssec_remove_signatures, ldns_dnssec_zone_create_rrsigs | ldns_dnssec_zone ### /dnssec.h ### dnskey.h ldns_key_new | ldns_key, ldns_key_list_new ldns_key_new_frm_algorithm, ldns_key_new_frm_fp, ldns_key_new_frm_fp_l | ldns_key ldns_key_new_frm_fp_rsa, ldns_key_new_frm_fp_rsa_l | ldns_key_new_frm_fp, ldns_key ldns_key_new_frm_fp_dsa, ldns_key_new_frm_fp_dsa_l | ldns_key_new_frm_fp, ldns_key ldns_key_list_new | ldns_key_new, ldns_key # access, write ldns_key_set_algorithm, ldns_key_set_rsa_key, ldns_key_set_dsa_key, ldns_key_set_hmac_key, ldns_key_set_origttl, ldns_key_set_inception, ldns_key_set_expiration, ldns_key_set_pubkey_owner, ldns_key_set_keytag, ldns_key_set_flags, ldns_key_list_set_key_count, ldns_key_algo_supported | ldns_key_push_key, ldns_key ldns_key_list_push_key | ldns_key_list_pop_key, ldns_key ldns_key_list_pop_key | ldns_key_list_push_key, ldns_key # access, read ldns_key_list_key_count, ldns_key_list_key, ldns_key_rsa_key, ldns_key_dsa_key, ldns_key_algorithm, ldns_key_hmac_key, ldns_key_origttl, ldns_key_inception, ldns_key_expiration, ldns_key_keytag, ldns_key_pubkey_owner, ldns_key_flags | ldns_key # convert ldns_key2rr | ldns_key ldns_key_free, ldns_key_deep_free, ldns_key_list_free | ldns_key # ldns_key_print | ldns_key_new, ldns_key ldns_key | ldns_key_new, ldns_key_new_frm_algorithm,ldns_key_new_frm_fp,ldns_key_new_frm_fp_l, ldns_key_new_frm_fp_rsa, ldns_key_new_frm_fp_rsa_l, ldns_key_new_frm_fp_dsa, ldns_key_new_frm_fp_dsa_l, ldns_key_list_new, ldns_key_set_algorithm, ldns_key_set_rsa_key, ldns_key_set_dsa_key, ldns_key_set_hmac_key, ldns_key_set_origttl, ldns_key_set_inception, ldns_key_set_expiration, ldns_key_set_pubkey_owner, ldns_key_set_keytag, ldns_key_set_flags, ldns_key_list_set_key_count, ldns_key_list_push_key, ldns_key_list_pop_key, ldns_key_list_key_count, ldns_key_list_key, ldns_key_rsa_key, ldns_key_dsa_key, ldns_key_algorithm, ldns_key_hmac_key, ldns_key_origttl, ldns_key_inception, ldns_key_expiration, ldns_key_keytag, ldns_key_pubkey_owner, ldns_key_flags, ldns_key2rr, ldns_key_free, ldns_key_deep_free, ldns_key_list_free, ldns_key_print ### /dnskey.h ### MIEK TOT HIER TOT HIER # lists ldns_key_list_new, ldns_key_list_push_key, ldns_key_list_pop_key, ldns_key_list_key_count, ldns_key_list_key | ldns_key_list, ldns_key ldns_key_rsa_key, ldns_key_dsa_key, ldns_key_algorithm, ldns_key_hmac_key | ldns_key_list, ldns_key # gets/sets ldns_key_origttl, ldns_key_inception, ldns_key_expiration, ldns_key_keytag, ldns_key_pubkey_owner, ldns_key_flags | ldns_key ldns_key_set_algorithm, ldns_key_set_rsa_key, ldns_key_set_dsa_key, ldns_key_set_hmac_key, ldns_key_set_origttl, ldns_key_set_inception, ldns_key_set_expiration, ldns_key_set_pubkey_owner, ldns_key_set_keytag, ldns_key_set_flags, ldns_key_list_set_key_count | ldns_key # errr.h ldns_get_errorstr_by_id | ldns_status ldns_status | ldns_get_errorstr_by_id ### net.h ldns_send | ldns_pkt, ldns_resolver ldns_tcp_send_query, ldns_tcp_read_wire, ldns_tcp_connect | ldns_send, ldns_pkt, ldns_resolver ### /net.h ### buffer.h # general ldns_buffer | ldns_buffer_new, ldns_buffer_new_frm_data, ldns_buffer_clear, ldns_buffer_printf, ldns_buffer_free, ldns_buffer_export, ldns_buffer_flip, ldns_buffer_rewind, ldns_buffer_position, ldns_buffer_set_position, ldns_buffer_skip, ldns_buffer_limit, ldns_buffer_set_limit, ldns_buffer_capacity, ldns_buffer_set_capacity, ldns_buffer_reserve, ldns_buffer_at, ldns_buffer_begin, ldns_buffer_end, ldns_buffer_current, ldns_buffer_remaining_at, ldns_buffer_remaining, ldns_buffer_available_at, ldns_buffer_available, ldns_buffer_status, ldns_buffer_status_ok, ldns_buffer_write_at, ldns_buffer_write_at, ldns_buffer_write, ldns_buffer_write_string_at, ldns_buffer_write_string, ldns_buffer_write_u8_at, ldns_buffer_write_u8, ldns_buffer_write_u16_at, ldns_buffer_write_u16, ldns_buffer_read_at, ldns_buffer_read, ldns_buffer_read_u8_at, ldns_buffer_read_u8, ldns_buffer_read_u16_at, ldns_buffer_read_u16, ldns_buffer_read_u32_at, ldns_buffer_read_u32 ldns_buffer_new, ldns_buffer_new_frm_data, ldns_buffer_clear, ldns_buffer_printf, ldns_buffer_free, ldns_buffer_export | ldns_buffer # position ldns_buffer_flip, ldns_buffer_rewind, ldns_buffer_position, ldns_buffer_set_position, ldns_buffer_skip | ldns_buffer # values and pointers ldns_buffer_limit, ldns_buffer_set_limit, ldns_buffer_capacity, ldns_buffer_set_capacity, ldns_buffer_reserve, ldns_buffer_at, ldns_buffer_begin, ldns_buffer_end, ldns_buffer_current | ldns_buffer # info ldns_buffer_remaining_at, ldns_buffer_remaining, ldns_buffer_available_at, ldns_buffer_available, ldns_buffer_status, ldns_buffer_status_ok | ldns_buffer # read and write ldns_buffer_write_at, ldns_buffer_write_at, ldns_buffer_write, ldns_buffer_write_string_at, ldns_buffer_write_string, ldns_buffer_write_u8_at, ldns_buffer_write_u8, ldns_buffer_write_u16_at, ldns_buffer_write_u16, ldns_buffer_read_at, ldns_buffer_read, ldns_buffer_read_u8_at, ldns_buffer_read_u8, ldns_buffer_read_u16_at, ldns_buffer_read_u16, ldns_buffer_read_u32_at, ldns_buffer_read_u32 | ldns_buffer ### /buffer.h # parse.h ldns_bget_token, ldns_bgetc, ldns_bskipcs | ldns_buffer ldns_fget_token, ldns_fskipcs | ldns_buffer ldns_str_remove_comment # rr.h and other general rr funcs ldns_rr, ldns_rr_class, ldns_rr_type, ldns_rr_compress, ldns_rr_list | ldns_rr_new, ldns_rr_new_frm_type, ldns_rr_new_frm_str, ldns_rr_new_frm_fp, ldns_rr_free, ldns_rr_print, ldns_rr_set_owner, ldns_rr_set_ttl, ldns_rr_set_type, ldns_rr_set_rd_count, ldns_rr_set_class, ldns_rr_set_rdf, ldns_rr_push_rdf, ldns_rr_pop_rdf, ldns_rr_rdf, ldns_rr_owner, ldns_rr_rd_count, ldns_rr_ttl, ldns_rr_get_class, ldns_rr_list_rr_count, ldns_rr_list_set_rr_count, ldns_rr_list_new, ldns_rr_list_free, ldns_rr_list_cat, ldns_rr_list_push_rr, ldns_rr_list_pop_rr, ldns_is_rrset, ldns_rr_set_push_rr, ldns_rr_set_pop_rr, ldns_get_rr_class_by_name, ldns_get_rr_type_by_name, ldns_rr_list_clone, ldns_rr_list_sort, ldns_rr_compare, ldns_rr_compare_ds, ldns_rr_uncompressed_size, ldns_rr2canonical, ldns_rr_label_count, ldns_is_rrset, ldns_rr_descriptor, ldns_rr_descript ldns_rr_new, ldns_rr_new_frm_type, ldns_rr_new_frm_str, ldns_rr_new_frm_fp, ldns_rr_free, ldns_rr_print | ldns_rr, ldns_rr_list ldns_rr_set_owner, ldns_rr_set_ttl, ldns_rr_set_type, ldns_rr_set_rd_count, ldns_rr_set_class, ldns_rr_set_rdf | ldns_rr, ldns_rr_list ldns_rr_push_rdf, ldns_rr_pop_rdf | ldns_rr, ldns_rr_list ldns_rr_rdf, ldns_rr_owner, ldns_rr_rd_count, ldns_rr_ttl, ldns_rr_get_class | ldns_rr, ldns_rr_list ldns_rr_list_rr_count, ldns_rr_list_set_rr_count | ldns_rr, ldns_rr_list ldns_rr_list_new, ldns_rr_list_free | ldns_rr, ldns_rr_list ldns_rr_list_cat, ldns_rr_list_push_rr, ldns_rr_list_pop_rr | ldns_rr, ldns_rr_list ldns_is_rrset | ldns_rr, ldns_rr_list ldns_rr_set_push_rr, ldns_rr_set_pop_rr | ldns_rr, ldns_rr_list ldns_get_rr_class_by_name, ldns_get_rr_type_by_name | ldns_rr, ldns_rr_list ldns_rr_list_clone | ldns_rr, ldns_rr_list ldns_rr_list_sort | ldns_rr, ldns_rr_list ldns_rr_compare, ldns_rr_compare_ds | ldns_rr, ldns_rr_list ldns_rr_uncompressed_size | ldns_rr, ldns_rr_list ldns_rr2canonical | ldns_rr, ldns_rr_list ldns_rr_label_count | ldns_rr, ldns_rr_list ldns_is_rrset | ldns_rr # rr descriptors ldns_rr_descriptor, ldns_rr_descript, ldns_rr_descriptor_minimum, ldns_rr_descriptor_maximum, ldns_rr_descriptor_field_type | ldns_rr, ldns_rdf # packet.h ldns_pkt, ldns_pkt_section, ldns_pkt_type | ldns_pkt_new, ldns_pkt_free, ldns_pkt_print, ldns_pkt_query_new, ldns_pkt_query_new_frm_str, ldns_pkt_reply_type, ldns_pkt_id, ldns_pkt_qr, ldns_pkt_aa, ldns_pkt_tc, ldns_pkt_rd, ldns_pkt_cd, ldns_pkt_ra, ldns_pkt_ad, ldns_pkt_get_opcode, ldns_pkt_get_rcode, ldns_pkt_qdcount, ldns_pkt_ancount, ldns_pkt_nscount, ldns_pkt_arcount, ldns_pkt_answerfrom, ldns_pkt_querytime, ldns_pkt_size, ldns_pkt_tsig, ldns_pkt_question, ldns_pkt_answer, ldns_pkt_authority, ldns_pkt_additional, ldns_pkt_get_section_clone, ldns_pkt_rr_list_by_name, ldns_pkt_rr_list_by_type, ldns_pkt_rr_list_by_name_and_type, ldns_pkt_set_flags, ldns_pkt_set_id, ldns_pkt_set_qr, ldns_pkt_set_aa, ldns_pkt_set_tc, ldns_pkt_set_rd, ldns_pkt_set_cd, ldns_pkt_set_ra, ldns_pkt_set_ad, ldns_pkt_set_opcode, ldns_pkt_set_rcode, ldns_pkt_set_qdcount, ldns_pkt_set_ancount, ldns_pkt_set_nscount, ldns_pkt_set_arcount, ldns_pkt_set_answerfrom, ldns_pkt_set_querytime, ldns_pkt_set_size, ldns_pkt_set_section_count, ldns_pkt_set_tsig, ldns_pkt_edns, ldns_pkt_edns_udp_size, ldns_pkt_edns_extended_rcode, ldns_pkt_edns_version, ldns_pkt_edns_z, ldns_pkt_edns_data, ldns_pkt_set_edns_udp_size, ldns_pkt_set_edns_extended_rcode, ldns_pkt_set_edns_version, ldns_pkt_set_edns_z, ldns_pkt_set_edns_data ldns_pkt_new, ldns_pkt_free, ldns_pkt_print, ldns_pkt_query_new, ldns_pkt_query_new_frm_str, ldns_pkt_reply_type | ldns_pkt # gets ldns_pkt_id, ldns_pkt_qr, ldns_pkt_aa, ldns_pkt_tc, ldns_pkt_rd, ldns_pkt_cd, ldns_pkt_ra, ldns_pkt_ad, ldns_pkt_get_opcode, ldns_pkt_get_rcode, ldns_pkt_qdcount, ldns_pkt_ancount, ldns_pkt_nscount, ldns_pkt_arcount, ldns_pkt_answerfrom, ldns_pkt_querytime, ldns_pkt_size, ldns_pkt_tsig, ldns_pkt_question, ldns_pkt_answer, ldns_pkt_authority, ldns_pkt_additional, ldns_pkt_get_section_clone, ldns_pkt_rr_list_by_name, ldns_pkt_rr_list_by_type, ldns_pkt_rr_list_by_name_and_type | ldns_pkt # sets ldns_pkt_set_flags, ldns_pkt_set_id, ldns_pkt_set_qr, ldns_pkt_set_aa, ldns_pkt_set_tc, ldns_pkt_set_rd, ldns_pkt_set_cd, ldns_pkt_set_ra, ldns_pkt_set_ad, ldns_pkt_set_opcode, ldns_pkt_set_rcode, ldns_pkt_set_qdcount, ldns_pkt_set_ancount, ldns_pkt_set_nscount, ldns_pkt_set_arcount, ldns_pkt_set_answerfrom, ldns_pkt_set_querytime, ldns_pkt_set_size, ldns_pkt_set_section_count, ldns_pkt_set_tsig | ldns_pkt # EDNS0 ldns_pkt_edns, ldns_pkt_edns_udp_size, ldns_pkt_edns_extended_rcode, ldns_pkt_edns_version, ldns_pkt_edns_z, ldns_pkt_edns_data, ldns_pkt_set_edns_udp_size, ldns_pkt_set_edns_extended_rcode, ldns_pkt_set_edns_version, ldns_pkt_set_edns_z, ldns_pkt_set_edns_data | ldns_pkt # rr_functions.h ldns_rr_ns_nsdname # ldns_rr_mx_preference, ldns_rr_mx_exchange # ldns_rr_rrsig_typecovered, ldns_rr_rrsig_set_typecovered, ldns_rr_rrsig_algorithm, ldns_rr_rrsig_set_algorithm, ldns_rr_rrsig_labels, ldns_rr_rrsig_set_labels, ldns_rr_rrsig_origttl, ldns_rr_rrsig_set_origttl, ldns_rr_rrsig_expiration, ldns_rr_rrsig_set_expiration, ldns_rr_rrsig_inception, ldns_rr_rrsig_set_inception, ldns_rr_rrsig_keytag, ldns_rr_rrsig_set_keytag, ldns_rr_rrsig_signame, ldns_rr_rrsig_set_signame, ldns_rr_rrsig_sig, ldns_rr_rrsig_set_sig # ldns_rr_dnskey_flags, ldns_rr_dnskey_set_flags, ldns_rr_dnskey_protocol, ldns_rr_dnskey_set_protocol, ldns_rr_dnskey_algorithm, ldns_rr_dnskey_set_algorithm, ldns_rr_dnskey_key, ldns_rr_dnskey_set_key | ldns_rr ### zone.h ldns_zone | ldns_zone_new, ldns_zone_deep_free, ldns_zone_new_frm_fp, ldns_zone_new_frm_fp_l, ldns_zone_sort, ldns_zone_glue_rr_list, ldns_zone_push_rr, ldns_zone_push_rr_list, ldns_zone_set_rrs, ldns_zone_set_soa, ldns_zone_rrs, ldns_zone_soa, ldns_zone_rr_count, ldns_zone_new, ldns_zone_deep_free, ldns_zone_new_frm_fp, ldns_zone_new_frm_fp_l | ldns_zone ldns_zone_sort, ldns_zone_glue_rr_list | ldns_zone ldns_zone_push_rr, ldns_zone_push_rr_list | ldns_zone ldns_zone_set_rrs, ldns_zone_set_soa | ldns_zone, ldns_zone_rrs, ldns_zone_soa ldns_zone_rrs, ldns_zone_soa | ldns_zone ldns_zone_set_rrs ldns_zone_rr_count | ldns_zone ### update.h ldns_update_pkt_new | ldns_update_pkt_tsig_add, ldns_update_pkt_tsig_add, ldns_update_zocount, ldns_update_prcount, ldns_update_upcount, ldns_update_adcount, ldns_update_set_zocount, ldns_update_set_prcount, ldns_update_set_upcount, ldns_update_set_adcount, ldns_update_pkt_tsig_add | ldns_update_pkt_new ldns_update_zocount, ldns_update_prcount, ldns_update_upcount, ldns_update_adcount | ldns_update_pkt_new ldns_update_set_zocount, ldns_update_set_prcount, ldns_update_set_upcount, ldns_update_set_adcount | ldns_update_pkt_new ldns-1.6.17/doc/TODO0000664000175100017510000000144712264060151013356 0ustar willemwillemTODO Features: * Multi-line zone file parsing * Configure option for not printing DNSSEC RR comments * HMAC and MD5 without OpenSSL * HIP RR support * Parse 'search' attribute in /etc/resolv.conf * Make use of automake (Bug #173) * ./configure --with-tools --with-drill (Bug #264) * Drill: print appropriate DS RRs (relates to Bug #355) * ldns-signzone optout to be really optout * Compression when generating wireformat. Preferably with a configurable policy: refer only backwards, case sensitivity, only refer to other owner names, etc. Bugfixes: * Bug #279: fix return values for net.h functions, and related: make return values for functions that cannot return memory-failure today. Needs medium version increase because of API change. * Long out-standing packaging bugs (debian) * Lazy ABI ldns-1.6.17/doc/tutorial3_signzone.dox0000664000175100017510000001304112264060151017235 0ustar willemwillem/** \page tutorial3_signzone Tutorial 3: Signing a zone file \dontinclude ldns-signzone.c The full source code can be found in \link examples/ldns-signzone.c \endlink Of course, we start by the usual includes. Since we need a bit more here, we'll add those right away. \skipline include \until define Let's skip the boring usage() and sanity check functions, and dive right into main(). \skipline main(int argc \skipline { We'll be reading another zone file, so let's prepare some variables for that. \skipline zone \until argi We will create a separate zone structure for the signed zone, so let's have a clear name for the original one. \skipline zone \until zone To sign a zone, we need keys, so we need some variables to read and store it; \skipline key \until status The \ref ldns_key structure holds (private) keys. These can be of any supported algorithm type; you can put an RSA key in it, an DSA key, or an HMAC key. Public keys can simply be put in an \ref ldns_rr structure with type \ref LDNS_RR_TYPE_DNSKEY. The \ref ldns_key_list type is much like the \ref ldns_rr_list, only, you guessed it, for \c ldns_key entries. The signed zone will be stored in a new file. \skipline file \until file And we have some command line options for the output zone. \skipline tm \until class \c origin is a domain name, so it can be stored in an \ref ldns_rdf variable with type \ref LDNS_RDF_TYPE_DNAME. The next part is option parsing, which is pretty straightforward using \c getopt(), so we'll skip this too. U can always look to the source of the file to check it out. Okay that's it for the variables, let's get to work! First we'll try to read in the zone that is to be signed. \skipline fopen(zone \until } else { If the file exists and can be read, we'll let ldns mold it into a zone structure: \skipline zone_new This creates a new (\c new) zone from (\c frm) a filepointer (\c fp), while remembering the current line (\c l) in the input file (for error messages). A pointer to the zone structure to be filled is passed as the first argument, like in most \c new_frm functions. Like a lot of ldns functions, this one returns a \c ldns_status indicating success or the type of failure, so let us check that. \skipline STATUS \until } else { If everything is ok so far, we check if the zone has a SOA record and contains actual data. \skipline orig_soa \until } \until } \until } Now that we have the complete zone in our memory, we won't be needing the file anymore. \skipline fclose \until } If there was no origin given, we'll use the one derived from the original zone file. \skipline origin \until } No signing party can be complete without keys to sign with, let's fetch those. Multiple key files can be specified on the command line, by using the base names of the .key/.private file pairs. \skipline key \until fopen As you can see, we append ".private" to the name, which should result in the complete file name of the private key. Later we'll also form the ".key" file name, which will be directly included in the signed zone. If the file exists, we'll read it and create a \c ldns_key from its contents, much like the way we read the zone earlier. \skipline line_nr \until STATUS If this went ok, we need to set the inception and expiration times, which are set in the keys, but will eventually end up in the RRSIGs generated by those keys. \skipline expiration \until } \skipline inception \until } And now that we have read the private keys, we read the public keys and add them to the zone. Reading them from the files works roughly the same as reading private keys, but public keys are normal Resource Records, and they can be stored in general \c ldns_rr structures. \skipline FREE \until } \until } With \c push() we add them to our key list and our zone. This function clones the data, so we can safely free it after that. \skipline push \until free And if we're done, we free the allocated memory for the file name. \until FREE If the reading did not work, we print an error. Finally, we move on to the next key in the argument list. \skipline } else { \until } \until } \until } Just to be sure, we add a little check to see if we actually have any keys now. \skipline count \until } So, we have our zone, we have our keys, let's do some signing! \skipline sign Yes. That's it. We now have a completely signed zone, \c ldns_zone_sign checks the keys, and uses the zone signing keys to sign the data resource records. NSEC and RRSIG resource records are generated and added to the new zone. So now that we have a signed zone, all that is left is to store it somewhere. If no explicit output file name was given, we'll just append ".signed" to the original zone file name. \skipline outputfile \until } \c ldns_zone_sign returns NULL if the signing did not work, so we must check that. \skipline signed_zone \until } else { Writing to a file is no different than normal printing, so we'll print to the file and close it. \skipline print \until } And of course, give an error if the signing failed. \skipline } else { \until } Just to be nice, let's free the rest of the data we allocated, and exit with the right return value. \skipline free \until } */ldns-1.6.17/doc/API.xml0000664000175100017510000003321012264060151014012 0ustar willemwillem LibDNS API NLnet Labs
Kruislaan 419 Amsterdam 1098 VA The Netherlands miek@nlnetlabs.nl http://www.nlnetlabs.nl
NLnet Labs
Kruislaan 419 Amsterdam 1098 VA The Netherlands jelte@nlnetlabs.nl http://www.nlnetlabs.nl
NLnet Labs
Kruislaan 419 Amsterdam 1098 VA The Netherlands erik@nlnetlabs.nl http://www.nlnetlabs.nl
DNS Elite Hacking A small abstract will come here, TBD.
LibDNS (or lDNS) is modelled after the Net::DNS perl library. It has been shown that Net::DNS can be used vefficiently for programming DNS aware applications. We want to bring the same level of efficiency to C programmers. The lDNS API consist of two layers. The top-layer, this is what is actually exported to the application via the library. And the bottom-layer, this is what lDNS needs to compile and function.
Short intermezzo detailing differences with other libraries. Most important ones are the libc resolver interface (from BIND8) and the lwres_ interface from BIND9.
At its lowest level lDNS is only dependent on libc. It uses a few networking systems calls; socket, bind, send/recv and friends. Further more it is to be expected that lDNS will depend on OpenSSL for its cryptography. As said, lDNS is modelled after Net::DNS, therefor its application API looks very much like the one used for Net::DNS. Some modification are made ofcourse, because not all functionality of Perl can be caught in C. This API document was written by carefully looking at the documentation contained in the Net::DNS Perl module.
The rdf structure, the RData Field, is a type that contains the different types in the rdata of an RR. Consider the following example: example.com. IN MX 10 mx.example.com. The "10 mx.example.com." is the rdata in this case. It consists of two fields, "10" and "mx.example.com". These have the types (in this case) LDNS_RDF_TYPE_INT8 and LDNS_RDF_TYPE_DNAME. The following functions operate on this structure. Create a new rdf structure. Return a pointer to it. Get the size of a rdf structure. Set the size of a rdf structure. Set the type of a rdf structure. Get the type of a rdf structure. Set the (binary/network order) data of a rdf structure. Get a pointer to the data in a rdf structure. Free a rdf structure. Create a new rdf structure from a string and a specific rdf_type. The type is needed to perform the correct conversion.
These functions operate on ldns_rr structures. Returns a pointer to the newly created ldns_rr structure. Prints the record to the stream s. Returns a pointer to a ldns_buffer containing with string containing RR-specific data. Returns the record's owner name as a ldns_rdf type. Returns the record's type. Returns the record's class. Returns the record's time-to-live (TTL). TODO the 'set' functions of the 'get'
In the DNS the atomic data type is an RRset. This is a list of RRs with the same ownername, type and class. Net::DNS doesn't have rrsets as a separate object. In lDNS we have the ldns_rr_list, which just holds a bunch of RR's. No specific check are made on the RRs that can be put in such a list. Special wrapper functions exist which allow the usage of ldns_rr_list of real (RFC compliant) RR sets. TODO: See rr.c
Create a new resolver structure and return the pointer to that. Returns the version of lDNS. Returns a ldns_pkt representing the MX records for the specified dname. Function is documented differently in Net::DNS. Do we need stuff like this?? XXX Set the default domain for this resolver. This domain is added when a query is made with a name without a trailing dot. Add a new nameserver to the resolver. These nameservers are queried when a search() or query() is done. Add a domain to the searchlist of a resolver. Perform a query. Try all the nameservers in the *res structure. Apply the search list. And default domain. If type is NULL it defaults to 'A', If class is NULL it default to 'IN'. Perform a query. Only the default domain is added. If type is NULL it defaults to 'A', If class is NULL it default to 'IN'. No search list nor default domain is applied. Return a pointer to a ldns_pkt structure with the information from the nameserver. If type is NULL it defaults to 'A', If class is NULL it default to 'IN'. TODO XX Gazillion helper functions to set port, src-port, etc. etc.
A packet structure (ldns_pkt) has five sections: The header section, a ldns_hdr structure. The question section, a ldns_rr_list structure. The answer section, a ldns_rr_list structure. The authority section, a ldns_rr_list structure. The additional section, a ldns_rr_list structure. ldns_hdr represents the header section of a DNS packet. A list of RRs in the Question section of a DNS packet. A list of RRs in the Question section of a DNS packet. A list of RRs in the Question section of a DNS packet. A list of RRs in the Question section of a DNS packet. Creates a new empty packet. Returns the packet data in binary format, suitable for sending to a nameserver. [XXX, suitable for sending to a NS?] Returns a ldns_hdr structure representing the header section of the packet. Returns a pointer to a ldns_rr_list representing the question section of the packet. Returns a pointer to a ldns_rr_list representing the answer section of the packet. Returns a pointer to a ldns_rr_list representing the authority section of the packet. Returns a pointer to a ldns_rr_list of representing the additional section of the packet. Prints the packet data on the standard output in an ASCII format similar to that used in DNS zone files. See RFC1035. Returns a ldns_buffer containing the string representation of the packet. Returns the IP address from which we received this packet. User-created packets will return NULL. Returns the size of the packet in bytes as it was received from a nameserver. User-created packets will return 0. [XXX user-created??] Adds *rr to the specified section of the packet. Return LDNS_STATUS_OK on success, LDNS_STATUS_ERR otherwise. Adds *rr to the specified section of the packet provided that the RR does not already exist in the packet. Return LDNS_STATUS_OK on success, LDNS_STATUS_ERR otherwise. Removes a RR from the specified section of the packet. Returns NULL if no RR's could be popped. Retrieve all RRs in a packet matching certain criteria. XXX function needs to be specified better. Print packet p to stream s.
Some resource records can have special access function no other RR has. Those are detailed here. XXX TODO don't exist (yet?).
insert your long list here.
A small example, which queries a nameserver on localhost to diplay the MX records for miek.nl.
/** * An example ldns program * In semi-C code * * Setup a resolver * Query a nameserver * Print the result */ #include <ldns.h> int main(void) { ldns_resolver *res; ldns_rdf *default_dom; ldns_rdf *nameserver; ldns_rdf *qname; ldns_pkt *pkt; /* init */ res = ldns_resolver_new(); if (!res) return 1; /* create a default domain and add it */ default_dom = ldns_rdf_new_frm_str("miek.nl.", LDNS_RDF_TYPE_DNAME); nameserver = ldns_rdf_new_frm_str("127.0.0.1", LDNS_RDF_TYPE_A); if (ldns_resolver_domain(res, default_dom) != LDNS_STATUS_OK) return 1; if (ldns_resolver_nameserver_push(res, nameserver) != LDNS_STATUS_OK) return 1; /* setup the question */ qname = ldns_rdf_new_frm_str("www", LDNS_RDF_TYPE_DNAME); /* fire it off. "miek.nl." will be added */ pkt = ldns_resolver_query(res, qname, LDNS_RR_TYPE_MX, NULL); /* print the resulting pkt to stdout */ ldns_pkt_print(stdout, pkt); return 0; }
ldns-1.6.17/doc/libdns.css0000664000175100017510000002157012264060151014652 0ustar willemwillemBODY,H1,H2,H3,H4,H5,H6,P,CENTER,TD,TH,UL,DL,DIV { font-family: Geneva, Arial, Helvetica, sans-serif; } BODY,TD { font-size: 90%; } H1 { text-align: center; font-size: 160%; } H2 { font-size: 120%; } H3 { font-size: 100%; } CAPTION { font-weight: bold } DIV.qindex { width: 100%; background-color: #e8eef2; border: 1px solid #84c7b0; text-align: center; margin: 2px; padding: 2px; line-height: 140%; } DIV.nav { width: 100%; background-color: #e8eef2; border: 1px solid #84c7b0; text-align: center; margin: 2px; padding: 2px; line-height: 140%; } DIV.navtab { background-color: #e8eef2; border: 1px solid #84c7b0; text-align: center; margin: 2px; margin-right: 15px; padding: 2px; } TD.navtab { font-size: 70%; } A { text-decoration: none; font-weight: bold; color: #1ba159; } A.qindex { text-decoration: none; font-weight: bold; color: #1ba159; } A.qindex:visited { text-decoration: none; font-weight: bold; color: #1b7159; } A.qindex:hover { text-decoration: none; background-color: #ddffdd; } A.qindexHL { text-decoration: none; font-weight: bold; background-color: #6666cc; color: #ffffff; border: 1px double #9295C2; } A.qindexHL:hover { text-decoration: none; background-color: #6666cc; color: #ffffff; } A.qindexHL:visited { text-decoration: none; background-color: #6666cc; color: #ffffff } A.el { text-decoration: none; font-weight: bold } A.elRef { font-weight: bold } A.code:link { text-decoration: none; font-weight: normal; color: #1ba159} A.code:visited { text-decoration: none; font-weight: normal; color: #1b7159} A.codeRef:link { font-weight: normal; color: #1ba159} A.codeRef:visited { font-weight: normal; color: #1b7159} A:hover { text-decoration: none; background-color: #c0c0c0 } DL.el { margin-left: -1cm } .fragment { font-family: monospace; font-size: 100%; } PRE.fragment { border: 1px solid #CCCCCC; background-color: #f5f5f5; margin-top: 4px; margin-bottom: 4px; margin-left: 2px; margin-right: 8px; padding-left: 6px; padding-right: 6px; padding-top: 4px; padding-bottom: 4px; } DIV.ah { background-color: black; font-weight: bold; color: #ffffff; margin-bottom: 3px; margin-top: 3px } TD.md { background-color: #F4F4FB; font-weight: bold; } TD.mdPrefix { background-color: #F4F4FB; color: #606060; font-size: 80%; } TD.mdname1 { background-color: #F4FBF4; font-weight: bold; color: #602020; } TD.mdname { background-color: #F4FBF4; font-weight: bold; color: #602020; width: 600px; } DIV.groupHeader { margin-left: 16px; margin-top: 12px; margin-bottom: 6px; font-weight: bold; } DIV.groupText { margin-left: 16px; font-style: italic; font-size: 90% } BODY { background: white; color: black; margin-right: 20px; margin-left: 20px; } TD.indexkey { background-color: #e8eef2; font-weight: bold; padding-right : 10px; padding-top : 2px; padding-left : 10px; padding-bottom : 2px; margin-left : 0px; margin-right : 0px; margin-top : 2px; margin-bottom : 2px; border: 1px solid #CCCCCC; } TD.indexvalue { background-color: #e8eef2; font-style: italic; padding-right : 10px; padding-top : 2px; padding-left : 10px; padding-bottom : 2px; margin-left : 0px; margin-right : 0px; margin-top : 2px; margin-bottom : 2px; border: 1px solid #CCCCCC; } TR.memlist { background-color: #f0f0f0; } P.formulaDsp { text-align: center; } IMG.formulaDsp { } IMG.formulaInl { vertical-align: middle; } SPAN.keyword { color: #008000 } SPAN.keywordtype { color: #604020 } SPAN.keywordflow { color: #e08000 } SPAN.comment { color: #800000 } SPAN.preprocessor { color: #806020 } SPAN.stringliteral { color: #002080 } SPAN.charliteral { color: #008080 } .mdTable { border: 1px solid #868686; background-color: #F4F4FB; } .mdRow { padding: 8px 10px; } .mdescLeft { padding: 0px 8px 4px 8px; font-size: 80%; font-style: italic; background-color: #FAFAFA; border-top: 1px none #E0E0E0; border-right: 1px none #E0E0E0; border-bottom: 1px none #E0E0E0; border-left: 1px none #E0E0E0; margin: 0px; } .mdescRight { padding: 0px 8px 4px 8px; font-size: 80%; font-style: italic; background-color: #FAFAFA; border-top: 1px none #E0E0E0; border-right: 1px none #E0E0E0; border-bottom: 1px none #E0E0E0; border-left: 1px none #E0E0E0; margin: 0px; } .memItemLeft { padding: 1px 0px 0px 8px; margin: 4px; border-top-width: 1px; border-right-width: 1px; border-bottom-width: 1px; border-left-width: 1px; border-top-color: #E0E0E0; border-right-color: #E0E0E0; border-bottom-color: #E0E0E0; border-left-color: #E0E0E0; border-top-style: solid; border-right-style: none; border-bottom-style: none; border-left-style: none; background-color: #FAFAFA; font-size: 80%; } .memItemRight { padding: 1px 8px 0px 8px; margin: 4px; border-top-width: 1px; border-right-width: 1px; border-bottom-width: 1px; border-left-width: 1px; border-top-color: #E0E0E0; border-right-color: #E0E0E0; border-bottom-color: #E0E0E0; border-left-color: #E0E0E0; border-top-style: solid; border-right-style: none; border-bottom-style: none; border-left-style: none; background-color: #FAFAFA; font-size: 80%; } .memTemplItemLeft { padding: 1px 0px 0px 8px; margin: 4px; border-top-width: 1px; border-right-width: 1px; border-bottom-width: 1px; border-left-width: 1px; border-top-color: #E0E0E0; border-right-color: #E0E0E0; border-bottom-color: #E0E0E0; border-left-color: #E0E0E0; border-top-style: none; border-right-style: none; border-bottom-style: none; border-left-style: none; background-color: #FAFAFA; font-size: 80%; } .memTemplItemRight { padding: 1px 8px 0px 8px; margin: 4px; border-top-width: 1px; border-right-width: 1px; border-bottom-width: 1px; border-left-width: 1px; border-top-color: #E0E0E0; border-right-color: #E0E0E0; border-bottom-color: #E0E0E0; border-left-color: #E0E0E0; border-top-style: none; border-right-style: none; border-bottom-style: none; border-left-style: none; background-color: #FAFAFA; font-size: 80%; } .memTemplParams { padding: 1px 0px 0px 8px; margin: 4px; border-top-width: 1px; border-right-width: 1px; border-bottom-width: 1px; border-left-width: 1px; border-top-color: #E0E0E0; border-right-color: #E0E0E0; border-bottom-color: #E0E0E0; border-left-color: #E0E0E0; border-top-style: solid; border-right-style: none; border-bottom-style: none; border-left-style: none; color: #606060; background-color: #FAFAFA; font-size: 80%; } .search { color: #009933; font-weight: bold; } FORM.search { margin-bottom: 0px; margin-top: 0px; } INPUT.search { font-size: 75%; color: #008000; font-weight: normal; background-color: #e8eef2; } TD.tiny { font-size: 75%; } a { color: #1ba159; } a:visited { color: #1b7159; } .dirtab { padding: 4px; border-collapse: collapse; border: 1px solid #84b0c7; } TH.dirtab { background: #e8eef2; font-weight: bold; } HR { height: 1px; border: none; border-top: 1px solid black; } /* tabs styles, based on http://www.alistapart.com/articles/slidingdoors */ DIV.tabs { float : left; width : 100%; background : url("tab_b.gif") repeat-x bottom; margin-bottom : 4px; } DIV.tabs UL { margin : 0px; padding-left : 10px; list-style : none; } DIV.tabs LI, DIV.tabs FORM { display : inline; margin : 0px; padding : 0px; } DIV.tabs FORM { float : right; } DIV.tabs A { float : left; background : url("tab_r.gif") no-repeat right top; border-bottom : 1px solid #84C7B0; font-size : x-small; font-weight : bold; text-decoration : none; } DIV.tabs A:hover { background-position: 100% -150px; } DIV.tabs A:link, DIV.tabs A:visited, DIV.tabs A:active, DIV.tabs A:hover { color: #1b7159; } DIV.tabs SPAN { float : left; display : block; background : url("tab_l.gif") no-repeat left top; padding : 5px 9px; white-space : nowrap; } DIV.tabs INPUT { float : right; display : inline; font-size : 1em; } DIV.tabs TD { font-size : x-small; font-weight : bold; text-decoration : none; } /* Commented Backslash Hack hides rule from IE5-Mac \*/ DIV.tabs SPAN {float : none;} /* End IE5-Mac hack */ DIV.tabs A:hover SPAN { background-position: 0% -150px; } DIV.tabs LI#current A { background-position: 100% -150px; border-width : 0px; } DIV.tabs LI#current SPAN { background-position: 0% -150px; padding-bottom : 6px; } DIV.nav { background : none; border : none; border-bottom : 1px solid #84C7B0; } .logo { text-align: right; } ldns-1.6.17/doc/tutorial1_mx.dox0000664000175100017510000001012712264060151016025 0ustar willemwillem/** \page tutorial1_mx Tutorial 1: Querying for MX records \dontinclude ldns-mx.c The full source code can be found in \link examples/ldns-mx.c \endlink ldns-mx is a simple tool that queries your default caching forwarder for the MX (Mail exchange) record of the given domain.
   % ldns-mx nlnetlabs.nl
   nlnetlabs.nl.   86400   IN      MX      100 omval.tednet.nl.
   nlnetlabs.nl.   86400   IN      MX      50 open.nlnetlabs.nl.
   
First of all, we need to include the correct header files, so that all functions are available to us: \skip include \until dns.h In this case we have used a configure script to generate a config.h file that does all our inclusions for us, so that it can be compiled on multiple platforms. If your platform supports the include files \c stdint.h and \c stdlib.h, you can include these instead of using a configure script. The first included files are prerequisites that ldns needs to function. The last one, of course, includes the functions of ldns itself. In our main function, we declare some variables that we are going to use: \skipline ldns_resolver \until ldns_status - The \c ldns_resolver structure keeps a list of nameservers, and can perform queries for us - An \c ldns_rdf is a basic data type of dns, the RDATA. See \ref design for a description about the building blocks of DNS. In this case, \c domain will be used to store the name the user specifies when calling the program - An \c ldns_pkt is a DNS packet, for instance a complete query, or an answer - The \c ldns_rr_list structure contains a list of DNS Resource Records (RRs). In this case, we will store the MX records we find in the list. - \c ldns_status is the basic type for status messages in ldns. Most functions will return a value of this type. First, we parse the command line argument (checks omitted on this page, see full source code), and store it in our \c domain variable: \skipline ldns_dname_new_frm_str This function takes a string containing a domain name (like "nlnetlabs.nl") and returns an \c ldns_rdf representing that name. If somehow the given string can not be parsed it returns NULL. Then, we create the resolver structure: \skipline ldns_resolver_new Most of the functions work like this, the first argument is a pointer to the structure where ldns should store its results (which is also a pointer). The function returns a status code indicating success (\ref LDNS_STATUS_OK) or an error number. Remember that these types of functions allocate memory that you should free later (using the ldns_free_ functions). The second argument is the filename that contains information about the resolver structure that is to be created. If this argument is NULL, /etc/resolv.conf is used. The syntax of the file is like that of /etc/resolv.conf. We tell the resolver to query for our domain, type MX, of class IN: \skipline ldns_resolver_query \until ) The last argument contains flags to influence the type of query the resolver structure sends. In this case, we want the nameserver to use recursion, so that we'll get the final answer. Therefore, we specify the \ref LDNS_RD (Recursion Desired) flag. This should return a packet if everything goes well. We get all RRs of type MX from the answer packet and store them in our list: \skipline ldns_pkt_rr_list_by_type \until ) If this list is not empty, we sort and print it: \skipline ldns_rr_list_sort \skipline ldns_rr_list_print And finally, just to be proper, we free our allocated data: \skipline free( \until resolver_deep_free For structures that can contain other ldns structures, there are two types of free() function available - \c ldns_free_ frees only the allocated data for the structure itself. - \c ldns_deep_free_ frees the structure, and ALL structures that are nested in it. For example, of you \c deep_free an ldns_rr_list, all \c ldns_rr structures that were present in the list are also freed. */ ldns-1.6.17/doc/design.dox0000664000175100017510000001041712264060151014650 0ustar willemwillem/** \page design Design The following image shows the various modules of libdns and their functionality. \image html libdnsoverview.png \section central_structures Central structures - \ref ldns_pkt A DNS Packet, which can contain a query, answers, and additional information. - \ref ldns_rr A Resource Record, which holds a bit of information about a specific domain name. - \ref ldns_rdf An RDATA field, every Resource Record contains one or more RDATA fields, depending on the type of RR. These are the 'basic types' of DNS data. - \ref ldns_rr_list A list of resource records - \ref ldns_zone A representation of a DNS Zone. The actual structure definitions are named \c ldns_struct_ which are all typedeffed to \c ldns_ A DNS Resource record looks like this:
nlnetlabs.nl.   600     IN      MX             10    open.nlnetlabs.nl.
 \              \       \       \              \                     /
  owner          ttl     class   type           \        rdf[]      /
  (rdf)     (uint32_t) (rr_class) (rr_type)
                                                 10          := rdf[0]
                                                 open.nlnetlabs.nl. := rdf[1]
* Owner: The owner name is put in an \c ldns_rdf structure, which is a normal rdata field but always has the type LDNS_RDF_TYPE_DNAME. An \ref ldns_rdf structure has 3 members; the size, the type of rdata and a void * pointer to the data. The data is always in uncompressed wireformat. The RSH (rdata) is put in an array of rdf's (in this case 2). The entire resource record is put in a RR structure, which has the fields described above (under the RR): - owner (nlnetlabs.nl.) - ttl (600) - class (LDNS_RR_CLASS_IN: 'IN') - type (LDNS_RR_TYPE_MX: 'MX') - rd_count (2) - rdata_fields[rd_count] - rdf[0] (10) - rdf[1] (open.nlnetlabs.nl.) * RR list structure: An RR list structure is simply a structure with a counter and an array of RR structures. Different kinds of RR's can be grouped together this way. * RRset structure: An RRset structure is an RR list structure, but its accessor function checks if the \c ldns_rr structures in there are: - from the same type - have the same TTL - have the same ownername This is the RFC definition of an RRset. * pkt structure: A pkt structure consists out of a header structure where packet specific flags are kept, TC, RD, IP from the server which sent the packet, etc. Further more it is divided in 4 sections: question, authority, answer and additional. All four sections have the type RRlist that simply hold a list of RR's \section wire_module Wire module and central structures Interface As the WIRE module takes care of the compression/decompression it needs a buffer which holds all the binary DNS data. All functions will operate on such a buffer to extract specific information which is then stored in RR structures. \section resolver_module Resolver module and central structures Interface The resolver module always returns a pkt structure. Either with the answer or a SERVFAIL pkt. The exact function-call parameters have not yet been decided on. Also the resolver module will need to access some of the to_wire and from_wire function to creates ldn_pkt's from the data it receives (arrow not drawn). \section str_module str module and central structures Interface Convert to and from strings. This module could be used to read in a zone file (list of RRs) and convert the text strings to the format used by ldns. Or the other way around. \section net_module Net module and resolver module interface The resolver module will get a packet and will mold it so that it can be sent off to a nameserver. It might need to interface with the wire module (arrow not drawn). \section Net module and OS/libc interface OS/network calls will be used here. The Net module is the only part of the library where the underlying OS matters. \section Client program ldns interface Any client program will have access to - Wire module - Central structures - Resolver module - str module (arrow not drawn in the above figure) \section dnssec_module DNSSEC module The DNSSEC types are handled in the RR module, but the crypto routines are contained in this module. This module will depend on OpenSSL for the crypto routines. */ ldns-1.6.17/doc/tutorial2_zone.dox0000664000175100017510000000703012264060151016354 0ustar willemwillem/** \page tutorial2_zone Tutorial 2: Reading a zone file \dontinclude ldns-read-zone.c The full source code can be found in \link examples/ldns-read-zone.c \endlink ldns-read-zone reads a zone file, and prints it to stdout, with 1 resource record per line.
% cat example.zone
$ORIGIN example.
$TTL 600

example.        IN SOA  example. op.example. (
                                2004022501 ; serial
                                28800      ; refresh (8 hours)
                                7200       ; retry (2 hours)
                                604800     ; expire (1 week)
                                18000      ; minimum (5 hours)
                                )

@       IN      MX      10 mail.example.
@       IN      NS      ns1
@       IN      NS      ns2
@       IN      A       123.123.123.123

% ldns-read-zone example.zone
example.        600     IN      SOA     example. op.example. 2004022501 28800 7200 604800 18000
example.        600     IN      MX      10 mail.example.
example.        600     IN      NS      ns1.example.
example.        600     IN      NS      ns2.example.
example.        600     IN      A       123.123.123.123
   
Again, let's start with including some necessary header files: \skipline include \until errno In this example, we are going to open a file, if that fails, we'll need errno.h to display an error message. Okay, let's declare the variables we are going to need today: \skipline filename \until ldns_status The only two ldns-specific types here are \c ldns_zone and \c ldns_status. - \c ldns_zone is the structure that can contain a complete zone - \c ldns_status again is used to check return values of ldns functions If we get no filename, we'll read standard input, otherwise, we'll try to open the given filename: \skipline if (argc == 0) \until exit(EXIT_FAILURE) \until } \until } With the \c FILE pointer in our hands, we visit ldns to pour it into a zone structure: \skipline ldns_zone_new_frm_fp_l There is also a \c ldns_zone_new_frm_fp, but this one also remembers the line number it was on, so we can use that if we encounter a parse error. Just like in \ref tutorial1_mx, the first argument is a pointer to the place ldns should store its creation in, and again, the return value is the status code. The second argument is the file pointer where our zone data should reside. The third argument, if not NULL, is a \c dname that contains the zones origin. It will place this dname after every name in the file that is not a fully qualified domain name. The fourth argument, if not 0, is the default TTL to use. Both these values can be specified in the zone file by setting \c $ORIGIN and \c $TTL. The fifth argument specifies the default class, which defaults to IN (\ref LDNS_RR_CLASS_IN). And finally, every time \c ldns_zone_new_frm_fp_l reads a line from the input file pointer, it will increment the value pointed to by the last argument with 1. Okay, with that, we should have a nice zone structure. Of course we need to check whether it has succeeded. \skipline LDNS_STATUS_OK \until deep_free If everything went well, we sort the zone if necessary, print it, and free it. Since \c ldns_zone contains other ldns structures, we use \c ldns_deep_free so that every \c ldns_rr_list, \c ldns_rr et cetera are freed too. \until line_nr); \until } If something went wrong, we use \c ldns_get_errorstr_by_id() to get a nice error string instead of just a status integer. And of course, we should play nice and close the file: \skipline fclose \until exit */ ldns-1.6.17/doc/API-header.xml0000664000175100017510000000620112264060151015240 0ustar willemwillem LibDNS API NLnet Labs
Kruislaan 419 Amsterdam 1098 VA The Netherlands miek@nlnetlabs.nl http://www.nlnetlabs.nl
NLnet Labs
Kruislaan 419 Amsterdam 1098 VA The Netherlands jelte@nlnetlabs.nl http://www.nlnetlabs.nl
NLnet Labs
Kruislaan 419 Amsterdam 1098 VA The Netherlands erik@nlnetlabs.nl http://www.nlnetlabs.nl
DNS Elite Hacking A small abstract will come here, TBD.
LibDNS (or lDNS) is modelled after the Net::DNS perl library. It has been shown that Net::DNS can be used vefficiently for programming DNS aware applications. We want to bring the same level of efficiency to C programmers. The lDNS API consist of two layers. The top-layer, this is what is actually exported to the application via the library. And the bottom-layer, this is what lDNS needs to compile and function.
Short intermezzo detailing differences with other libraries. Most important ones are the libc resolver interface (from BIND8) and the lwres_ interface from BIND9.
At its lowest level lDNS is only dependent on libc. It uses a few networking systems calls; socket, bind, send/recv and friends. Further more it is to be expected that lDNS will depend on OpenSSL for its cryptography. As said, lDNS is modelled after Net::DNS, therefor its application API looks very much like the one used for Net::DNS. Some modification are made ofcourse, because not all functionality of Perl can be caught in C. This API document was written by carefully looking at the documentation contained in the Net::DNS Perl module.
ldns-1.6.17/doc/header.html0000664000175100017510000000057212264060151015002 0ustar willemwillem ldns documentation ldns-1.6.17/doc/images/0000775000175100017510000000000012264060151014125 5ustar willemwillemldns-1.6.17/doc/images/libdnsoverview.svg0000664000175100017510000004675312264060151017727 0ustar willemwillem image/svg+xml - CLIENT - any program making use of ldns - WIRE module - from_wire to_wire- convert to and from wireformat- all name encoding and decoding is contained in these functions - central structures - pkt structurerdf structuredname structurerr structurerrlist structurerrset structurepkt structurezone structure - resolver module - stub resolversendquerybgsendaxfr - net module - all network interfacing code - OS/libc layer - str module from_str to_str- convert from and to string- dig-style formatted output DNSSEC module signverify ldns-1.6.17/doc/images/libdnsoverview.png0000664000175100017510000012517612264060151017711 0ustar willemwillem‰PNG  IHDRA«Ç3CÔbKGDÿÿÿ ½§“ pHYsHHFÉk>€IDATxÚìu¸UÒ‡ß_ ˆbA‚KÐàîw]\XÜv?XXX`qwwwww×àî. $!©ïªáv†¹’+™+õ>O?Ó§ûôéj™îê:uªdf$I’LH$uö6¦>nÎ6³’..5³‡Ê¶\¬bf£$í ¬YÖüf¶ž¤NÀCÀf¶[¡žÀ}À©uˆ¹µ™}\ís•$IËÑ¥Ú$IÒ±Ô¸ W~þ ¼Ìì ¬Ü ,ÜSaóÀr@§(¾N+ÔUÚUÔ]BÒµföX,Ÿè œË—«¶ÿ¶Úç*I’–%• $I&4K³˜Ù7±ìSà‰°/ŸšÙ#u¬?8Xª¸ÐÌ~4G,~ÌÌ~¯ö J’dÂЩéM$I’Œkw ?1³Qh¯Ÿ¤…i@Ùú3€é%­]íO’¤u‘– $I&4ýñ.°æb `áBùI`ûBùwààHIwVûà“$i=¤”$I³"é!j¬ÌÛ˜ÙGeU~&kÆ]^af{ÖSçRàÿ€Í›p\›;GñI3;°!I’*JP’$ÍÍ>¸S2À—Ö? ì)©«™ž™ÙI'·7²™‡€·cþ§ !w’$-Kú%IÒ¬˜Ù+f6$¦‘ª\„€)©;€¤N’¶–´t Êu3ð5°Y#·ÿºp\L€S™$I “JP’$3û ?3ðƒ¤¡ÀÏÀ߀b×ÙU’¬0[K“{”Õ³ˆT‰ý)ª}’$i(ƒ%&IR-$õú_äÐô$I&4©%I’$IÒ!Éî°$I’$I:$©%I’$IÒ!I%(I’$I’I*AI’$I’tHR J’$I’¤C’JP’$I’$’T‚’$I’$餔$I’$I‡$• $IÚ’“´WëêË:ßf‘´Š¤%TaÝê’¶¬cÛÿHš½ÚÇ$ŠT‚’$i̬U˺ÞÀ€j ØHš¸x Ïz_΂Àòu4±0mµ#I&©%I3!©»¤y$Í(I…åŠYHš\Ò¬¥õ’:—Ö•µÕ»RPIÇÔYÒÀRöÂú^‘‘}RIs–÷“4·¤‰+´Ù3Úê\j?–w‘Ô3æ§“4mÌwú³Iê\Iîø«pœ=ãÜLTÇùë&©Gœ¯Ù%M^X7«¤¶é'i¤:“¢F›}$u-./´5[ñÚÅòN!Oß⵬e?}ÊÊ=ŠÇ,iIóIš#d)Öíç¬oâzNVÜXx¸x©¾vb»)%M_ayé^ë×»W…:3Kš_R¿†ì+IZ]šÞD’$’ÖNÞ¦~‘´š™ýL |"éx`%`Jà` ;ð±¤EÍìhk!à^ü‹|dÙ®ŽÀ³¯OüÌ+iG3»5Ö\¬ |,/é`sà-`.IÛ›Ùm±¯€ó€—q É0<“û¾x¦÷Ó%½ÌÜ"éàà} 'ÐKÒfö~ìÿsàl`E /𞤓€ß€~’–0³/+œÆCî.@·8¶­€­€é€Y%nfÿ ÙÖ>æ‘t«™íZáÚL\ °-°I´¹JóÑÖÊÀdÀиvcC©¹˜øxØ‹ ¡ý•¨ gS$­r Yº‹Ç¶[Go%]nfÔr¯­×ø-`I7šÙn!ÿÁÀT!ó1Õußžl ¼#é' ¨$÷î,À(`nI›šÙ=¡(ß뇅Û™ÙÃ$I[ÂÌrÊ)§&N@ s¡|pHÌOƒ¿ôvŠòÄÀ§À2Q> 8©°í¹À µìçà[`Š(¯ |ôˆòwÀù…úkàŠÉd…ò÷!oϘ_:ÖM|å•CîÁ…ö&&.”®(”‡GŽó à~ [,»8 –cÛWì¦òÎøËw(~&Šòä…m'ƈÒ9Ý2öÛx8†š„Ñ[÷®›{G¹®à­åcðî¥Ò¶Gck‘¿·?RÇYvu¡í»€Ý‹2Çïlq gŒò$¸¢´L…}ô¾Ör_\ Ü8Ê©ã>=¸ æW>úFyÍ8+DùdàÃÂú¿Oî»wËÚž¨ÚÿÜrß)»Ã’¤yøØHÒ)’.æ•Õ¹ ÀÌ~^fåg[G×äÀ¦¸u¦6î2³o¢­{qÅ`þÂúK ó«7šÙwQÿ.Ü¢±°ð“™=ë¾n+Û×gfö@©`f¿ˆãíÅÀ²Žóš²ã¼ÝÌFźç Ç]‰'Ìì³BÝQV+3{WŠJÝb#%í%é,à\™¯ÐÖTÀ£À5f¶¿Å›ºJ×f0¤ ãŠÀ•…m/ªïF¨ƒ7€Ý$í.i¦8?«ãÖ·%$mlH(ÉÚ˜ßÅtËŸ™ý\ n„<ƒÛ¢ ÌìN\a.rGi=ã^»÷€i$&iI]Íldƒöš$­ˆT‚’¤y8Øx8x ÿj/1ÖÌ~+”ÿ º£Íì5ÜŠ±®½hfïÖ±¯_*”‹þßæ{ã Z‘p+Pw¼‹ªHy¹ØV©Ûædài¼«å޲ãøµì8ËË]ë8¶òºÃËÖ·¿·Ý„+Aï—É2ЯÂùªDq?£ ûè+™µŸ¿PæST|Æþ8 W_“t]ø}õzÓãÝ~SãÝYOWh¾®ë9¾ô¢ò½T¤x=þðOà†èb,9LßbfO–íã#I××J:5ê-‚+ ãËeÀ’ŽžÄ•ðá ÙPÒêÀbø=5®<Ñ’¤ª¤”$ÍÃ?cZ ´)P¢þ ð¿²úWS°Þ˜ÙHIïügjãàE`=Üù÷´Âºcq'ÛR»?Æh³]B¶(ø™Ùž’ÖÁGœ ì;3ƒ¿œÏ.Û÷)x·Èj¸•icܧ¥Ä‘x÷L‰+ñQL%žÄýI*ñ,ãú¤|_V§x|«àJà걟ۨ±À¼JŸÏ‡’–v45nÝ)ñ{\›? Ën>‰m_—´8î4ü5pgáºVbSà_¸õí¼{´äãô®­í/ff#$­„+2kâJèàõZö±°C\Ï/K>b±Í%uÈ÷C3û9Žmë0`aj”÷{pËV‰oqGq¢pås$ðfv3IÒÆPݾ‚I’L$ÍŠ[Yæ1³ê¨wî»o3íw îüü‹¤ùqëÒ²fözÓZnHê 4³W#&ÓùÀH3Û¾Ú²%IÒtÒ1:IªŒ¤Óq_ŠƒëR€ZˆÅ7$}…[SöHhºÇùyï Û¯ÚB%IÒ<¤%(I’¤AwÅ»7_»\óÁŸ$¤”$IÒî‘4ïêì‡ûA½ <;6¿„>Ûø=$IÛ$• $)CÒ$ø°ã§Ì¬A£e’ ¤Î Rž’fÇGsuÁ»ö†ã#»àažÄ£·óü&íT‚’O8¼.…èY ˜ø‡™]RmÙ’Ú‘´ Þµó~“ë Hšx ¦Ý­B•’blr(n1z¸É<^’´rˆ|ÒáˆäKàJÏÚx@»ßð¼Xƒ/©¶œI½¬‡ ?«Ú‚´ÌìSI âŠÍ Œ›0üþŸW„ÆFyžìÇjËŸ$ÍMZ‚’vOd_P·60îуq?†ÿ3³ãÇ{'É'Fl½nf+U[–¶†¤^¸Ð\xú”cpëÏ9xιO«-k’´$©%펈í²®ô¬Ì‹[zzP{ÞªáÀ‰fvHµåOê'â½Å^f6ºÚ2µ5¢ø.`Qjr®ý†§Sy8ÄÌÞ¨¶œIÒ’dœ ¤=2Oüø Øp³~m÷ûpàœT€ÚkÅïHÜŸ+O"¡ï*x$ë’Ðh`s2fÓLÐ&ÙèY(Æ£¤‰˜ÙáÀ.T°®™Ù·ñ?š+½)éxI“W[î$i,©%í I%Ý œìefk™ÙÐX=÷yxØ £á¶=$ X wt/ÑØ Ú²µÌìà¶:Öif{óáçþIGHê[mÙ“d|I%(iHê-é$<-ÀýÀ¼fvwYµ5ñh¹kæê6ËÂŒ«•X)¤¤0³—PçS3Û¿&ÓC%,©g½;H’VB*AI›FR'I;ïà_¥s›ÙIåJNÄDùXÙÌFV[î¤Ñ¬ƒ§sÿG̨¶p3ûÀ̶Ãóíͼ/éß‘ƒ/IZ5©%mIKãñL¶Ö0³ÍìëZª÷6ŠØ(IÛe<çÕà[\±ý.ŸC嫈™½kf[+àÖ¡÷$íij’¤U’£“6‡¤Àqx¼›ÙÕÕ–)iyb4Ò'x¬§ûðÏÿ¦^3³ù«-gâHš8 X8 ¸ÀÌFU[®$)’– ¤Í ©»¤ƒñt C©u(VÇãÝlË~ÀS¤| Ì›þ(­3bfëàNëëïJÚ^R&îNZ ©%mIoá#R6³ƒÍlDµåJ&(k׋‘}€±fö9žÿê<_\ÒŠ0³çÌl5`˘ޒ´¥¤|ÿ$U'o¤U#i>IÛ™ÙFföaµåJ&,’ºÀÍÍlli1ž3û XwÌMZ!fö„™­ì„Ç"z]Ò&9ª/©&©%­I“I: î~=°€™=\m¹’ª!`ß²à–ðQa€ÙN¯¶ IݘÙCf¶ðO`_`ˆ¤u«-WÒ1I%(iUHê"i¼ëk î÷sV6ìØ˜Ù¨ ѽÇQ‚¢^v‘¶Ìì3[·ò&éyI«U[®¤c‘JPÒj4‚g|_ÁÌö0³ª-WÒjù³;,i»˜Ù­ÀüøˆÏ“$=)iÅjË•t R JªŽ¤™%Ý œ ü×Ì›ÙÕ–+iõüÅ”´M̹˜88WÒC’–ª¶lIû&• ¤jHšTÒQÀsÀóÀ\fvsµåJÚ i jg˜ÙX3»˜¸¸BÒ=’©¶lIû$• d‚#g+àm`0Ÿ™•é,’ñ$-Aí3ûÃÌ.fnn’t«¤AÕ–-i_¤”LPâ‹î)`O`c3Û*â¼$Éø’JP;ÇÌF›ÙÙÀlÀCÀÝ’®“4WµeKÚ©%Iý%]ŒÕ,jfOW[®¤M“Ýa3ûÝÌNfŻΖt…¤Y«-[Ò¶I%(iQ$u“´ð:ð >äýbˤuIÓIKPÃÌF˜Ùñ¸2ô6ð´¤ %ÍXmÙ’¶I*AI‹!i-à `Y` 3ÛÏÌ~®¶\I»!-A3ûÅÌŽÀ»É>^t–¤i«-[Ò¶H%(iv$ ”tp°‡™­efC«-WÒîHKPÇÌ~4³ƒñt)¿¯J:EÒTÕ–-i¤”4’zK: x¸˜×Ìî©¶\I»%• 3ûÎÌþ Ì…[ß”t¬¤Éª-[ÒºI%(i2’:IÚxè Ìmf'™ÙèjË–´k²;,3ûÊÌöæÃŸEïH:LRŸjË–´NR Jš„¤e€€­5ÌlG3ûºÚr%í‹È"_Î_,A’:W[Ö¤ú˜Ùgf¶+°0 0TÒA’zV[¶¤u‘JPÒ($ t5p%p¼™-cf/U[®¤ÝÒCÒ¿Ë–u¢` ?í«-hÒz0³Ìl` Üoè=IûJêQmÙ’ÖA*AÉx!©»¤ƒ—¡ø÷««-WÒ¾1³Ÿ€ $ý·°X„%HÒÔÀÀ°jËš´>Ìì=3Û XXW†ö”4Q]ÛIÚ6¦öM*AIƒ‘´1ð0/°™lf#ª-WÒa¸8¬ uÆJšÏ?7x¬ÚB&­3{ËÌþ¬¬€+C;×ÒÝ 0xPRïjËž´ ©%õ"i¤G€ƒ€mÍlc3û¨Úr%Ž»€QÀþ’Â-A“ã„§7³QÕ2iý˜Ù«f¶>°°ð®¤í*ø”Ý…û=/iÊjË4?ÊÀ½ImÄðÒ#€ €CóÌlLµåJ:&’:?“#€n@_à7`3» Úr&mIK‡ÓãϺk̬ÔÕú° ð9°”™}\my“æ#-AÉ_ÔEÒžx××hÜïçìT€’j/¥£Ø˜ètŽé®j˘´MÌìi3 ìì¼&i#I.Å•îþÀ‹’樶¼Ió‘JP2’¯à&âÌlO3û¡Úr%Ip# +5ϰ/Ììój —´mÌìQ3[ØØx  t‰©ð¬¤ª-kÒ-[<¸­Ú²%íIÓHÚ 8˜(º˜¸OÒjÕ–5i©uPäl¼-žÏÌŽ2³‘Õ–-IêáfÆ})už­¶PIÛ&>ÿ)é9\Ñ>)41нÂ&Ý›$ý­Ú²''»Ã: ’NÅ_{™ÙÓÕ–)IФeÛ^±è–îœ$M"#‡Å/,†‡_ûU œø°·™Wmù“ñ'• „¤þÀÑÀªÀÀ%–7@ÒÆÔwŽžø ØÍÌ®¬¶\IûDRwþªMÇ¸Š‘ÿ1³cª-o2~¤ÔÔ ØØ¸8ÜÌ~iR£IRE$=¬„Ü™Ö̾«¶LIÇAÒÄÔ(FK‹ã1†Ž5³«-_ÒpR jçHZõõ6ðO3Zm™’¤©Húpð–™Í[my’$òÍ |lfßV[ž¤at©¶IË i p 0°‡™ÝSm™’¤¹÷i»®Ú‚$ @ *y©Úr$ãGŽkCDôÒúêô‘t2ð8p/>ê+ ¤]© Þ,I’´]R j#Ĩ…ëXß)ºÞÆs+Íef'›ÙèjËž$-Äyförµ…H’¤í’JP œðîÂ@+­_xØ XÃÌþafßT[î$iaN«¶IR‘ƒqŠjËÑLÇ1yëN‰·Û ©µrbd×=ÀrÀeëHº¸8ÎÌ–1³ì“N:iåLZ9s¯W[ˆf`^<›@CX ¸¯Ú©µb"ÊmÀ’ÀgföY,ï.é`àeÜ/b ™]Smy“¤¹‘4Ÿ¤W[Ž$IÚ'©µR$u®ÇƒsuîŽåoáÚùBfv°™¨¶¼IRޤµ%]ÛÄff6hľ_Š’-ulŸIêÛRí'-‹¤C%Í#é(IWƲ>’‘t½¤cŠ]Y’“t¤[%-ižÂº5%]"érIÔ²¿5%m^¶leIÛÊëKº8ÚZ­lß;F—JZ·Bû›F{»IºNÒþá'º~ÏIÅû5º­öu§K𥬽%]-é _a¹$áJË6‘´J-ÇÝ%dºZÒY’æ®öµ/'• VHŒ»XFú ð¦¤G€ƒ€mÍlc3û¨Ú²&í‡x`Í!i`(áÅu=%ÍþiÅå½ãÁØ;¶íË;“SÄË¥w,ïà.’æ*µ'©¯¤A’¦O™»F;óDd_$MLô}w“ÔYR¯Xß_Òô±í$eíõªpìS‡l=£<)Ðèíw©¥­Þ…óÑ#äèç±[,ïçmÊ Ç6™¤$ÍXí{£²#p10¸&ž¼ˆ‡9øx2®Yoà~Üò~ >ò¶üùQzî³y#pФ*ìïGà¤°î—ø_iFÒ€ÿ×F;g”¹Ãñë€÷*´¿2p.žéþ"`;<µÌjÀyÀÌÀ…ú×Ëâ±¶¾ž—4uȲ-p,þz8¹°€½b?%ãQ´+qþ!vœß‡%ÍÔò—w<0³œZÙœüЇb7øEù5[ÿ0øÂÌ6kä>Ç›T‚Z’޶g\üþÇØ$&B:ØÌ^©¶ìIë%²SEñC3û°¬ÊÒx¨ÿ»K ¬ÆÏlüáºAáAn¢6æ/‹mÆHz¨O!¸ÑÆÍ]÷»¤=ð‡p\á„[wêâ `IÿnkÀÿ`¸™]ßÀs&ü«v13Ç7ª‰—â:3óËà_ÿ³Iš#ÎëW±üŠ8¶$]Ükr£…ŒË=cf¿7QÆöÀ-¸E ®ôÅÑ…ßâÖÏ*U4³}c0ÊÊÀ!¸¥sgÜB_ô ›ø%þ åÍ\ÃÍ·¶)ìÛ€% ÷G94à¸ÇÖS.ñÑW&wI)ú¡lýŸÇgfc%aÜî°žµìç[à=3[ ²¿…[¯ –P0-Eúµâ«yOþª›b¾Áûr·f0³uSJÀêøfo<Ñc9½qÓ|%úâŠÉ`Z`jàD¼«¦DñÁ=èZ<ß—•oûnÎÁ•®õ´™]l'®¼_Ò õ8+ÿP_›ø ð‡|÷:ÎKC(¾÷ßIMg$Ÿï¼+Ö¯çåïÀg’ö«¥ý½ SŸ&ÈÚn0³ÏÍlHLŸ6p³[€‹Îôá;Ö;|³&3³ßÌì6àNÜJDÌïNÈ%™»*í dy¿ÇÇÅòop¥í?¥¬á+Öëbcx+iÃÒq›ƒoðnéJråŠá‡„ò-i:`•Zöó80MÑ‘[Ò$±Mù¹ù¥pÍÞj¡ã®HZ‚Z’öÆ}J Ðpü÷î“p'ðp…/ø$©3; ׹%õ,³Ð€ût3³c±ëÑÀ¤uUˆ.¬€ÍÌì«x L;Çöð€¤]p¿¢•qçÑz÷û+•,d„sr¿hw¤¤¡¸ÒXiB©ýïkik&j,¸•xWZΪpΉe§§JZ ÷£:®¬Î`½F\—¤ 3{QÒ>Àƒ’¾À•ðn¸2Ú¸KÒ'ø5-YäÆ?LßÛ/ ë*q1îwH¡« ¼{ì"à}Ißâÿ3£ZàX“´pY||OœkfwF•€Û£ëo4®ÍShâà"I‡àæÔ²ŸCѺ@Ò¸5krÜ·µ¡Êi‹“Y䫌¤qDz1ÀÏÀ£xŸñÃf6¬Úò%I7Sà/ÞN¸¥ñÄøj{@?ŽøZ ø»™’ôGÔ-Ű:øÁÌþ+i6<¡äñÀ§fv‘¤«€çÍìä¾ßÀ¯6ÂG›\`fGHZ8ÐÌ« ó?Q¸)} p4Þ}õ–¤[ð—Ø¸¯Í¤ÀÍf6 °}/ü«öd\ún5[ÂÌ^•´þ": w2]8Ó̾‘ôî0ý(þ‘ò[”Ç•¦Mð®ÄÙÍìI7÷›ÙÙ…ý_‰¿€NÃ_ âþwã#}nÇ?ˆ¶z˜ÙÕ¾OÚ;¡„Oƒû–}SXÞ)–î³2¶l»>ø •ïÆcw•öß·~٠ݯ =ÖoÍ“¿–¯ïëþ¨°®0©™}]ÿžþô;ìÇUŸoÓ%-AUDÒÊÀòÀ?€GÌlhÓZL’F³ î´¹*®ßn˜(ÿ6Æõ›¨ñ§8,–•¸ W0³¡’VÂMç%+ÉøÈœ"kàÝ9kâ±±n~Šuï࣪*ñ°!îpü=°\Á”¾MÓÔøWýç”YÃÌìgIËDZM‚;#?ƒûæ`f7Ä×ÿFøè²× ǺV,Ÿ˜ÈÌ>–´Þ}Õø'®–ºÀ®ÅG€Ùï†XA¼‰w‹ŒÂΕpÿ¨§ñ¥¤… ëÌg–¥ë…™ýØLûÿ…¦uÁ6ùX 뿬cÝܧ­¡ûjµiœÒ”$I’$I‡$£“$I’$餔$I’$I‡$• $I’$I:$©%I’$IÒ!I%(I’$I’I*AI’$I’tHR J’$I’¤C’JP’$I’4È)Öo<ê¯ ©A‰{'à1LÉŽ;<©%IÒ`$M,iÓjË‘$Uäp<2xC™˜¡ÚB—Ñ ˜½ÚB´R J’d|è \]i…¤>’.kL£’thK -iÅHTœ$ BÒä’¶“´·¤ %õŒÄ¸3óHZOÒ"QwIÝ ÛÎ'iβö¦Žö6ÔµŽýŽÌõ+IÚ½°|)I»IZ3r™•–O*isIûHÚLÒä…uý%m-iI3ײ¿¹$-P¶lFIK—ɾ•¤¿Kš¶°|ÚkIÛJZ´Ú×m|I%(I’æbb<¿Xc˜OœÚRÌ,9ÁÏHÒ&‰„¨¯áyïºã¹âúãù⦧ƚrгÐÄ?€Í å©€+ð„¹»÷™2ή¶Ãï[$]ôöî”Óxÿßu–Å“#inàU`i`NàyI•þc37DBÕG«D;+Ç>æÅ?'iᨷ ž\ù*`njr¶Ì,§œrÊéÏ 8ظOy0y¬›ŠÈ½åÅð,ísàÕÇâ™Ð‡àÔËÛŒ'ýÏà¾þRüÛ½uÁ«^‡'5]8 X¥ÐÞŠÀ¥…ò¬xò×ÏBöƒâáü1ðc´OÔ½Xª°íZÀY1ß/ꮇ¿HîŒå›/Dûw³VûzåÔ"ÿ€jYw>ðeËþ&+ûókã ‡§rà=`ÝZÚ Y(¯‰'×íe޹0ð;нB;7ÇÊ;¯þ'¿Ä|縟—rÏø/Îå÷Õ íìÜó›FÝɪu­š:¥%(I’rfþìÌŒg…?§¼’¤u€+™Ù;ÀVÀHü yqüa^Î…ømüËòA3ûø®l,NÅf@Èqþ°-dëSh¯70[È3 ®=õfîÁ_ GFûëÆ¶³½ mõ‹íÀ_Tƒ¢î ÀñE|lçà6à¦:¾è“¶Ë‹ÀpIoJ:\Ò‚Mlï}3ûÀÌþª£þ£…ù%qÅçLIàÿ¡Iypåþà-I'JZ®°Ý"À½…òÀ\Ån»g p9°m,Úÿ&i*ü°¡¤ó%]¬û.ñ†™}×ò—¤eèRm’$i•\ffïHúð‰¤‰K+%í‚Y®Xz¸£Ìì÷:Ú,Kí•s Þ͵°M”Ku ïÊû­PÿZdms¤”$I%>-ÌŽ?ûSó ü/pTAj(ë‡oJìkf÷×Qÿ“ñh{:ü˸9)îzü«x‰Â²ð‘6I;BR'3w ß'i$îos þ˜²l“¯peø›ðÓY÷*1‹¤™ÃºÒ X ÷ jâŠÉfökQÆs,ðð„¤O©±t>¬<åõ!f6ºücÂÌÞ–ô&n‘]ïÆÌ¾–ô0ÀÌ./î»Úר¹H%¨£z5Ä\_úÝÍì‡jËT óÓÇïÔtE- Ü/i¤™ËÆ%ÉÂa 3{Ø îµ}p¿œibÛJÏ£òv~&)”§.Ì„+)• ”Èw+”è_Ïþ‡¯˜ÙQ-p¾“ÖÅFayïrÝï¸ ¸BÒ@àa3;÷º\ÒíÀ\¸ÿY‘ %= ,¼íÔ‹™Ý/éà¥h"ÜÙyWàIçâÝÀñ®¬ÿƦ‡à¬)Ḵ~»º8¸¢¨lá>@×Fwð¸²÷#î¸Ýö©¶SR•œÞ6N.[vJ-Ë6Œùë€%b~Eà‘˜îÁ}æ(Ûö¡BÒ´SŽuYüÁݺ›âêª_£œªúÿ¸·€,ˆûÌ\ \ëþtŒÆG• öˆrüa»5>Šd¢²v;ãñU&zûoźy_ðıìàÀ²6Áý)¦Ä}v^žŠuãŠÊÿpem*`ùX·*þ"Z ˜%–€wiM, ¼Üë¦Ä •ý—¾Å»»ã~Aÿ(ÖÉ©}Lq¯.†+>›Ó•­Ÿ·öÌ]X¶ð7\©Ÿ ˜1–Oÿ¥¾¸²*йŽ}/ ô®°|n|ÄÙ&…{XÀüÀÀ–ÀleÛôÁ}x6ú–w–.«Û#þSWØwܪ´MÔéZ8ƒª}½š2)¤C!i Üa¬¯yŸjjÌÿÓ–ýˆû<<'éc`73»=‚Ń+ =ð?Êø øsìc,°ã:‡~lfÃ&ð±. œnfƒPwS\Q[aBʘ´.$Ý+ñ‹óO{šûIôÅýt–ºÓàþ 'šÙ#’ÖÆ¿û;˜Ùû…v;ãÝ á Ë[À¿ÍìõX¿þ‚ènf+IÚøÂÌ®(´Ñ !¶>Bæ`3Û=ÖÏ€ÿ7ÂýŒ.0³Sbøïø‹ëW3Û$¢þž,<Ü ,lfû–gaÿ+ûáN×?™Ù^Õ¾fI’4ŽŽª•+8‹ãŽ Ëîú™Ù” CÌlÎh¯+nZ_ÅÌŽec…Ììåȳ >\x!ÜßàÉxpolˆQ<ÂÌ~‰ú=ð¾ÛA¸òv¢™}Rho+|Xå{ø ì(3]ǘÙÞ…º[ãCA-W‚¢ïz×ékà43JÒ® %èZ«Ý 4I’¤]Ðnœ›Æó!ŠOâf=â÷1Ü­¸ì‰¨[3â]å~73JX˜zÖ²ýšxŸòHüKyoIwâÃyÏÅÍÇêßËÎÀc4¼_®HÚV|ðnò/1PþÕº:þ%\‰{pEë |˜ñ’ú“$I’$퀎ìýÞ‡{\ü+…û–=\ÇöÓJºW,–6wú,r®Ø”øîƒP‰ûÌìL€ˆIñ73[3Ê¿Ã#cÝÂx¿íà‘o¾=®ðì ìbf÷Eýé7riƒˆa—€Áæ£}o‹w7$í—ýð`†I’$íšv©IÚwàxÀÌŽ¨Pí`IáJų¸´h,[w¬Ÿq„©q'ÐJVµ Ò»™¾«P.e-¼ P‰gñ!˜Ýp«Ôk…uCh„„Úx9†Cv n¬p¾—ÃQ†™Ùø$LZföZÓ[I’$iý´K%ÝRR>jîý<î´#>Be$@ÄDØòRûøÅÌn‰mÁMÝ\ÁÔPÆÖS.ñîtZdràk3%i8îÉÿy¬+Öòv3³Q±¬¶.ºoñQeË6@ö!¸ Æ ¨•$I’ÔB$ÝßÌ6¨¶,•védf_šÙ˜>ª¥NÉ/hܨÄc±¬¡þ@˜Ù[x(ó#R¿‰<ô“TJn7=ÃâîX/®Ä•¶w,È9wp^6ÖÏ‚wûUâAx«{ñ š³WšÙ’ÂSbÜŠû†nƒÇĺWÒòÀUÀ+¸›À"x`Áå¢ÝUð¤Ãçãn žf¶@CeKš—öê”$I#‘tþ_˜¸þÀ>·’ÞK¤ 43pnU~VÒãf¶GY{Óáý…ðÄ‹O™ÙFx$j€§ ÁE{áz?ă.ž‡G¯žÕÌö&Æ»…—2³á‘=þh<ßQÜ—mÕh’°b‚wú˜ÙqÑV?<0äff1âóŽÌñüss|á>.¯5³‘’>¦–ô®HC¯ÜG*AU%• $I*q™™½ i5<ÕÄ%±î6IO'‹ Û˜Ùïµ´5O310Ú|6–—F(þ^Ú6Þ#Ÿ›Ù©¥ëò³?Rn§¯cñ“ñû¹è³}–™½õwÄ…>[…¾Åý×Â-I;$RÄ ÂôõðD¤{Wà#‡o>+lrRü æ¾þ³9üC¢ä{RôÅíè~¹U'• $I*ñIa~jjrë•øx<Ú:#u[|-ŸffÇÖQÿÓ†5 ÀtÀ3ûl<¶ŸcŸO†yQY_šqI+CR'3î EY3»DÒ“x÷ìMÅúõµ9)_VÆ“ƒçœLªH*AI’T¢§ê3<g‘™ðÑ‚õbf?{JÚ Ïpä'+mßµŽ}ƒçå›´P.¦nùè$iF3û°B;åϸßð.® ù@Í;xwß03[½™ÏoÒºÙ(ú> ôÆ»m·Šu{·KZÏë8î‹¶vÚÝ;î;4yµ´£“¦¸$Iêã ‹¤Ý%M,i Ü/¢AHÚXÒ¬¸ÿÄÜ9ú—HÇò°MäÖëQKCððóDÖúRtrbTÙ¥x(‡%M*iÍXýï^›GûÝð ªkHš#Fý·ñof“´OÄÉšLÒZ’æ¨öEIZ”ÿÃó/>†'þÀÌÞÀ#ꟼ[u6Ží†à¾hE¶ŽåD(“…ñîÕb»ª}°™´%IRΫÀ—¥BD"_ +µ pžR¦Ômô;ã-gŸjòhw3û Öm;¯‡çÖûšxaöÿŒ¤q…äK<(éjœ°w ynÅ-FÏwšÙï’6Ã_B;ÛÆç Ûðn·c€É­&VÈ À÷…}ÿ¹ùŽvÆ­KCð$ÅI;ÅÌÆà¾kÏÖ²~ÞUV¾üGüþ+.{®¬üP âûbµ·#“q‚’$I’$é4¨;LÒ,’—t¶¤¾ Ù¦ZHZQÒöÕ–#I’$I’ÖMC}‚îºãææÖž ³>”5I’$I’¤Vêì‹á¬S_3ߘٯ’ú˜ÙZ|J3{7êO…+!ïÅðÂR;}€Ÿðìæý#á(’zã}ûïë×"K/`x 3î±ÿ³™á‰“FÿýD@g3Ë{šÙO’¦ˆùa™¦ YG‘$I’$I‡¢>KPO<„à^I·HZ÷¿x=Â××Å-xBO€å£Íu£¼*pOÌï‚gtºøY„&ØWR·Hªøp:ð~$²K’$I’¤Qçè°°¬,‡´_ÉÌ~)dÄnfsHÚ ˜ ˜#,0;—Kšš?˜Ù"’&Åc{˜ÏÌþt?°9pFâ<¬\çÿy1Ê7GùÁZ¶›xÕÌvY÷¦f}/ \)i&3û£Ú$IZ1”|f3{´Ú²$I’4'M‰tqa~eàŠ6n‰™ÏATâ3û­pkAéxÊZ%%ˆø=°¬\›dx‘ëÀM$m‰ëÇ_ƒÁ%Iâ, Pm!‹¤³$MÛ‚í_I\“v†¤å$í,inIsIš+–O¹ÃŠu׈üRyrI›IÚQÒL…åSÄž)$m!iIë·z«„GÒ‚4E ú¡0߇BùPn~Å»ÓJüZ˜]¡Ü•ºyè'iܯè^ «¤ùñ¼DOÕ²Ý3Y(÷Åc‰ Àµ©ÃÊäI’¤ý°.îCØRü èVíƒLšIGçâ~±'àþÛÄê¥ñØTE®ÄÓ¸ iQ¼·b1üûqIƒ£Þ <ñ5À‚xÏÄž‚,Jš Ø8’¤Ei®ˆÑoP“šˆ¦Ú )Þ,DðªGÃãà!<ˆÙ“ãáÜ<OÐxlÙôe·O’vMDE¾VÒ§ÑU=]Ùº!’Ö–ôJÔÙ¯°~IJú\Ò’Ž•Ô9ÖM!éEIHz]Òg’¶‘´X,ÿJÒÉe²üMÒ Q÷îˆ<]Iæ^’®‹6>—ôXø*žL‰§*"i½ˆ<}·¤$½¡?V’tnY›—ö'©«¤C%½ûxBRŸð…ðX´¿T|ÕŸTÖÖ³’¦Žù“cß·KúFÒ¬’ftƒ¤%½!iÛjßIý}€•Íìpˆ‹÷w`uàd3»<Ö™¤ÿáÎÕ%.Æ­G%fܤ†µq3ÞU vÈrC¡Î3Ô„óÿžqµoÌìíèBÛà||K’O„˜Ø˜!¬«C%+.E6³_€·$=ƒ+7¯›Ù[áH]ê‚úWÎ+l{xø>$é;à²RxIE[ài*.ÂÃkLƒ+L‡áŠÎ;eòŒ‰:óORŒ•dÀH3û=ö® ý·dAnÀ·Ú?€µ IZ‡ÎÚ¯+Ììù¨¿*nMº·ŒÄ_Š©U‡±üµ§¤S=ëKJ®pÅöz ég€ ó#ŠÆ óqEÿNà³Òý‘´,õ*A¿çÐBùb¹°|(µ8OšÙ¡eåKÊÊ4DX3û¸L–ïËe1³g ó?P¦ÅòÏð‡i’$ã2þÿ¼°ì“òJföu¡8Ï¢¤MqëÍxÓŒû36þ·Åm¿)+—êOûS,YXÿ0Q¹OÁ}ý.úHºد‚ŨÄW íBÄ®}7ßSS)žÓé£ý‹Êêäh¼êñ*0]Œþ@RÜÚwS¬ÿO¬«øÐ_˜ø˜ÙÈø0˜ÅÌn-5qëêâ|Ü28î‹”LZUUI+ËVXõ~ɲ”$I‹ò%þ•;=nÅ¿víÔÅžÀÿ™Ù anpÆù2†/›ÙÑõU +ÌAÀA’á]å·Çñ”¼([T¾J±¾ÑöIßâÝeŸUØýXÆ}–ŽÀ²R[}ø«âVÜÿ0¼ûqB"×¤Š˜Ù×’ŽÀ­•×â÷ðW…*Oâ×ùnIÃð‡boÇnÀ­’>À»–»á‰‚kÛçg’À•­«ª}: ÍåÝ\|›™Ë§fs°N’¤vÂ:r pT8/ˆws7”ï€5bÛ%ÇsÛrÎþNËÝ% ˆdAÒšáðÜ…šØd?Åï§À¦1ŶQb¯ƒ$-Ã’a\EåLà¤h£‡¤å%•F¿~l-iÎ*ÿ °D8‰OÍ_•®"â~LÇIê'©w ¡^¤ ç.i"¡|o‚¿ƒ¶+¬û÷i»ä»9´÷ãXÿ*îSvîOw°ilþb´W‰O€«¢«9™´*KP¤Óx«Úr$Ig|tËóÀkøÀƒcÝ(þÚMó:5ÝgÿÄMùÏãö(lûHÙ¶ÏáÅ%Þ%¾¸Íì1I›ûãa0~¤ö.¢~¸%hj<|ÇͬôÒÚ%ä88ÿ2¦¸±™}"i÷ýgàXÜVúº?ÿò¿ ˜,Žy‹X·°;îÈúo3{NÒþx|²ïñ¬³¿W8_%ÁQïqÜjõ&îï˜T‘ðË)ùn•¯û÷û)ñdÙúá¸Óùv?àݺÆ•£T~' Jëk’$I’Ô¤ñwæyMnì¯mo*¼ÄÌ®®ö±v$Z$i!`93;©É%I’$I’ÔB½>A¥àgP¦^¸Sf’$I’$I‹ÑÇè¾ÀTµOi¡œ%ÍÒ€ˆ’& §ÅR¹Oy9fŸÀûöÇYõg/koîBB×$I’$I’S§$ibà$Ü2spOŒŒ˜ xêt0DÒ õìë\|ø,’â΋ÿˆòüÀËQoàŽXÞøAÒñ¸rtD(_'⎃§ïKÚ¨Ú'2I’$i?Dê•9«-Gò)Ò¾dòÞ&P§±7þ|`f‹Ç4)ñ0™-€´8µž}³ÀƇ Ëu…$ÿÕÌæ1³M€-ñXBs˜ÙàØöì:†¾&I’$Éø2+5iSZ+sài9’FÒØ8A+ç{MBSËJêuÿ,Q4W¢n%è’Âü:xÈüõ%m‰+‡ËO’¤•!éÜRòÐh[’® «u’47%­!é’ÆñU•Ô7oî«Iš4Öu“´¡¤}$m-©˜„¸«¤µ$í馊m®'i’HP¼“¤iËÖO&i[IÒ°TSI=4V êÇÒ(ñ#УèãSN$‹û X¾y0O`¸4u+AÅ0û}ñD‰€iñ¸ §â“$i}¬‡'l „çìÚÔ†’¤'âIsç^*°”Ô xÏ•9žò<¡0x¤ò]ñT â÷(Ñcñ>¾/pž¤ƒcðü˜Wã=‹/Kš<ÖO‡n\½•9/›†&P´lÙx&æR’Â%ðÔÔÓÖƒÀ~À‘_åAà@¼»íkÆ`23;¶Ú'/IÚ#’ÎÀ£¯°,€çL:œØ%ºÁ‹Ûô.ÀÐcðœð…ýð#ñAŸàïöÂ?ˆîÖ1³Ý m>lmfFfîƒð¨»½ñ ŠkP“oëIIcñ¤«SKšÙ¾…¶^ÀÓR|-é4<`áºøGØÂ¸2uBïÏÀ±fvYµ¯ERu.後d¿‡kâ ÎÛf¶i¬[„x†1`0ž;ìòöö^1³m£î9À0IgRó±¥™]ëïÇïÓ ñ@¤÷™Ùö±ncü?4†(Aï“I:x]ˆ‡¿XÒïxØãñˆ¬õñ ®½î_(Œ'?l('àù±xôÙ~x¸ò]"Bg’$Mcü wc\Ù ¶ÅÈ#*l³þ<™ ²¼0ž*b/`#<ýÀPüy±8þŸ} Ž+`µØo‘y©ñÉ8 ÿØZOM°ðþE½°"žzbžªcƲ¶æ§ÆZ43°vlWÊFÿ2þÕ¿I¬PһńÌI‡äáÂü}Äàü~z¼´ÂÌž—ôkÌÿ!éàI7á þÝá>²`’ÎÃ{bJ½1sàƒ`ÜÈÓÓÄüBx’Õ÷Wûä´’Eþûè·\èX¼+ú$7²¶6³°¿ûq_ R¨ñgpÍúæBשñõGäùRÒ<¸ÃöÆøWÛmÀoÕ>™IÒŽ¸ÌÌ^*" ÆÑföy-õÇàÝÓóO›Ù³±|´$FÆ@‹R[‡˜Ù貺ØX9ºÕ^ŠíJ/‘òör|/Fý5ñgÍ­ø3îw¼;cÊÒk$ŽNeó%?ØQxBTàÏ®¬?»dÍl‹ü»žwîa\97|¤ó…vÏeÜtQ£ ó†$€'ê-ÊÓ =©›å3³×q夸ì üb6˜È™rh¡<вü8föÞÝF< ­ÐÎ÷x‚Ã$IZ†O*,û´Žú'âþ—½$]`fck©ÿeIªð¿è…Hm‰ã›˜œš®µ5ãþ’¶ÉÊÔXƒÖ ÆäQ`'IÇÅ}¼!0ü©Jö‹’JVÆÒv ›ÙK;ÔÉÌÆ6 ÞÞó!Ïey’&Ò¬ T%-Jå ó•™]íƒM’¤ÁŒmà2Ìì7à?À$-€wu?‚ûýŒå¯ŽËåùz~£0Ú%b„õж–ô#Þ]öU-íŸe#(ø1†ciçZ¶†gœ_£0â5I‘t!né\WBÀ‘ ×%}|‡ûôŒ¦—t7nÕYO¦ î:r·¤'ðn¯É€Á’fæ¯ÿ‰rNÄ}ß®ÃðÎTí“Óhî,òßàŽËåü<ží$IÒ†´î¿ðþÂW,À-H›IºŠÚ­I¯ IZxw‚.¾ÎN‘´5î´8𬙠—ô9°¤{bÝ+À¹Ññ)pX=â?„¿¬Ž–t\È¿0ð“™½@ÒQÙï™·bf_€÷RD7êìø½ó ð%ði úY÷[ë\af¯ÄvÃ%-,‰Ç!úØ¿d1•´H¸Ä‰„;ˆ™}÷ôàØîñh'}a›@³*Aföþ L’¤íò*þ@/ò(ß¼ LŽ+.ýñ/âýÍì©X·ðøH±c€ÏðáÅ#ÀöÂ?Â_ÌDö¡¸ãóø`ˆ×€-bÝøhuÿ3³%u¿Å• Y ò¿F!¤F¼ÐVÄG¬=Ž[­^§BW|Òq0³’£òS1•³Þ=Ö8¸ÖÌJ Ë;Ô8Ý—·k¸èÉ ë)+¿[Vþ ¸±°è’&Ñê²È'I’$IkGÒþøˆÅ±¸’tZI JÚ©U I'‡‡“wùºnÀöÀÜÀ=fvÇø¶?äŸØÆÌnäö]ñÑó÷›Ù­Õ>¦$I’¤cÑØˆÑ­I—HÚ¤Žõ³Hz­Úrø; BYb¯Xÿðvµ­…îü5®Ëø°æàA<nÕ´K$åM’$I: V‚"GÏô’æ“Ô½l]/Ió”g³•4©¤.’&’4—¤‰Ê¶éRV¿GY.’æ”4Y…zÝbýÜŠ| <¨cŸrù‚¾ÀT±¾O!¾’¦“4»¤:ÑEΗQ·\öÞ’:Iêu:WØ~€¤©êÙG<(Öíxï¥óÇ;W)O’¤îqÞû–µÑ½PîB>›NQž¬®ý‡%ªxŠåÞ1”ó-<:o±^§¸æs•Éò§ …c\¸~:¬ ß,’f(ã(ÃIÓHš8¦Nqô*ÔŸ³Òy–4•¤AÝøÏ¶ñSÄ}ÑRé’$I’Ö†™Õ;áN…/á_ìà16J]iûãÃŽßí Û=‹çõzx¹1c¬»øW¡®ð—áªQÞ0öóäôBÝëñÈÕoã±Â1ßÛíWážÅ½øŸ‰ij<üþƒx$ÛçâwÎZÎÁ\!ÇÃ…º³Öÿˆ§x5ÎÓ`ÒX׸¾ý(ëg`ú û9wæü0䜸 ¸W<žÇ»6Žzà£òŽ)´q>„ó¥8îoðt%g¼Ÿ€j9Îc“b¾Ôî¨(O‰‚è†G>}¯°Ý÷øH†wðPóà)>Ãd~ìË ™>Šcœw‚}½pŸ= Lõ׈u·/âNˆ'×ŵx Q±>Òçɸ/Èw%>jè>àkà?±|‘ãëåʆü'rÊ)§œj›€ÝãÙôBµeÉ©žkÕÀ útéEåñ»@¼gŒò‚øhŽ™¢ü,nÑèå c~CàµB›ËâÃY;áIè¾-)$xèüW€5£|}(“¶¿÷Q©íæÀ´—Ü[ï(àñZ¶Ÿè^(ï‹(•N‰yÿˆòñòž(Ê{àç¯e_W{ÊW…bÐ3ÊýB‘Y>ÊSÅùZ%Êá#`J×éœPºfò¦ÀZö½ žÛ<ñå øPäÒvwÇ|%%è¼By\©íå©CÑ(Ý—û–]¿3b¾>â¼(¯çkùBýñ‘ˆ½¢|4kfÁ(¯ |X¨?ya~²¥tßþ ¸ Úƶ6áI!'Žù%Ùª-SN9U{ŠgÝ(ücu¢jË“SÝS§èZX>¦ù)CR?<&Çq¥efV¶:wjý0–¿DM–ÛWYMbÕgq«¡MqÀs]f/a0m~I[àVÏËÚ½ÁÌ~¥i¬\Tïl`©RwSó¼dKI:!¢á.ÌWVí²¨k¸Å¦t¬ƒk¬fäÀÔ«œÍì—˜_ @ùHìï+<ÁåàBýÛ ×é9\á|·Pžµ–ý<Ì!i `%Ü’7 ºWÂ-gµqIa~ÜR·º¤-ñ c_ã÷Ò8D××`à¼8ž±¸µ¬x<ZÙðQ\!+Å zOÄûR¡¶¤†N¸¶ºwLU¨ÓaüZ˺ò@ˆ?E¿Šb §ÑDäXó”WÛ†ÏÆÔ¼DK>.ÓãV¡iðnŸb2»¿Œªjåòÿ€[qþâ°,iSàt\‘»ÏWÖ£¬ZÅcÅ#ßþRX÷{¬ŠÇÛó^¼^T(—GðþTpŸÁR®ˆ+=áJ_}JP1ÈW_¼ÛlžSjjàr*;zwÅ­‹ÇôcÙñTºÞÅc]¡ Ð%ü̞Ư×5¸eìþzý’Fbf›˜ÙéõTë†[Cj¢õ¶31îGV’œ ,Š¿ÄßW%æn?ÑÞx—ü™5/~¯/ŽlΆ[ó¯Å?`§i¨IËÓÅÌîÅ»„jãcüå² îô  €xÙ,DóÂ_û~x£`©x¿™N±†Ç]M!ì~më%),5%ùÆCûƒ›ô¿7³o+l¿:î/r}ëãqžßÆ»K”þ$å `vI“¬aKâÖ æàA`+ÜïësIâ ,{Q9"x%†ÓšÙ±õU4³Q’ÞÃïcñÔl¬̆ó;ÄÌ,³§.¬¯ïÞéPH:ÿ®¿Àï­cq?¯.f¶@Ù6Ç/™Ù5’fÅÍùðs{¿™m‹¿:I›maž+°ØÎ À øÐüEt>n¥í_ØvÜ7l$þ^Oxú7<¬Ä]ÑÞ2ÀÎf¶E”gNÆï5p«ìUx@Å>Ñþ·f6XÒx´ßGbÛÕ€ ÍlÇpÄ Ï}xðµ™­"iƒkZ¼KzOóÀyIÃÌ6,ÍK:øDÒÌf6 ¿G—Ã](fÄý ¯Œºgâ]÷ûGy¼ ~Ÿòû=©> É"?&¢¯^)éøô²øÃðFà`Içà#}¶Á†’QóÈ®ŸãÝû–?$éuà–è¾þ0~ÈÌ¹W#þÌKföxÙúÏñæ)’ÞÂen“ô-îÔ},e ] ¼ì!éÜʱýxœç3€çbÛ¡¸Óܨñؾü¼½&éaàš8?+3àªæàAü¥pF¡|ÞÙÐn¼ó]%‡gçž·&‘rŽNEº;ð_j"7•ñTÇÄyÛ‘q-q¯Eð³afv]3í·­2 ®ôo ¼‹ÿoÛâ=#*l3#5IIÀ•àµðó^R˜¶ÆýþJ]¢•>pÎÃォˆ0 föƒ¤=ñÎË€w9K2nŒÿ W@Š£%{ム‹óøÇצQ^ü?y8Þ…» 5]Õ³Æö%úPÓÜ9ÎÉx·í’–Ç?WÇ1ü·ÌWèrOÚ’VöíÙà÷ÂÌø3Â"…Ë›¸|Ázšû. ÖIC³ÈŸŠÃš¸…æ¥xŽ’´óe]¼Ëá¬Â‹ò|Æýš™¿¾üÿ…;Ù^[¶|-ü¡¹*®½†[ŒÀG•g”>˜ÍJ$^,;†ß%-Ç0ÐÙÌžŠþÙÍð‡á^fv[-§á <2èj¸%f㱸ÿ¢é"i£™ ‹äøPþÝqÇðŸjÙ× ø¨ª7–•Á».wŽóþ)°PÁ?æV\©+ñ ã&¿ü èׯsø çÖ‚üû3®%ðcà´BùX\A.ïáa-Û·(üŽâ*ÇÍ’ašÙe’¾Šsú°ŽÕ¤]Šû¹—qýªÞÁï·#q…v´yZ„•ðô +…¬sÅuÄÌ‘´nQ˜œÜ?¯ä_E¸CmfŸ7`Û1¸õm63{šÌÛ¥”¿×³íÀ#fö ~ï‚+­c+l{›™ýÙM^O"îUðû¡˜KìùØ®¶öëã%˱¤ðD™?à]÷á Ýœøó+i#Hš€³ðŒy–÷w×`Þ(OŽ?×?®£É$­“j{fç”SN­k»‡ÿ^¶l0CÙ2úÇüuÀ1?%®´~‰¬ìËûcêÙ÷<øGÀO¸…nµX¾ 1J±P÷là°²ewàÝl¥òZÀó1¿p_-ûݸ¥lÙ#Àº…ò¦Ô„èÇ?qaý“¸ìî²iÁj_ÓœÆû?°>£4rx\_=ÊSàŸkãx¥º‹ÚZø¸ÚÇ”S婹³È'IÒ>ÛÀeÁ̾v’´ nɽCÒ¸³»$u6³1µlû:°Qt‹î'A<ö]É™¿\¦Œ;°¡aþ#`æ2¿Àb;åÏÃß×WljþJqÿCͬ¶.õ¤í0WÄï–ôn%þþÍz9"åIwáþAGPpëHÚí&mF’$­ƒV<#Þ<·" Ç_*Ãñ¡+…¢´C„gè„w‹–ºŒ?JZAÒÀ:v?Ø2¢ƒÏ‹[JÜ+-GÆpå)ûÔþ‚’–Çnðîûm%M!iA¼k·.ÎöŠáÐÝ#ýåÑå“Ö™ý†+>áÁõp„gqÅøhBá1é±1pW!š~qäÛ¸¯YÒ É?g’$弊wey”¿:2?Bߛė2îX½Þeôü€Èï·°%îÓV>rjYàŸx€Ô·qÇcÌìmIÿëz†òò.ã†e÷S›wõ*j´1RÒŠ¸Oسx÷ÆÅx×Ã’Nþƒû¯mœ…wu¼ˆ[2ö3:ÎÉŸ%3{ZÒFøË± ô1Æ?&XÒ 0³ŸwXü‹…ùGËê~_kðp(ÏÖSNZ™E>I’$I’I“»Ã$-,iŸ˜ï$éœòDªIýHú»¤ec~qI{T[¦ȼ]ŒzkHÝ’oHÝf”ofIʧDWK’$I›$»W›—æð š X»ÐÞN¸);?sÇ|ojbS´fV*È\“Ó|qJÆí›Ÿ¦©L’$©6Û§"Ô|4X ’4™¤A’GER/I%M"iÎò )©‹¤9bêRaÛN’zJšGR§X>‰¤ykq²œHÒÜ’zR!×’¦,[Þ=Úé2÷¬°mIî%¹ ëúÇv]+l×KÒlÅœ4ÁCDÐF9}b¾_¥úq^fgOE÷ºŽu@œ³IÊ–÷(;ÖJéCj“¹Ò~çeÒZÖ—äî_Ëú)%Í_~<’&Ž{ _-mÎQ‹5r3<›}ñX»Ä±NR¡­ÉJÇõSJ’¤ÚlIoZÒD¤MJ:õ 0¯¤ÌlÏFìï-<ì긳`gIK›Ù÷’fÁ_þà–¤)%­m5Q6ßÅ£<¯„{ç-é<Áçp`šhëÃy/Ü9óM<‰Ý fvR-Ç·×ä}<éæÀváõjÈ3>dvNIë›Ù£±í*xÚñ‘'ßëÄ ó*ÔxIk™ÙÓ±í.¸£é«¸Eå·:î™é»¢.Àãeë—ÇR?¦t››Ù¡ô]ŽGä}O²º™½i Î^æ’t©™ímÎûü˜wŽ-ò)ˆï=<]BiÈðØÇšföl´µ7µzH\ŸQxüšspŸ'I’4;‘®e <ºùcMl.†K&/ÌwÇ#ø.åÍðtà/;&«¥Ïð¨¾%‡ì»ÚíQ¨»;pk¡ü%pzÌwÅ–'‰`ex÷£b~q\a›¢$?n˜³‚Lýð X Ú~Ø2Êçá/â^QÞx Ðî÷Àš…özä è^(¿‹žWXf‹uñ—ì.QÞÏT’ÏðDàÊÇÀà(‡¿œKçôXà^Ë9q…¡k”/Ç#ôNåý€Ûc~@Èe\»5¢|#ž–ÜÊyž“®$Ó/À¬1>ºt¬ÁòðÐø¿3Ey6|ÄÐÎÕì•SN9uÜ Ï40x¿Ú²´—©“¤i$-ÓüµèJ£$í-éìxAuÁ¿ÒÃåW§?+ü—aQIÇKº·z”ï㚨;:^`wYM˜û?ÛÂ}”ÞV–´%nÅú‚Ê&ÄepkÅl’¶À£Â~Ÿ¥o±š”Åý,|ffw–*šgaÏx}y¸ò73žãk9à3Û¼M™¥¤Òy‹º£pëDI†ñÄ®¥szQ=íô’ô?Içãùß&™JÜlfÃ+ë²xº”wBŽw)&ZÆ`ÜBFÈvAaÝbñ;]œóÍ©ÉI…õä8VÌlŒy"ÝEð·Äò¯qÅgpaŸ—ƺ±ÔŸKí¦:Žõ93û ÚÚ€ë“4IKF –Æl»E ±o)Ùv|QIÒZÙÿž:R{$M¤ žÿd—(¿Nå,á÷ã9vnÄ­3àÝ/á×Âü!’ÖÃãr„[Œf¥&ÑbmÛ–—K~7}£Ý¢sñµTÎßÓïÆš¾°ìyÜúSbxa~ta?½q‹A%úà]NÀŸ1JFàV^¶«­JÇ^”¡;ãvKÕÕE5-óäH¼ëq$þe1IöÓ³‚Œ¿R;åÇXœï‹Ñ+žóWRbÕÚÎkŸ ˦Ô9Ž£¶}6åœÖy^“ñbzü#à˜Fl;?~϶T‚Û%ðgÁýMm(Iš›ðÃ\=Šcpw‰‹«-W[§‹™Ý‹'£¬Høœ,ŠwAüŽ¿Ó¶€,«×™Ùµ±ßMhë`>3;¶uûà‰_ë{i–SòKéU°•x÷7¹0ŽgÜêòÞ¶Ÿ¤Næ~=ñü½ Þs ¯âï{¢¼Lu—ÀsÚœ2Íȸ)êâàÀRʃ¸æÇ3Ì×Vj‚á-\vÎ{盫t^—À»ËÏé¬eç{IàŽihì³”\w¡FœÏÒ9=XR73)ÁýÚ=’ÎÀ¯Ñúøà&¼«õßøÆB¸¿Üxwå§À†föQ8™‰[ô:áJËépå§_ø€ýlfËVØÿÞÀžø½ù-õ¹;ÞMør `YIÿÀ»Rÿ‡-–H$Šçº(ÚÙïzß÷©;¸¸YÈ|ð/3«ëƒ!IÂÔ fšRJPiˆcôø‹ûDI7áî–ÿp€¤Wñ/ú›ÐÖ¥Àî’.Á}QzàÊÁYföV±¢™½,én<¿Ñi¸EiA`ˆ™Ý\×NÌì%I÷Ŷ§â¾/3šÙ ÀÉÀ³’†áޏ‡'™ÙÏ’»Ü.”t ÞוÆqðP¼x~Å•‚Ú"`¾ §ñaÀ®4<»ñ#¸…îBIWãCÏë-u,pœ¤±qþ·+œ·w£»$ˆûÛ,¼kf×à/ÌkCùx W¶®5³7ã|_#éÜ¢0+5ÙãNŠ‘…}ðQã™=)éEà^y^ p߯ŽYtü£dc¼[y$Þ5½-°.~Ϭ‹wÅ.€we¤Æòvþ?„?c®Ç#=‡_Û-cû¿œÏpn?÷Ñ{'¬—]ñÁWâ÷Êÿð/a€¹€½ðð %…º´ßÓ•d‹ô×ãϱ{ð“ÅüêÀÓ¸23ÿ?bÜQ´ÓS3ˆ¡/°5ð¸E½þ?_ÿþm˸é;’¤1¬ûF–XNuäáKF½J™Yô“ï…?$.nÃ_ˆà]L—ÆüXüUÛ‹õDbˆrð(n‘uÂ}J¹V6,Ô=qCù߀•x¡of¿KZÏ¿.îtü<>©[âŠÈŠø÷M¼ÛàvjòòŸX(oŠ¡®Ç{È0TÒøËVà83»²pNã_ ëà¡Ùï Æ‚1„š‡üoŒûЈm½&iq`M\±º;ÖWº–ïJZ;Îíäø×öº…ózS´Qâc< Añ>(É|mÈüI-ûºFÒ¯¸5àCü…ºFaý?"ÅÀrÔ¤Hx,Ö=(i%üE5/nMú&6ÝW×ÁïÁ…ÌÃÛcf—Hú¿OßÃûÏW*ˆu5/Ê©¹‡‰óyz¡¼^È7³Ï 2üg¡/ßöT3{¿Çõ÷8¶’UJÇ4ºÔ~C"|jf§dÜÿ@˜ÿ˜»WÞR JšÊÆŒûáùî_ùTãšK Óf´yÂZ2{(CÝñî·áfV_²Ç¤$ͼ¾\«àJßlfömµe›Ç~7p½™]TX6*Žÿ£( ÿ0Ú·ÝŒ€œÿ0z ¬ÙoÌl+I›Û˜Ùêuìƒh{\1ÞÕ̆I:ifê¾í=QX6 ˜Öjò•übfJºx"¬µåû½xÒÌΊr7ÜêÓ£4À!m 5³£%ý YŠô^²Æ>ˆû˜ýI]Ç›$õ!i2ü£­h ú8Ą́¶|m™Œ:Ùöé \"i:üOñ î·‘4µ{Â_ë`“Ž [ײñw pФ™p%hgà ¼i3û´–6ê|î˜ÙMÀMòÀ¬çGàÖ%«eÛrYGà>%ëajºê>¦f`¥vŠÝÒ£ñÿÔ$Ô8Æ÷ÇC„T:'Ã%} ü×"¶V’4«á yQ ê‚÷–¤Ôš#mFREÌìW3[È̦2³iÍlëZœ“ñÀÌŽ4³iâ¼.lf9b¨€¤¥ä9îºQ£ü!"..4cDÚ^ ºaÁ¿fIZFÒlÚ]ÒêaUQ´]êŽþX^ž¯°®´2C€#‚úÚxWu‰ó€Í%m²Í&iP¡ýUCÞ©CÑ{Ø%ÚÚˆº€+§Iš+"›Ï£$i ã#nÁ•óÒn•e9HÆT‚’$)çUÆõ¿÷ß+F5Ÿ8÷åº ÷+Å‚Údz>¢ïD—ÁÌžÄCaìœTy÷ì†+2Oà PéK÷ÂXv$°w,{†B(Š`¼+í)<æÓÿðÁ˜Ù븟Ú.!Û¸ß!ç0Ü{ÛX¶®D=‰;è‰[“Àu)Û÷‘xàÖ ãÜœOÍË+IÆ›°F—b¡¾Ã-›cq×U«-c[&}‚’$I’¤•"iI<®Û\É^qxžQàv3[·Úr¶UêµIšYÒáÕ´1HšJÒIMo©bÛ«JÚ¼–u‹IjLnµÚöu\øüT I‹„§Làýn.iÍj{’$I) ?ÌÌŽŠeŸâÁ„VTYâî¤á4äÄuÇGTI‹Jzd<6é†ç¸j  vÿ€ÞŒ­z|ŽñXI{”-ÞeR"ißCøïŽÜÏj‹ªHjº+’$I:kû‚ÿ ›ð>DþÆ F›Œ Q‚Þv*.ëÐü1l¯V$uŠºóHêZ¶®_,Ÿ¸ly/I%MN…ÅÑ ýðìò}"Óxi›I%Í[ÁZòD­T¯g´Ý#ÿ 0œçŽx'•Ö ,“©ãAÓÓ§p̳ÅðâJç«þŸ<Žq’²õ•ÎIi]8Ÿ“TX7c\¯É+¬ëΨï…èžsð”¤.åç§tnc¾{œ«Nq¾zUh·KìwΨ§²ë[Šu6‘3®°íqº•-ïmõŒýv®pŽæ‹u N™$I2Aˆü`™ÙñÅÅD ÑP„–£ñ¹<“d­]’ÈX‹›äÅÑÝ‹;®TËv àÑf_Æ•‚!…u'ãN…âÃX×-¬ûwœ|7ò&þrìŽ;2ŽÀ!Ÿ¡&”þ0< ùP<ïO)³üÀ…¶‡âÎoàïSÖï‹+N÷ãñv/¬[$øPÓÀÙµûÖÀ½1ß¿aÆ:~ç®S…íÖ‹}|Çw\,ÿwÖ|½0õ)lw(n¥)ɽ],ïˆÅ>‡ï©ðáô¯âΦoáñ†Êe×adÈt€ð…²zC¥cþ <@Ü‹¸C韙ßcýŠ!ï3xbÒ{p‹Ï;¸“ë3ÀcQ÷à˜>òès<~Ì—ÅûÑrlÓ[±ÿ±nù¨ÿTlûJµ³ç”SN9Õ5]+,{¨^\6Qµem«SC.BQ  ê:ùñòŠG‰--+½ŒVõä…ò@ß(‚2)9mß…çÞÏÚþzÙ¾úê f½k”+)AWêßóË…‚Ò/ÊýC!™ïVûX;Öõ 9ÇG Ú+ÊÝBY¹–mÏö/[öeq_¡ðíókÅ ¿g”gÀó-M ,rv*l[R¯Ž/,߸§™>)”¢½ôŽòNÀã…óñ-°~…{c]à‘²v‹JÐæ±Ÿ^…òç@÷(ÿŠ·r> ü=Ê7à&åqÎCNãýPžØ´Úrä”SGâcz¡jËÑ^¦ñu¦ÊÁi’VÔÕ"±`sÓÄËóø!+7Yž3³»ña°Å>Í+,®6ðµ7ïÝ:¢Â^„G¬¯ŽúŶŸ-´½n‰XMÒ–ø°Ø¯qç³9ãE[J‰ñC¼TLJËcÛQ¸jÖñÜþŠÂüóer¿ ¬r/‡+•‹àé*úgJ A/l÷u8o…+®K§Luq›E:‹²ó¼ð½ò²îúX¸Æj’§^[ç.Ô¹,Ú‹?,Jû}ØQÒÞ’fµÚÓ6$uÓ?ï!º1/kL£›çЖZÒŠ‘˜5IÚ:v‡%Mg¼” 3†++Ãq‹Å'‘£«œÞÀ¯e£|]y\€ž…r1ãòhêN.zHê|ÈàóxÂÎÚ(¶ý5hûÆ~àŠÔÔ¸âñç£< ôøfœŸcŸíûâÝ”E¹/†™Gì]0Îï©Àgän¢8Gýb»i¢½Ã›0Ê |»ÚÎsïFœ»}(Ü;qýĸ÷ÎðZÎÓ¡xvïÅ€—$ÝÞß®dü˜ÿ/6†i¨‰…ÒÌ‚[µ“¤­£¦7‘”ïž™½mfû›Ù@IŸJº®’S}Ô]LÒC’æÀó«M$iHL³W¨?XÒK’¾‘ô¡¤}âu:0l÷bÔ=$,w×Iú*F‡ž¹ÜJí­(éÒByÖPp? Ù’47ž½~•hÿž¨{©¤¥ Û®%©”7¬_Ô]OÒ«’îŒå›Hz!Ú¿[ÒøZt“¤9HKP31^_Â’V–ÀKûáCÄ.¯gfßI:¸MÒ‘ø×ùBfv0Þeõ’މvöî4³7 ÂûÀÑfÉwè%à I§â>C â¾ ãËÀ®’ÎnÁ_ÆË'šÙû’®®ŠãZ ~܈ýÔÇ«À¿%}¼af÷ÖSÿ `ˆ¤Óq¥´þ‚?ïÆ[1ÎG/Ü9¸ÔEyp®¤)â¼ÎÌdf É;öÐEÒѸóñÆ@ƒº—ÌìõHbygÄp2`VóáŸo%|ff”m~&𪤃qåïßÀÅV9GÕ8Äýö.ž-~üžü°ù.[»b¼»t0~ŽÎÇ}³6*V’´õyc3{'ºUßÁ»aÜÓ%.įÛõ¸5r&3ûZÒ¿ð +Ró€€GÞàl![ŸB{½ÙBžIð gSc‘š¿¯ŽŽãÙ¢ÐþlŒ͹5á@ºàƒÖVÆHZw¼_#Žs'<ÇÙü üxH’æ »Ãš‘†(AŸà])࣒þ†‡ëÞÏ<Ùá_0³$=‡¿'ÂGä`f?JZ[¿îœ|^aÓ“pg×ᣓJÊÕ⸿NÜ’µ=ðÑÖcÀVøÈ'pÜc mƸŠËSÔ„ÓrýX©?ƒ#–ïŽàz˜ö¦2¯P“Ûå7 üþ¨£Ý1ø‡Ê¡¼¾ZØvl…mo6³Ç û­KæÕñüeųb»?€1ð;Ô̾‹6v.Æ»`§îÃc‘½Ý²—#Iþ$• f$Óf$I2’în5³s¢,\‰žWn¿ÄGxefg¶ë|`fÝëh{>Ü?k0>Ðb_3»?¢‚`fKê^|hfG–Ý \XRæ%­m,ŽÏ+›Ùšö»c¬Û¤°ì)à𜤭-ÌlÕè¢û è\²òHzÿp,Ï«öo3{•$™Hlcf¯T[–ö@:†&IR‰ óÓÇïÔtE- Ü/i¤™ËÆ%©–A„²°AX•ö.Å­*c©ü<*oç7Æõ œº0ÿ0s-Ç3–¿FÁ¸>hý+lWÜÿ0<¾ÔQ$IõHKP3’ùF’$©Ä’ §÷ã€k‹á0Ì#Õ.ìWHóò=îܾUD垨Ø`Dkÿ{8Yw­K¥0 ŸsKZ>œ¬kãe<$Æ”’á]r%îÆ³ÿÃõ§ŠîÕRû ÅèÈ’ßÏ`[I“G7ëöõœ“3†swwI$ýCõôÑ%I3“JP3’JP’$•8 wž·¾””Qx¤wÌì#ÜÇjIË›ÙÀ¦¸ßÜÙ@¥¤¿+à¾{¯ãJÔÆÑÖkxƒÿΊºïàÖ"'ãþkOáþh/E¿Gû³ãñÅæíîÃ}¤f0ÇQ¸ÝÓÀ?ñÁ¥n­ÑÀ£E‹Vø&m†;v¿‰fÛÒ§ IÚ,é”$É8„OеfvIµeI’d\$½lV ƒ’4´%I’$IÛ!»Ãš‘tŒN’¤œýðÄÆI’$íšT‚’$‡ðÏI’¤u’– f$»Ã’$I’¤íJP3’JP’$I’$’T‚’$i3Hº0òݵDÛÝ$]#)Ý’ÖLZ‚š‘T‚’$iKlÀ¸£›“Îx.½|.&­™T‚š‘ü³'Iò'’f4¤lz®°þ_’Þ‘ô©¤«$MË{FÝuâ÷3I–µ½µ¤—cÝm’f¨E†~’n–ô•¤Ï%=ËÏzwÅ>V•´°¤›$í)i¨¤%­%锲6Ÿ–4mÌO$騨ÿ•¤G%u®êÏGû JÚDÒQ…v:ź¾Q>[Òö’î‘ô­¤i$Í"éIŸHzMÒfÕ¾®I’T&;I’ùä\â<"ç–¤M€=U¢ÞxVõup+Ê `]<Šô”À³’î1³%­‡Gk^øØ¸X¬‚ ÿÂ#6ÏŠç÷Z4–ïŠG˜^$= Ïa¶ðž¾SÈ0SY›ƒ€n1|”WÀ£O/„çÛ øX&Ú ,ÌP¡­Ò³sV<ìÆÀû±ìIàÜj5;ð ¤wÍìÅj^ؤݖ f$-AI’ü‰™5³ÍìG`\™Ø"Vo œifï˜Ù<}ÄÚ’zš8ÔÌ~2³¡À¸bžvã|\©™¸Ï6 ‚c€ÀÜÀX3{:d?üGšÙï¥ìîxZÃÌì3û‰:ˆ<_;{šÙ§æ¼yÑFEµß£ý†¾h.1³!fö ®ý ÜÇ9¸WÜ’¤9H%¨IKP’$AÒÆÀŽÀ¡ð€çû3——™}"iž}ý«Xüu¡™@˜Ÿ÷·Y©°þq {…Ý L\ LÝ`Õ¡”|afcxh“Å>?j`ý†ðIa~z`*ࢲ:o6ãþ’$i&R J’d$-œ 6³¯ «>¢ÐÍ$iF¼‹és¼;¬.†÷›Ù©õíß̆ãV¦Gv÷czï¶*n•+G#€I rö¢FÙú·ÎÌ ¼P¶]ɲԕ«Ð8má µlW:ÎïÌlõ¦_‰$©HZ‚š‘ìK’äOÂyøVÜg„¤ Ì»Kš_R?<£ûuÑ TgHZNÒÄွc-2¬#iΪ>à—º¹>¶ˆõ=kÙ×+Àâ’•4p ¡¨„5élà4I³KšDÒ`IG—Ø·À6’†³ô`yIƒ$õ¯ç8ïºH:\RŸ˜V–´@õ®jÒÎH%¨IKP’$E¦Þ¶‰ Ü*²Š™Ý.iJà\ 7n™ùwÔùx”q­"oŸ˜Ù=’vÁ­IßÔ"Ô¸6n¹ùgÁ©x`à,\!ùx®¸±™ •´/p ðî¤<3ð{TùOÈ}5ÐWšžˆu›;áŽÎ{™ÙI‡ã#ǾþÌ‚;nÛ~UØ÷HI+Ä>ŸÂ-d¯WûÂ&IòWÔpß¿$I’$Iª‰¤÷•ÍlXµeidwX’$I’´²;¬I%(I’$I’I*AI’$IÒvHKP3’JP’$I’´R jFR J’$I’¤C’JP’$I’´ÒÔŒ¤”$I’$m‡T‚š‘T‚’¤‘ž‰´I’$IR J’v‚¤î’¶ôžÃjr3{¡©í&IÒªHKP3’JP’´q"GÖ%xÞ«³…ð”ÿª¶l-t¼«V[†$™Hš¬ÒbÊ” I}«-k[%• $iƒHšRÒ¾’>Ä3¬o ôzâYÒ×4³QMØEkæI=ª-D’LzI:®® ’6V®¶ m•L š$m„Ȫ¾°°4ž¬´\ø ØÌÌ>ª¶¼-t¦V`I„"$À$m \ ¼efßU[ȶJ*AIÒJ‘4 °®üÌŒ[~†ãÖžîeÕÿÞö«¶Ü-Ìßð—ÀÚÕ$I&·âÝÝÿTòZ8\WmÛ22K'ó$iíHê Ì̬ ì«&ŠßŸ€9Íì‹jËÚ‚ç kgwàW`Q3{«Úr%IK"©;ðþ_Ž/Æâÿƒ_€åÍì¥jËÙVIÇè$i˜Ùà`~ü«ðV k¬þ Ø =+@Á’Àè˜ï¬Ym’¤¥1³ß€—£8 þÞ.Y‚ÇÖ% • $iHš¸7ƒ/‚v¿ O0³‡ª-ã`=ü%01Þ5–$ëñ¨ùø1ànËîœ&‘JP’´r$-í½,mfsPóxhµeœ@¬t.”ç•Ô³ÚB%Éàn¼ ¬È/ÀÕ¬­“JP’´RäìÜìnfû˜Y©;hzÜ?f}3Ûè´bhüTe‹W[¶$iiÂ÷í·²Å÷W[¶¶N*AIÒ ‰î¯»pëÇ¢fvka]_¼;lm3û¶Ú²N Vã¯_½ð¡òIÒ¸‹q#E¿ff?W[¨¶N*AIÒÊ(t½EM÷W‘Ù€›ÙSÕ–uò7jC–”!‘ÎÑIÇá ¤ôü\[mÚ9D>IZ ’üø'°cÑúSVo3û¼ÚòNÀóR>4~"<.RiˆðÒföjµåL’–DR/à > bQ3{³ÚrµuÒ”$­€B÷×zÀ"µ)@I –Ä­?¿·ß‡à>‘Ö ¤]_oDqD*@ÍC*AIRe$-ƒw½ ,Ó^ó~5õð¡ñ·ã1’Àó%ý ÿ*Þ¤Ú&ÉâÜ/èöj Ò^H%(IªDŒþ:溛™ý«0ú+©a àj`ËâH83;ؘGRŸj ™$€»q_¸›ª-H{!s‡%Iˆî¯Ë¾x÷WZ*CãŸÀ}¤þ ÀÌΔ4*CµåM’fð!Ђ£NÒ”$˜ìþ/FóWÈð¯a/¸EèÉj š$-MD‡Þ7Ri$Í@ŽK’ DŒþÚØØÞ̲_¿HúX¨äJK’¤…Éî°$™º¿ú ›ÙÇÕ–)I’¤£“ÝaIÒº¿Þ–M(I’¤u– $i! Ý_{;d÷W³1ŽOP’$IcIKP’´’¦À‡³®þJ(I’ª!96•T¯ñCRwI"þV*AIÒÌD÷×KÀkÀrÙý•$ €¤‹Â?°tÂãmMÜ€º“WTIÎ J*AIÒLÄ—Öðx5»˜Ù¾ü0I’R“8i¤”$Í@¡ûk-¼ûëŽjË”$Ió#éIëIz^Ò’N([¿ž¤ç$}.é~IcùÀ¤ÀÝ’†HZ¥BÛ›K:^Ò)’>}Í!iIŸHz_ÒZ…ú}%]ë†JÚ/|ÿŒH/éCI/ë—íëIóÊ›J:¾–cî-鬨ÿ{’þ'©sµ¯EsJP’4IË⣿^#GMÒ1:©&ƒ€­€ÕEM$­ iià `{`ZàJàVI]]ñ$Àë‹Th{ `7à~`f੘Ÿ ˜hq¡¤Ò»û<ÞÀg— <§Þße€¥€Ëö5ÏÉWbr`ÆZŽùü77°°°sµ/DsJP’4’B÷×õÀÎÑýõGµåJ’¤Å9Ò̾5³Op%eÁX¾pð®=„wÍcf£¢ÎH3û½R˜à3»3ê_ Ljf¿™Ùõ@o`ZI˜Ùp3{8Ø:ÚÙ8ÓÌ>‰Ó‡4æ@%M…[¸O•±¸r·Aµ/BsC䓤D÷×å@O<øá'Õ–)I’¦!é|j,&Ç™ÙQµTýº0?‚‹ÊôÀ|À…õ¯3~ïÚò¶(û¸ú-ö×7dÓî¼ôùi€âs©±Ï¨é±¸…«ÈûÎ_àí¢éÌì×Fîw‚JP’Œ'ÑýuULÿIëO’´ÌlG`Ç&4ñð‰™ý·–õc®Í$îgÀ`&`h,›#–|ʸÝ[3•m?÷Q*ÑŸÊ|€ë [˜Ù÷õœ¿/ñ¨øm†ìK’RÖýµ“™í— P’$Îv—´ZÄÚ™VÒö’ºÅúO-$Í)©gSvÝeWÇIš\Ò k­¶,I’´mÒ'(Ij!âmüØø»™ÝUm™’$I’æ#• $©@t]ÂX8­I’$ívѧ—$͉¤åðà‡C€åSju¤OP’$ÍBZ‚’$ˆ(¬Ý_I’$‚T‚’„ìþJ’$éˆdwXÒá)t½Lv%I’tÒ”tX¢ûë?ÀîÀvfvwµeJ’$I&©%ISâÝ_ÝÉF:F'IÒ,dwXÒáˆî¯—€RJ’ê"éiI³Æü¡’vo}ô•4õ:ž£%íÐÀº7IZ¦ugŽìñM‘mrIWIzMÒÿ5¡ÿIÚµyÏ\ó"éqI3×U'-AI‡!»¿’¤Õ20QÌOÕBûØXØzÏÔÀ ¬{/ðEëÞl<ßÙvzË?7¡€Ÿšt–ZžYñÔ µ’JPÒ!(ëþZÈÌ>kb“I’4ˆ¾¾(žGk 𰙽׈vfÃ3Ÿÿ ¾4³ÛËê̬Œî2³ï$MÌ ´ž“ë5` ™=Û z™ÙãQ^øÑ̆Ey `A\a¹#˜"i¾ØW'`àŽ rÏÌ`f÷U8¬weDÒ@ü¥=X ø¸ô±&i‘8öå$M ¼Zmi`ð!p·™åËïâJæü¸ò´4ð°,ð˜¤ßåq…áÛ8¶Ÿ ²+ÎõœÀ¥s |üuúãìßÖˆóqCéE€%ðdﳚÙu\ëÁÀ\±Ï»#‘+’fŒs3¸ÏÌ>/lÓXÏÕvw…6'VŽóø€™}ÝaI»§Ðýõ>ú+ $™°,  L Ì<.i¥F´³!p>p0p¬¤cK+%m< Ì,¼JQO`F` `q\aèÜ.©d 8 ¸9,ÆÄ~fŒvÁóN ì<)©d¹Ú¸8˜èSXÒjÀ]Ôn59 X(æ7ýž N•th¬› ˜˜7Ž¡´pLìwOÆUÂŽ®Žå3ŹŸ2Ú^<ÎËÀ&xxÕ€W$õ‰¶;ãÊÄÑ@oÜ’¶i´½klG,¿ÿМ#ÎÑÍ…s°!nñšØOêzT¥“!©³¤;CöÞx¢ÙÍbݲ¸üq}_‘4¬ë <¬2\׸Ôíbq]—43Ë)§v9á_fá_n«U[žœšíº~ˆUW]–œ} 7Ç¿îKåo¹cþlàÐZ¶ÛÏÚÞ%Ê ߯ü$À÷À<…ú‡çÆüÀeeí½,ÊÀÇÀ“¸µ§0<”Ž©q‹Çl±ðªÝ¢|:naQ¡ÝK€S“}}–:ÎÅKÀê1ž¥½S”—>)Ô}X¤P^+ÚïRí`•(?œS¶¿ ÿÔ!Ï•Àî1¿#9¿K…zçÿùµã|MåIQÀTQ¬UØö|à±Zö¿n¥«´Ï§= åÃ{bþ_¥ù(/‰¢X8[Ö¯ <—ÝaI»¤Ðý51>ú+­?IR%$uÃ’Uq…c"à÷F6÷¬™ýó“Eûs=€=ÂšÓ ÿâ¯Ë‘øA¼k¥/ðþ²^)~Ÿ6³ß£›ìS3 `f&én\Y*ñ¸Å›µÀ¶x·Ì²æÝG åi‹î¬8¾ºœ¹—Ÿ3ÃjÓ W@æJ]oÖsmfŽÄ­c]Éðî2p«É]…ó]ïšÙ7qŽ~•ô-0Mt·Íç·Äøµ¦‹ã ò8ûŒã[0Îk‰;ÄüBÀC¥fö”¤±m7Ü¢´j8¡wÆïÃyS JÚ’–Ç Ëð/•1Õ–)I:8ûá>9«šÙ·áïq^#Û]˜/) ¿ú.Žù#êhëA¼[§oÌÃO¼åÒ>ÊC2t*ì»¶}<¬ˆ+~WÇñ*Ì×ÂpëÐE…eçůu?xwÙÍÀö¡ôŒ+C¥co¨ÛÌè²rIöQ1_tP®ËY¹¶}Z…uÅë`¶SÙö×_–˜>AI»AR'IÿÅÿÔÛ›ÙRJ’VÁ@àe çVÜy¶¹yOlfÏ–¦XÞ¥5eÙ6áÖŽµp¥çiÜÚ°5JÐËÀÔá´Lø­…ûŸÔ'ÏŠÀÑ’¶k¦c,?†GCÞ7ÊŽ¹¡£ÍÀ¯Íc¡uÁ‡K< ¬–”Faf¿áþ˜ÇùëD_Q%žÖ*ßgXÇžcÜ{g}jFÊ=W”=>†»Ç¶£ðî°YÊÎÓói JÚ ’æ4³·jY—Ý_IÒz¹¸HR_¼»¥gsï ^â;WKºwDž÷iùð®Ü ¼ifû˜Ù7’Þz˜ÙÇ’^££Ýoâãê>I7àNÞßà§údz7^ÆHšØÌÎnâaÞ œ#éà3»7Žõ%I·áÏ¿¥ñ—~C¸¸TÒ-qlßÖ]¬¼(é<|Á+fvâxʽ;îoõ*îœ]‰«€ â˜îÆ•¾7Ìì8`ßhg Þ¥º>r ÜÏhÛØæuÜòøc¡ÝÝ€[%-†w3Î tÓ_»1“¤õ NÏ5³ *¬[W€.NëOûFÒxË«-KÒpbÏ<¸…ä}`ÎøGÒR¸¥hD ƒ]éúJšènfïD¹ þÒ´ä“DK½€÷p¢Òñ^¸ï™Ùs±lN ³™½åY€ÞföRÙ¾çÆ‡™ûËgƘÙ…ºáföIA¦9'+øº,|`f߇N×’ÿQXC–°Æ_oZàýÒÇ^È6øxÑÌÞå }’b¸þo¥O¸å«'n ëçã½Â6‹ã><ßâá FHšifE‚Šç,B ¼ff¿Fy’hc(®Íff¯ã~Y,êû^8—ËàCä3³ï ÛôÀ­A£p+Ù \iQaiÜÏêSà‰T‚’VO˜OÃc‚lT¶ü@¼O[3»·Ú²&-O*AIÒ¶ˆXJóàq„âá6)*wÕ"»Ã’¶Àaø(ˆÃJ âkàJÜÁn!+ÌJ’$IZ¿â·Æ-i›µR JZ9Pm|ÔGÉD¼<Þýu pHv%IÒQ‘Ô¹µ?Í#[ÿ£É µ9:,iµD²ÃðØ£€a…Ñ_7³ƒZûŸ?i2‹|’ð§Pc"o'AZ‚’VIƺ  >ê¡f=»¿’$IÜ¡ynj#&ãIZ‚’ÖÊ1øhŠRЮnx®œGe%-¹b’$I:*›à±r’F’£Ã’V‡¤5ðØ=*¬þI…èYà@3{°Í'mIÀ•ŠC’“ßÄ^)äIDAT¤£ÃçÆ»‡™Ù»Õ–©-’– ¤U!iîóÓ£–*¿ãy_nƃd-‘ P’$¥q_ɱx뤤”´$uÅâ•+@£ñü7oáCû›Ùfö ¥)³#’ŽÑIëàñx·XÒÒ1:iMœŒ‡2/Ý—¿à/¼KðhÑoV[À$I’VÂúÔ2æ—4i):sÒpR JZ’ÖÃ#?Â}~žNî*3Ÿ$IÒ‘‘4-žÇ«Äo¸{À-Õ–­­‘JPRu$Í \|œ\jf_W[®$I’VÊjxpËÐ-Õ¬­‘JPÒX \Jh˜$I’ÔÉ&Œë;Ù‰tŽn©%UÇÌί¶ I›"£“K’]¦Âª®’æ3³W«-c["G‡%I’$IÛaqjºÂJqÓÀi OR J’$I’¶Ã:@wø“ÄÉÿBI%(I’$IÚ&©5‘T‚’$I’¤m’JPI%(I’$IÚ&©5‘T‚’$I’¤m’JPI%(I’¶F>ø“ÄÉÿBI%¨™‘ÔGÒÔÕ–£L¦ÿ“´Oë+éïÕ–9I’$©—T‚šH*AÍÏfÀ‰Õ¢Œ)bjS“U[à$I’¤^R j"1º‘HšX˜øÏä;L'i=`¸™Ý/iIà“¨»0p‰™ýZÖÞZÀcÀ²ÀôÀMfö¥¤åy€GÌìõBý‰€µ€þÀ‹föLY{Ës—-Ÿ˜®X_ÒšÑþð ÇÙX˜xÕÌ'I’$i ¤ÔDÒÔx¶ºãÙ|×&fÂ-)‹ DÝCËýcýDÚ»¸  ,À¶ßjÙÏ™ÀªÀ³’Æ£W£«qâ“„ôƒH:.ßãgž•´…ÿB(@‡ÿWm!Û ·’d<‘470®H¾dfoÖõâç÷Ù°Ô|URRjioày3û=ÊóߘٗQLbfoG¹3>ê«?ð²™½YÖÞ¢ÀÌø(².€™Ù±®'°:®È<Šû½hf¿Iˆíÿ¤ÐÖbøpû_€§K2%I5ˆAë—þ IÒ‘ô4°(þq»?›î`?|äñ ò÷AR;©%IÒ¦H%(éÈHÚ8èüÓ”@à{3Ë`·ãAú%I’$IÛá®øíôƃðöÀ»Æî®¶pmT‚’$I’¤`fïâÖ€ÎÔŒîý¸±Úòµ5R J’¤­‘ŽÑIGçV<`n‘‰ñôMÉxJP’$I’´-nÁ-?EÞ´ÿoï¼£íªª=üýRHï@-@ˆ¡7齈ˆ˜A¥[@}¢>@©ŠRÒC/‚‚‚€€´ÀPÅ@€$” HBBæûcÎMvçÞܲÏÍßgd¯²×^kí3ræk³Ió0V›&… $I’$i]ÜÍìñÝ>®­zR­‘‚’$I’¤¡T,UMg–Át2¤”$I’$­k™u$ö1ž- ™KRJ’¤µ‘†ÑI⚟öq}›eпy¢¡ÒfHÚOÐ9ÙÌŽ­z>I’$IÒˆ˜ÙxIoày#Ó5~iM¤€›€Ó€n~’¶””¨’$I’FáO¸2ãöª'ÒZi!(2oŒÅ_êÃ’:HêíËI×’4HÒ E&ô¨ï9±4°”eIËH<óé+i]I+Ïúý%õ–Ô;ê»Hê,©¤U%u«z/“$I’6Ã_€GÌìíª'ÒZi”ã°-_K·—/ÇIõ×Jº×ÍÄ£d¾/ix$&Ý8CÒ“xñÕ$ ,mKJºÏ̾ÙÜD"/Ë/€'ž’žNˆ±n~›§âaË×Â3±„',M’ä³#m‚’Ÿ¢êI´f&ª¤aÀf¶Q©|#°…™ÝuÞ2³ï‡væj<ãù·%mÜl™Û·þif'Ef÷—€šK¼(i"ð53»?ÊÍljŒ¼™mXê{6°°nJâI²pôð 3{ºê¹$IÕHêhfÓ«žGk¥!ŽÃšal!Ûç„%ü¹ÀJí/šÙCq= ×]ý'c€9‹= œ i/IKD<†æøK @I’$I¤44ºô‰p!©ÐY‰ãÞz”Ê”®§7Qבæ\ì ¼$éè–Î1I’$Yô´¡¤“$td8ò”ÛÛKú¦¤³$'éPICjú ’´»¤>’þ#©]Ô_*iǸÞOÒI `¾C%]Tõ¾µ]ú3›krÖ/Uo <»€Ÿó™ef;àîú‡EÓt\K’$IÚa'zžšâÀJÀÓ’¶)uü/0·Ó «j_Ü®´PþLˆë¾¸ ìüÒ+ž•ÌF1Œn)ǧHjtŽÅ¿X IWàÉéÞöަ1À@I¿^Åâ’$Yø¤at²P´:™ÝÕ—J \&i%üwô›ÀÚ%;µËê 7Ø­NýXàÝšç® l Œ7³ÛjÚáÎDÝ€‘föH Ö1ØÿC~tÉæuy` ™Ý[ê»8ðùâ¹á ýE p·™)Õo„›žì¼kf·Vù¾æ…FÒÎo¦Œ™] ìlŒ{d}ÕÌnŽæçsJÝ?~‰{m\<3‡yÜl 쎇!Ïžl¼,}oÆÿBH’$I=v+ @§Kà¿Ó€¯7&%„¥Å ¢†_›—Êkgý%Wgwà!`m\ktd ×q°JÜs¾¤cŠ!¿IêSê{°G@ÿ\Ò^ ?Šçû¯™½Wõ~$I’$­3{ hX(87’Þ§ê‰TACA¸jo¯˜Ï:ø¹êwªýÀ x´æû€½ÊjÈZ$휆[õw½À†gá‚VÑr(ð}Ü¥qnlyIšŽÇ[(xè"ip©nS’zKêXÓ¿°.žŠãJàAIí%õ(͹¸–¤’E²ØbŒöáIËHZ¡ÔÖ¿Þ¾ÔY_ïRú×Î/Ö@<{é:÷¶=îLóôúdzz—çc¯\^WóìÚ¦ò;í,U·½¤Å".’V”´ðwà7¥½ì׋dzk¿;íbïz•û'­Š¿1ËŽq?(I’dži(ÃhI;E@ÄWÝâù<4þ«À²’¾jf†Àðޤ/}€$}W—“´µ™=ÏXx ¼÷íüX]Ò!fvU<<žÀõ+¸çÙs@gàr< ÇáÀÝ¥%¬ƒw\¸7æ¼z}?õúo’~܈ÿàOÚKffãb7Kº%ú‘ôûè÷uøÙ{ÀJu]ãߟán°¢|ž-^øµ‡D[G\XÙ1ÊN+ù+àÒ¸þ:.Ïùž«¨_”ßέ™çÀÒͬc3`l©¼iÌox©î¸j¿ˆÓtð—¸^/úó_¸NŒr'\ Û¬‰ç/^ºî< ìåaø_ÐFy%\¸êå{€ÃJ÷ÞÜÓÄsÖÇ#õ–ë~»2·‹ò™À-MÜÿà R¹süÛÛ¿–³õÝ/ö`ÍRÝþÀq= öì€b,àe`‹(ÿ¸¢tïéÀUçó3OÿOœßáÉÅ÷,?ùÉO~æõ³ÐŽÃâ¸iëø,_§Ë–ñ£zGQažê`{à3›åsq-É€Òý—Æ=ÓÑx˜}€‹=â˜MÀ^Àˆh†k€v–´'žVãCüH«`óÏ;fvc©¼=p™šœ?àŒ‚Ifö·XÏS¸pM”§áyÖ7ñ¬%ýPÒY¸Æ¤³'—cf£b¬pÁs ¤NÀæÅzc/™Ëuë*\–϶mâøîià’~,i™MÃØšÙ“sèsYÌ}jìQñØ×Þ\4—ëJ‡›ð`‰wYºÆ'I2Ÿ,Ìã°p­ÀÀ„šö^xô×zô&•Êàc{0ËP²l09£X›™=$é-ü(è]\{tWôë‹ Ë•î= ?*xg¬½vŒÚõ¼t.ÙM®é?£¦n:Ÿv.¸O{E<£7еÔ^oì@wÜF¬ÜÞÔûhŠÚu½‹k®:ñéà–GàZ¸]€ã%ÝìÖÌØoÓî†[霈J—ùjôíàÖ2÷œ*x 7Ìý3»UÒ.À×âìcf·GóDàÔš1OÞ*•¯Æ4±‡ÃŸâmÅ [ª1Ìò¬*85ž‰™Þ7;áZ]iBdfïIÚønÔÞÎÌn—478ï|ÇšNh{'®µÚ7bÞÐÌŠ£¸­bŸûÇ8£ñãÏ2–ÞÓûñ(sn ¹á¦ø÷j"î^ŸvA­3{¬ê9$I²hÐ*³È'ÉÜ ©+°bÓÝpƒï×ÌìGUÏ-I’$©Ž† –˜$Ÿ€Ë%ý׆MެzRI’$Iµ¤&(I’$I’6Ij‚’$I’$i“¤”$I’$I›¤¡… IûJÚ:®7 ¯ªçt–¤>óxïf’N·òEI'Õ&mM’$I’F¥¡… <ÝÁšqÝ“Ù#;/$ý=Üï[Ê<%Þ”´$p;0–YÉA+!²³¿ZS·‹¤ËçuÌ`o¿Ç{DÒª zžI’$Ië¢á„ I=% ®“oêàèš¾‹GVx$um.p¢¤ö’V‘´¦¤îQ×&Ø7ƒN’zHêPso×ÈdßÔØKKZ¹‰YÄxëá¯aV¤h$õ‹¼jêìC;IÝ¢½¤žÑ6@ÒŠ¥¾KÆÚÚÕŒÑEÒ’V¨™[O`©XsïH×ÑX"Ê=ë¬opíøÑ¶LD¥nÉ»]LÒj!–ë;—÷7ÖÚ«Ø{<^PŸÒ;ªÝ‹eꬻS©Ü¾Ô¿[ŒW¼ó–ÛL’$IA*X¢¤ïãÑ ŸÀÓa”sA}¤ø…è{ð¿Àãñã,<þËÅuÆ] ¢¦ÿV‹@{ãI6OÄݦωñÇ1{¤ãG€Ÿ7ÖŒ»,p5ž›j*Ð]Ò03W3…õñ¨×p-П€“"2ö×ñ$®«Jú¶™ý5îyÏÿ5xèx¯¤kñ„¨+Kº¢¸WÌáeIÛEäè¯àYÜÇKïKú’™½ œûUh¤Žº÷€B¸¸ ÏÑ6èë{QR{À²øÜ*Qþ.Xå=€;âzüGs¹(¯†GÞ¯‰±ÜT*w:Äõ£À¶¥¶MñžºDù»1¿!uÖÞ,÷‰rwàà{Q>­˜[”‡ï–ÊÏ—ʫijŠû»á‚ä·¢|.ph©ÿºÀ«¥òx`­ª¿óùÉO~ò“Ÿj? í8,Žt¶ŽÏòuºlŒ6³ÿ˜Ù³¸ö¦[÷™ÙKÑ÷ßÌ~Ä´YéY=ñU›Kúµ¤ B˜Qo`3{×¼ ªý‹Ì5åõtÀ3Ó¿-iI{áÚ•–&çܘގçÞ„k[Ö-õ)'{%ÚoŒþÏáé"®òtÖ÷VëûðG3+2²À…²z|?‚º,æ:O†û…–ΧޫÂ5Q˜'Z½j>ÇK’$IÚ ó8l'\Ë~Ì3¡¦½'® *ó~cuÅ‚2åLå?`V†óCÍsZí„k/þŒ mof/71þ9À’îÂó™­V§OØ¿~1€ñ¤¡-¡®)óNŒ[ðvMû‡5BÑŒš=›k„À}¶NÁ5LC™]ÀšÝð#É~ÌÊ‘f¥õõ¤ô~̳{Oib¬^Àdó£ªzk5\À*h‰pþ‘™M+•ß9Õ£álß’$I’êYhB™4‡.c€5%µ7³ÃÎg]êkƒ~ZêÛ7<¾*žµgç?< éGÀƒx‚Î3ñã­î5ݯÀ3ª ÜmfêŒ÷Ndµef·ÌÖ< lY$-q=»€¶|Gà·¡aBÒ¥¶é^¥®föa©î¯73›v>cÔðJB•¤ÁÌ.À•ô–4ÐÌÆGݦ¥µ¾‡'a-X¥æþz﨓¤ÕB nwõŸ¸~×<¬Zg¼¹öðK’$I-É0ú<ãúE’®Ä †;Õëhfÿ4¸MÒm¸+ýÀÌzý%}×F< ĆþÍO‡ÄÝýf6ÚÌ&KºÏÆ>¬™9œ'é8\³µ°”™Åœ98HÒñ¸ðOq{›1-¸·%ü+Öõ°~TôbìßäpΔô0n¨ý°ž¤£€—Ìln”|NHØّ¸¶ì1I‡âÝ|Z;W¼¯·%\1’ÖÄ…´õ¢ËíÀ-’FEyßš!ž—4ø'.ÄLN‘tVŒ·n0^Œwµ¤ÇqmÖ~uÆ;ZÒMÀ]föÌÚó$I’¤Ñ0ÇqÌóEÜ«gðGü‡õ¡èòaì„{‚M‰~“€‰M ÿ .í ¬ 5³û£í Üh¸³kîÀ —kµ<¿ŠgafW;+âBÛRøq[=Æ¿/­÷màóøÚPÜu~¯RÿSpãè‚×™åíTpRÔ\ ‚Ä!Àßbì7€Ýq;œ‚­p¢þ@ÇvÀ—Œ9^ V¾Q^_%nŽ{¼mûx4ðfëÿ n°üe  °A¡ -Ý^À&ñŒ}p½‚ïWâGs…g pp<»?°Yq¼ifwàÞt[}q/ÀSKãí \{Ãu%I’$i“´Úª’ÖÆ½­>’47Ìdî>¿cwÀ]Åo7³E2ºskFÒ*Àƒf6O‘»'Ž`WâGÀkföBMŸÅð£Ë—ÌìùRý*À43{1Ê6õ…ïâNJýûàBs\ã;* Ú‰p]j¦÷z騳ˆï´.ðNÀßÿT2’~ŒkŒmAߣpç‡Ô4&IƒÒHÇasË®ÀwËi<°ë€¶Â=°Ψz‘Iò²-®½BIú8ÎÌ.ˆ>ý€»€% /Dðp¯¿åNÜ€~$®a»HÒúæ1¥¶Åµ”÷áqº†àG×ÛÆXWá1›ÊZÄàZW$ yŽÁ==Wй~©c'\C;G!Ø-ö#… $iPZ­dfGSAz{ŸAê‡dÁaR ´`xÉ̾T$í \)iª™•O'ãGŒ¿¯3Æ·ðcÅu‹P¡A*ÔÌÇ'šÙ)¥çÔºefŸ:J;°k€ýÍìÒRýºÔ± ‡Šfö^IíVh°Bóµ80¦ÆS‘°{댭£/Ð»Ž–¬3@¡‘*?»©Í–Ô?n~®©0I’,ªiïQóœÚpMñ]üèìÒšûG7Ñð/I#pÁA’.õÅßŵU¯KÚ*øY}‚™MÄ…‹ýqÏÉ£g$­í—౟ÎÇíyþa0ÊŒn(}ŠR™=jK˜Ž{ÿ†ÛoáÞ¦ÄÔh\ó¹ý¢’­Ó9Àú!ÄmÜif¯Æ½á^ªóÂ0Ü {wI{âGî«…Áx’$‘BP’$µ¬Ž͆™=Œ‡Ž8¼NÛfv™ˆ>O~TjÞÌÎ4³Ý€oJZ½4Ä}fvuéS¿À,¥¥L­±ë©Y½òz3{dúwq[¦ÔDEÊ幉tÞÓ±° ®ú9MÄ6K’dá6AI’|‚¤¥ñ㣠šèr~<5 ÷CR»²¡q¤PG¸½×¶ã‚ÍLZ£é*<ær шßÍÌÞ˜Ï%?Çë*Œ²7>Àívþƒ{¡ÏìÂìÇ„ïáš­‚UšyÎãÀófv*I’4 )%IÛ¦Ÿ¤ÃqeeüØæFÜ£ëS˜Ù³’®¾Ç¬Àœ‡IÚ¸ wß8Æ)\àt?³l{À#š?Vúû«`œ™0³;"*øHI¿ÃÉâ/÷Ù燓ñÈó¯ÅÜO~ef3%Ý'é ÷|êŽGZ¿ÔÌžþâÑÈWÀ…ˆ'€EÞ:I?áÓ!ÆEê–b[ãÑËûâ¨ëÌì_5÷îì˜Ù ¥ºƒ«Âv I»ÍìÁ(¯ƒ'WîŽHýSéÞÅq#æ¸]Ñ@<äÓѾSÌk<žsð[fö›hûp[áZ/i%\x[ô~«™ý£êïA’´eRJ’$I’¤M’†ÑI’$I’´IRJ’$I’¤M’BP’$I’$m’‚’$I’$i“¤”$I’$I›$… $I’$IÚ$)%I’$IÒ&I!(I’$I’6I AI’4’v‹ü`I’$Ÿ1:I’†CÒ4`°™M¨z.I’,º¤”$I’$I›$Ã’$©Iý%Ý$é¿’^•tK©mT$fERI×GŸ»$í#é¢hë*é1IÃ$–ôФ£«^[’$­ƒUO I’6ËáÀ;À ` °A©mm`±¸>øX èÜ ¼mí£ï.ÀÖÀÀHI·šÙ¨ª˜$Ic“š $Iªâc` °*0ÓÌFÖvÔØ 8Ö̦šÙxàì:ckfï™ÙXàŸÀzU/.I’Æ'… $Iªâ—À£ÀuÀDIÇÔéÓ×½Vª›X§ßë¥ë)@z–%I2GRJ’¤Ìì}3;ØÌ;‡IÚ¤¦Ï[À$`H©zÕªçž$É¢A AI’T‚¤]$ ‘Ô˜ŸIuºž œ)i3I»{T=÷$I RJ’¤*–.Ægß7³§£í`Z\ ܆Ûúœ¼m3¢ïÌÒ¸ÿ^®zqI’4>'(I’†FR'3›×®F›ÙqUÏ-I’ÖMj‚’$it¶‘ô¬¤€§~À爵T’$­ŸÔ%IÒðHZX˜nòI’$óM AI’$I’´Iò8,I’$I’6I AI’,HÚ>ŽÍŠrI_‘4´ê¹%IÒ˜¤”$É¢ÂñÀç$õÀ¨¿ ¬VõÄ’$iLÒ&(I’EI›—šÙJUÏ%I’Æ%5AI’T‚¤›BX)Ê’t§¤u£¼ž¤Û%½"éIÛ—úŽ´¤;$½%©·¤Ë%m)i+à`€¤Ç$#i”¤ÅK÷/'i¤¤.UïC’$Õ‘BP’$Uñ$ð½Ry+`0ð¸¤þÀmxtèe+%-}ã¤VÞ>ôî~ŒG¢Þ?&›ìSzÖw€çÍlJÕ›$Iu¤”$IUŒv•Ô=ÊûàGX3q[žQÀh`à•(ïXºÿ<3{ÊÌ&™ÙÇEeÜ?˜ifSÍlp°?€¤ö¸tnÕ$Iµt¨zI’´MÌìYI»IºØ•0lÆ#®\TsÛ¥ë—æâq·$mt&›Ù?«Þƒ$Iª%… $Iªd°/®¹yÂÌž‹ú€gÌlÇfîm±W‡™™¤s€ÎÀyU/I’TOj‚’$Yä‘ô?ÀH஀’$)øôÛ3`É"zTXtSoftwarexÚ+//×ËÌË.NN,HÕË/J6ØXSÊ\IEND®B`‚ldns-1.6.17/doc/images/LogoInGradientBar2-y100.png0000664000175100017510000016654512264060151020717 0ustar willemwillem‰PNG  IHDRFd-Ê·ï pHYs\F\F”CA€IDATxÚìýw˜nÙUïpÒ›CåpëÆîÛÝ’ZYBÂL –#d`óaÀŸ†Ï ² ã1ÑX4ÂI’i!»[êtûæX9W½9‡“Ïßë=§Þª[·ûªÕmIþÞõÔÓ]÷Ôk¯½Ï>k¯½~ka)%шF4¢hD#Ñ×2‘¯4#шF4¢hD#úri¤ÒhD#шF4¢}ÍÓH¥шF4¢hD#úš§‘J7¢hD#шFô5O#•nD#шF4¢èkžF*݈F4¢hD#Ñ×´º½l’a„@g»—œGVºhD#шFôb D×±®î¬SBLl !bšþÖÓç’H¢ÑêB“›¼´µâøn!‰$Áømg2T툕n³VÚ®W4E¶AaŒ|ÎÎOŸ8‘ŸR’ÿ©õÈûÔ›G*݈F4¢hD#z1RRŒWËûßökÿ&¦éÃ÷{!?óßÿ¯¾å»ç”·ÕqÎøC¿¾Q-‡ÛRhT½ò3896]Ñr!JÿÙÏþÂã<–ÊpqpíK iö»ÿù}ÿâ_~ãw!¥_i!½Z4¬Ïq!Á“‘•nD#шF4¢½L¢„¤¸¡i‡]¶pÉŸýË?J±þ·¿=à\!…ŠÈ1­`”ÔT,Ö¸è©BS”±íp=]QS±DʈsÁ‡˜¡>cš¢~¥¥òꈑq®Pz§°ýÃð}ÿ¿þÄP²©t#шF4¢è¥IJÄ¥BÊ¡S)Á8OüŸþ»I#þ}ïø;ç*¥RJyT7R)¤Ré$<¼G¿’K ‰è!ÛøJKåU¤a}n©´ûÝ¿õ [õrÀٽʂ˜ŒhD#шF4¢—Ià‡NêÆ¿üã<~ý‚J)ãcŒ^\ß’/ñï—üãÿÔêÜ!}n¹´÷~óçêýn>‘z‘*#•nD#шF4¢½|‚8#„CQÿ?úµ§–o(¡V÷5mE“‡éiä>Ûès‚+”î4ªÿä·±Þï$ #àüEjTºhD#шFôeøï+”b„¿ÿ¿þ§K[«_…Zp"¥dœßýØ (#¤€'p;,¤àBpÁ£î§!py¨&¸ËÛÔ>GèN£ú¿ù3ûÍZʈ1ÎFÀ'Ç0?RéF4¢hD#Ñ—K€ÇÔÕcþ{?ø–Š» ¥L|iu×À+”ÞýÈ ‰œ`¢PJ ¡„B(ß©D’ q¯E™àRJB%D¡T!t¸…P‚1(ˆw7¹à ¡»ê?úÍŸÝiTS±xÀ9F#¤Š¢äó”4‚GŒhD#шF4¢W„@‰izÇ6¿û±_øÄOüÜéñi.8%ô«A«m©çØŸ¸ñ‚c .zcç&gÞuþQ)%´Òm=µ|óÆþf¥Óv/‹/ä'ßuþu_ÿÀkTªp!(9F$ 5"C­k·Q½²³¾RÞ+¶=×ö‚ O,ä'ßtêwž}$ŸL )¡)4”ZdH ÝmT¿ó7v»QÉ€>‡1dËøôíË›µ’Ë‚ªø¯?qæ-§©t#шF4¢è•!ðèOèF©ÝøîüûOüÄÏMgò‘ô•å ¦Z¿ócþÏB!JHÏìÏ;þî»Î?Úuì_ùô_|äâSµ^… Çlû+Ÿù‹·ž>ÿËßóÃoX8{D« U1A0Æ}öÎÕÿúÅ¿¾¸µÒ¶M!$Áƒ„iB .$%d67öî7|ÝOü½ïœËÃë>'(¡µ^ûŸüö/nÕËÙx2à,2æ)”þ?ŸúsÆYļBh·×þ?ÿÁûF*݈F4¢hD#z% ´ºt,¾^-~Ïc¿ð—?þ³Ùx"å~¥YC!ŠÉX"Í'˜@4JBx"•ÙoÕ¿ó7f±¸›‹'Ç’i4ÕJŒ0„c¹²½öî_ÿ·û—ÿσ‡†ô9JH©Ýü?þôw>qóŠIB7ŽTY½P×6ë‰Ç?våÙßø¾ûö׿=Òê„”j¯ýžÿòsË¥½HŸCá­±”2K R!TH™Ð 4ò¥шF4¢hD_Eæ·èŒqÀy6ž¼¾»ñÞþ’í{„ñ•¶ÒEÄ„`B0Á¹\ˆ€1ÒÅâÎ?øŸ^¯§39Bü ìs` œgIËsÿå}Àñ½á SÐç–Š»ßô+?õø ùD*K€j Ÿ1ˆ''¤d‚SB'RYÓsß÷Á_úè•gBŠA©õ:ÿø?§°3¬Ï SˆÕþà-F*݈F4¢hD#úréˆò18Ë'ÒO¯ÞúÁÿ÷?1ο:ŒtÇÒPµ;ÅÝr§•‰'A?#SBð=•±t,q»°óg—ŸFh>RRBj½Î{?øKÅvc"•aœúÒsí¾ëÄ5]WÔ¶ÝwnlÎtE‰kú¿øð¹±· }¹ÿ]¿õó×vÖSFÜgÁ0xB"©Lpþ0Á™Bޝ#шF4¢èË ("®ëûGæ@«Of>yóâ?ÿƒß€Ì¤_qº» ¢%늢R!Ùsì–Ù7]§Ñïùœ‘!½ üáTJÿêÆ ¡èâ!ôÓÿƒõj!Oøl`Z£„ôû›_ó–Oü¯?÷Ìûõ™ŸúÕÿðÿ}f|Úò\°ðq!TEqÿß~ì ñj·]î´æóq]×u /¡#‘2âð“6â™XÜP54B¼ŽhD#шF4¢—M„ÓuþÎÃo@}úö•‰Tføº´º‰Tö#ŸJÆo¼÷Ç„<”O쫇$B Ï}ë£oû'oû[ùdj¹´÷_žx¼ÒmëŠ:@È"$¥ÔUu¥²ßs¬t,np7ö6?~í¹|"„¡øBÛ¶ù}ïø;}ÿ"Õ!4ŸŸxëé¿õWÿu©ÓÒU"É8OÇϬß~béúß}ä³¹± ÿæ7ÀºùSñ»¿ó…¿Î'S` Da„|ÎþàþÏwœ}Øô‚ <RÆ5¬t#шF4¢èeF˜ žŽÅÿè‡ÿ¯7,œiÛ¦J•#¦8&øD*ó;_øë÷ñ?4T-Ôp¾ŠcŒ1î»öÏ}Ç|äGÞÿî7¾ãç^óÃëÛ>øƒ?1’èÀZ1JÚ–YíuB—ö/®ÓtCÕ¾Z:„(!¦ç|ý¹×ü›w¿°à?Ç‘@=4sâÙõEl`t ¤".„øP·ÞïZ MQ†¡ ¥M³÷{Ï|Æñ½!àˆTˆÒ0»U¹àÑM®J•J§Uëw¦3y0¾·‘HÉ]ÅF*݈F4¢hD#zÈgÁSsùÑ÷çoþŒéº†ªò0]J7¦ê"Ì©õU©#ìs¶06 yiLŒ!„&R™cÍfïM³ß=Û€„qM¿´µúÔÊM‚ñAmŒ”„´–%ÄòܶmNgò_|d¤ÒhD#шF4¢W€(¡Œóן8óG?ü×~ÞçL£Ê­ ›_=úP¬ã07Wø§a]m˜¢Œs.„JéAk ) MKÇâÇVä‚w0ö…p|ï¾x½·Ê7RéF4¢hD#Ñ+C ¥çï<÷Èïý³ÿý}¿ó”1¤ÕA±W\Ÿû2c£È»ãêÝw]UQ”Ã)_ä8/›½ûhcŒ¼ `\ÜOwG$%‡E#•nD#шF4¢½R$¥T) 8ÿæ×¾å·¿ÿÇè÷-¡cñ*˜åÀ¢†R`ù¢þg¯‚ÑX"•2bÇR0 ÃŒóñTú§¾ý{ùÄ^\hqÁÆ&PdË<^§ÄRJŸñHÔ0(.B’:RéF4¢hD#Ñ+F¡VÇÞó–¿ÙwÿãdâI<¤‚¼r nE &€<}IÆ^ñÁ2ÁÇS™ùÉÚ+QØJHÛ2ßõàë^¿pÒQÜgƒc0ÖÝm²ÃûŒµ¬>BˆqF E‚!³”r¤ÒhD#шF4¢W˜Bç?ø7¾©çØïÿèïåiÄ+¨Õq!’†ñGžxncÑgì^­b„¹ ÍøÕïýçÙxò&B!ô8=7ë!…cªöW7.~üêó MQâšžO¤1Æ#•nD#шF4¢½Ât Õ!Â…øßõC}ÇùÐsŸLe‡“À~¹] (×Â=üä$âRp)^½d0–ŸùŽï~ci¯YKÇA¤Õqž2b^ààÉÇû ŸŒkÄÀóX „Ô%¦icÉ FaxaŒP6å-§\ÈOVz-ªD*JÇ‘ü¤D\pˆŠ2J6¢hD#ш^yŠ´:ˆÓö_Þ÷/Þóæ¿QïwîNû5Mc.Äd:ûG?üMer-³§R… ÝÀBÆ’éL,N %„ÄT=O§Ò)#®ŠòX`CPºP*Lð”ÿ¿ñ÷:¶©* ÝÕ"„„\ ~„ãTâ+-ŠhD#шFô5@c…P……þ(”(”Þ Ñ ZÁ!‰1þÿ—Ÿü¦×¾¹avuU£Ãª{6BQè À—ú-+„ßÌ*ô GJ¥T!”ܳw|WïT¡” €!¸¯?ýéÿýÿöÃo¨÷;–çb„)! ¥$ŒKB0†¨*¤°<·ÚkgãÉ7Ÿz EZºùÿð¾ñ…V!¤RJ1‰Z 3!Ós[VOH1ºxшF4¢hD/Mgõ~7¦iÃ66Jhßêwë^µB­Ž!tUýƒúWïùÀÏ?¹t#®éBF‘:°BST!BG]ã,Ïéõ:HJ6”tá> cppõÅ¥hô»ŒsŒ ˜Å(¡}«×sltÜí¬å¹Gz'˜˜®íœ%Æ$Òêò“ûÿþ»¿¸üô¿ø×·÷·mß#+”` )…€‹`”6âo÷y!ÆzÇ»ÿÈÜÉoýÛ…‘g›‚òÜúâ³ëw†{Çû,øî·}àXIbŃJJaœß*l=¿±¼TÜ-v`´“HŠšK¤æóãÌž|ëéóN͈*‡Ê“å„RRB6kåOݾtmw£Üiœa„Ó±ø©ñ©GOœyÛéóNÏQB¥”#•nD#шF4¢½ê4PzÂ+ȯ¶4¯/{PÃÿ= üç^|Œ‘ÒÆ… L†½åÐ]ZÝ‘¿ÞÝ%d¤ÒhD#шF4¢£aÕᘿ"®]/©¥EZÇç3¥p±xØX%„`œ©BÃÛÌû$hÚ¼{Ç!²,‚õñÒÆ9ÂÑI) !”Ò0M™”R"Œ&·»PE‹ô³ÁMë=äÀÃPyhçh#‡Bž %#‹’¡!ᢻå½ÈÃ#$’‘‘óøw=Da„_¢Ùã¾43w÷õJ4û2$s?ý¾JÜŽ˜ù’šè+>„¯6f^ ÿ¬õê1ó*Éók}š^¥1¾J’yyý~µm•_UÍ‚«ØËafÈÅîîOíËœ;„З·ìÑÝUàÞ1¿t å±ûÿ¡Þ]âeÛB#-þ^¼¸k‚ÑÝ_Æbº»ß{8ÂíðB9¶–Dr \†tw­c†:9¾øµáeøEEwðäð p¤ÌAïCÍûðîŽî.pw;/¾BîgS¸f¾”¥z_ô ŽñE¸½W³/9M/ÎÌËxqî>qËÌ—9M÷³€‡‡ó"kæeÌÝË”ÌKMô‹ AJ‰0F÷ØÓ¾œf_ö^z¬^r¥½¸d¾ÌÙÿ’ð½j½¸d^röïÅíKJæØ¯À½^ŠWüÝÿò§éþçñË_À/oBJé3Ï<óû¿ÿûÉdluBˆ÷¿ÿýóóóàî}jïSž÷âù~”è90öøãüãO¥R¡~¿ÿîw¿ûý£Ä9§àqxD>¡ÕìU"v3ø¯Dº“RÂdH/ñPª»káð«PøP*€¡ÖÐC!†»¸ûadÒCøáð;BFM ÕÇÕ¿HŒ±2Z‡j Ms4p&?n–q5Ë8‡0( ‡ !š•ýacB’ÄÅÃ4sBprÈå€fø‡QøG.¸ŽJ„|Æ¢¾ØP-ÖŠ œidà k ¨å±j1ÁyhµöXqè³ š…¨Y/8¨p>¡à°B„gÐ/㜇¢‹rÁ×`k"`µ"nÎEÈŒøcŒ±øLðP\üøZB@-Ç÷[Ÿ·g"¬ Üñ}£ƒ!`Œ}Æ ù –0pÇ÷€Ç÷¡Y14Æáfmßã!3ôš…U'‘´<ÆÈ8bcÚ¾cäBølÀŒÇ°$,ÏåR@-Ûs#y²ËsÂ! :)¥Ï˃ ny.0ãþ Y)M׉˜ ¡dÈg,bÆtÁgÜ |˜hƹøƒZœE’é»64pæƒEeºpËï»0ã± ÞwlcÀ¬U„ø0Ѱ$`ŒnàÃŒH„zŽ Ü2ÎÝ`°˜-×1 )zŽ%†&†àø^Ø,šµ}Ï E×u,]Ä Æ¸ïØÐ,¢k[Q-;d¦k[ÀŒÏYϱ –ø°¨„ÛáLϾœÀH†óŽmÝ=MÛf|Æ"»a³\ˆŽmF̘ž µl߃f}Æ:¶9‚ë8í{ð{,y"„:¶ ýœ·­>̾é9ÖP³0û>cN¸Â;¶«Ž Þ²úâð4!„ÚVßç f¼mõ¡VϵAt\Ësáu³}¯ëXÑÛoVÀYËìI$1ÆŽï¹¾¬é:!3Aôºµ-Ó4ËMÏ…wß |;d¦iö@tg–ç‚躎cB˜žÃCfÚ– µZfÆèsÖèw¡–ã{ƒ¥(e£ßn}XáKjy.È“ ^ïw`…»ï>,EÓs‚P2 ³7Œc˜‘²eöïž} ¼N¸€À,`„ú®.`MÁp /!¥í¹ ÏáíË ühŸAݾ}û÷ÿ÷ë·~ëøÀ>ðÇ{¬X.â"„‚GŸ!1ä‚6ôýø°† ïv¨ „ŸõêËÍ$ú;‘.\øÐ‡>ôØc=öØcúЇž{î¹H'¹[eÂIt—¦üÊý™Ÿù™F…$BŒPGÔ,PZqxŽÒ·0L˜‚"†4„œ`2Ð0¤|/¨c&8ã#Œ0 8çBŒ9|\‘$˜ø,`æù,à‚BÎ|ƤD ¥gLpøÅ “B¥ lµ*U`¥r)J½ ð˜Ï¥T©âsæ3_STðEԨ…°|OWTŒ±x皢¸oû>\WTŸ1;ð UóX`z®Ï˜F‰dϱ5E%Û¾ç±@WU„P×±! ¡>c}׉ëºÏ‚®c{¯QÅñ½¾k3)TJ;¶å>ÁX¥JÛî„UªtlÓt]!¥®ª=×vYS5)e³ß…¾šVßrJ—¢iõÀ3­çØ]ÛR(„6Ì®é¹ ¡ª¢T{…P•*nà7Í^:w¿ÞïÙ¾«+Á¸ÜmÅu!Tíµû®C1ѵÒmL4E­õ:Û”HRB*½vßu4EUZh7 U£„”»­ŽmRB¹à•nËôݸ¦K‰ ­zBQB:¶Ù±Ít,Ž*´ë*Q4E-µ›-³/¥ŒëF¥ÓòXÐZ¿Sëu|Æ M+µ›-«O 1Tm¯UÃÇT­ØnÖûpÝoÖ;Ž©«š®¨[õ²¡hš¢ö]§Ønä)Œñ^«Î8OèFÀÙV£’2b ¥µ^§e™¹y³^¢„Ä4ÝòÜF5ŸLLö[u'ðÒ±8b½VL1‚ñV­\ïwUªxÌßnTºŽ‰'9çkµb.ž¤„ÛŽmåI‰äJe?¦iš¢nT‹•^–ýFµØ¶Ìt,Ž^,ïeb •*ån«Úm§2Õ^g»QéØÖX2íÞzµ8É÷{­Rl˜Ý¤ÓåVa+K(„.—÷Ê–¦(n¬V m«—O¤¹à‹¥Ýñd†²Û¬ÕûÝñT¦ÐnlÖJ}×ÎÄkÕB¡Ý@¥c‰Õò¾í{¹Dr£ZÚiV-ß›He íF¡Õ˜ÊäJíæje¿iõ'ÓYÓuî”væó]ÛºSÜ©tÚ™x¢Òm¯U ¦çfbñÛ¥ýVbšŽÅoíoœgãÉ¥âîV½Ì×UíÆÞf±ÝŒkzB7®î¬Åu#®é7ö6¶J‰òúÞf¥ÛK¦wš•Õò¾å9S™Ü^«¾]/ÏåÆBWwÖJSFüúÞæV½ì36žÊ¬”÷j½ît&pvas9OÆ4½Ôm-•öÆ&B×w7ç¹DòæÞæj¥àøþT&·Q+í4«ó¹ñZéva»m™ã©ôõÝõjAH9žLßÜÛê»ÎD*s«°½XÜí;Öln|·Y])B=»¾¨Pš‰':–yaséôÄL×6_ØZÞmÖò‰Ô~³v}w£mõOŒM–º­k»ëg'g ­ÆÅíÕr§9•ÎÝ)îÞ*l[ž;›[«¶›Õù ‰ÐSË7âšžŽ%j½î…Í¥§ç«Ýös‹{­úT:»V-^ÝÙèØæÂØäN£²XÜ9=1½Y+½°µRî´f2¹«»7÷·¸š¢~qõæV½2žÊì6ª/l­´Ìþd:ûÜÚ¥ÒÂh"•ýâê-/&ÓÙ6–¯ím:¾—2âO­Ü\¯“F,O|êö带gãɧ–oÜ)îœÍdóÏ­/6Íþ\nüÒöêå­Õ¦Õ;=1½RÞ¿UØ:75‡úìâU„ÐD*ó…Õ[×w7|Î MûÜâÕõj1—H¥cñ¿¼þ|>‘N±Ïܾr»°m¨šøŸ[¼º]¯Ìç&$Buó……±)]Uoìm.÷˜š»SÜùâêíR§9ŸzõæÕuJÂèS·®¬×ŠÓ™|LÓ>võÙÙìX\7–J»—·Wž]X)ï~ùún³z"?ñÜÆâÅÍÛwOŽM½°¹¼Q-›š½¼½úôÚíJ¯=—ûì⵫;뺪úŒýÕÍ‹Õâɱ).ÄŸ]~úüÌ /ðÿòú…Û…í”aŒ%Ó»úlR7ò‰Ô'n\¼¼½æ±`alò©å›û­úÙÉÛ÷þìòçóãI=¶XÜ}fõöëNœ^.í}úÎåõjéÉYÓsÿüòÓÏœÐõù¥;ŇfN\Ø\~réz¡]dîäv½ò×·.½éÔ[õò'n¼°TÞ?5>%úðóŸhfÁçÁŸ_~úêîÆX2]ì4>qã…ÝfíÔøÔgî\}výާ'¦ŸX¼^h7ÎNÎ<¹|ãóK×ÊÝö#³'—J{Ÿ[¼öÆ“çBrñ ÉÙìØã×/|qõv×±˜š{fíÎRi÷¡™\ˆ=ûÙ‰t6—HýÉÅ/\Ø\Ö•qþ߯?¿Q-ž›¼¶»ñìÚ¶Ý?;9»\Ú»SÜ979‹úÌ«Uò‰TÓì=³vû©¹–Õ¿°±¼ßª%Óû­ú­ýí¾ëä©›û›»Íª¦¨^Ü.l7­~.žÚmTwšU±|"µ×ª·¬þX2]é¶÷Z5ÛóRFl·QõôÂ… O~ösš¦aŒ"úïýžÉÙ™˜¢v]»kÛ)#Öwì¦Õ÷?®ë\ˆ¦ÕK1Ÿ±ŽÝwƒ@¡ŠBiÇ2!ŠžÇ'ðtUóYàø>ã¼¶ï©„‚v:œ1&¤¤„ )á!ØTEyê©§žyæMÓ!Œ±w¾óßôMß¼Hw µ, :‚(}è¥/ú¾T:XO¢A×GtÈûÓ)A Æ¡ù-¼Æ9 "!&¸”R¥”KÁ¸€ yL.•8C+”2ÎÎ/cB]QÁÚ5p®©ÊÝk"KlÀ™¡j MFõY +*F(ØÉ‹ŠxŒÅ4 ŒLQF`7ð E%{ŒÁ|îð( lß7UUËs|$8ãÜt]JH\Ó£˜Ñá…gbñè1$ÇåI”ŠÅ-ß5]'¡ ¥]ÇËÆ“^tS¥JB7LÏ9Ê””¡¾ëÄ5MSÔè\޶<—`œ‰%z®=(ˆqÀ™Ï‚ñTN‡†ªÅu½çZa8ÐX¾'¤K¦{ŽÝ±­t,¡ÚwPô£>£ÉŠŽ’g“élV]ßu¦Ò9Ÿ±z¯CK¤Û– -„A«žÉæMש÷»q]Oê18aK™™Ö…’ÛCòZ µ†žÃÙ£c[£Ét¶ÞïÔû©tŽÒ±û-:dÞ›%˜ô› 1›k˜ÝJ·5‘ʪÖèwa'Bá¹ ªT{íùܸD²c[8Öz\"‘ŽÅ«½œ2)Á-«‡šË—;­b§9—S(mš]8PW¥Ó:5>Å…ØiT„”'ǦÊH cÄ…h˜Ý³3ÛôY@àÀ†P±Ý896…lš=ÐGBÅN3ŸH¥Ò;õj½ß939ãøþf½¬rj|ºÐ®Gâò‚ c›çgN4ÍÞF­”Ž'¦3yÐ&¹””–Õ÷{pz¾ÔnnÕË3Ù|&–X¯[fÿáÙ…¦ÕwŸ„æ|ØU(&¦ë˜žóÈìB©ÓD!„£S³ åÁÜ I0öXдúž8]íµ™à¦i¯Y{xæ|±¸ËÍÜ©ýf *‚¨+ÖÎ6Íží{~Ðlh€GRA ÙnTó‰Ôt&¿\Ú/¶›¯_8Ûsí¶Õ§d0õÒ™‰é„¦ßÞßnYý7Ÿ ö‚ Øi~Ý™‡êýî½lRÊízåçiö{}8U†C€Z=Ç®õ:o?ûp¡Ý¸¶»1“[ÈO.—vBð,´êgo>õÀRi÷ÆþæÃ3 ©X|£VR)š’R¶µXÜ}Ë©1Æ·Vßÿº³¯V WwÖÏLLOgò+å=‚ Ü´ ð!t«°ýúgâšþÂærÛêÿÍ_·^)‚É J.•vßqö/.l.K)¿îÜË…ÝËÛ«¯™;™K$W*û*¥Œ3•*«Õbʈ?zâô­ým„\!N¹ßðУKÅ]„ÆûDp5qˆ™k»ëoX8k¨êj¥ R…‰ÁRŠVïÂö7œ´ãXû­šJ)|®n¯?4³0–HÝ)ì¨T 8Óe±¸›Ð·žzðÒöê½Íwž{ Fø +·ú®ý¼i±¸ƒÐv°TÚýæ×¾¥ÚmÕû…(ÑÕL“é:û­ú·=ú¶µjDÂg‚«TÙª•ûžó¼ñNaûâÖÊÃ3 ©ì…¥B«þ·z}©Ó²<›½ƒÙ¤çV½<™ÎL¥³+åýr·õÚ¹Sn௔÷Âg&f ­Æ^«6ŸŸ0m»Qî»ö¹ÉÙ¶ö¿Áfw.7.¤(vš\ðéX¬°,$)åD2íÏXä¯Ö÷œL,Žr|?rdr|O£ª¦¨Ð°b"Ão½¦(ã€qŒ0’‡þŠbB(T‰‹40!]»W(´ÏÝ“^=Bè+=ßç³^J÷ú;¾ïWz%Õç¡¶ðP,ž{–÷©HƒsàÛyÐìKqþ’#“G Ëã"ïn^˜—dþXo¨!ÉÜío042)#)½(ç_úŸ_´âÁ î¯‰ßÏ"¼Û‹BŒË#ÏD÷âÓˆ ñx÷3|[øî¦åðÿBÕq,àᇡ꘿ Ñ?ð‹ËH¢/ÙEÕº[´=º‡Ë»Û9®m„б1y¼ŒF¡ÆŒñýci!ÿ2 È} ~K‰"Я”øÐ¢ênCa­C;”<î%”¡¼îý†Ëцi ¢rNÈጄ¢;þè Ü Ç ÃZ÷Üa X+ÝÂô•ºJ#7Q8t.ÊÊöˆèÈ}/E‚1:zøGÃÉ`\wÕÝ@\#ŒdÈvtD9vy ú=ju€É ß{]ÊÁ›‹exÇøn(ÀKHfL†S>x8Xi0¥—)>þ½ÚKð½º8,ÎÁvëWYÏúH‡UºÈ‹÷ˆïo‚,2ZawU‚SDH ­š…ð3ƒ#àË¢PIÉ8W…³‹”RU‚‰ÏŠÉð P)õÙÀªwx4ƒ…«Å J¤Â‚»W‰:Àãc6«(¶ïC6è57TÍeRSyt?vQb„PLÓÜ K膦¨}ÇVMx8Å5=¾T(U)í9vLU0£¾kÇ5#iÄ,Ï 8ËÄš¢t,SSÔL,pfznBe c„PRÙ¾ç³ ©2Df$tCHÙu¬”Gá‰\¥Š¦¨~7®é¹DÒ |ËóÒPa)eB3Æ-«—ŽÅ²ñD×±˜ài#.¥$CïðÁ0–RÆ4]¥J­×…ÛX~RF¬ÒmkŠ2™ÊrÁ›f/—H¢Á9XjŠSµr§™0Œ‰tÖö<ÓuòñAð½?øt Ùº‡ Ð݆'}¸0XD²ñ„”¨ÖëL¤2“élµ×æ‚gI8¢EûM´‹€§A:W)všc©ôL&Wïu]ßOe„æþƒ*Sél¡ÝÀeãI!¬ÒÉt¶c™]ÇšL礔c.d>‘–RZéLn6;Vl7çcÉ´‚Ü5®Étv»Q!„œ›&ï4ªS™\8wˆ2–LoÖJ™XBST!N»3Ùün£ŠK¦¹”f.;Þ²úM³wz|j<™Ù¬• U;;9øØnTæs㑸tEÍÆ+åý\"unr®k[åNk.?(À…ÈÅ“š¢¬V ³Ù±ÓãÓåN³k[ç&gó‰ÔRi7Oª…îDÙ2iÄ’Fl±´;“É£¡=RqAž;]UóÉÔ­ýíÉtV¡T†c\›\.íL™]PY,î.ŒM@ ê™Lþæþf>™†èö$\Í„ ôÈó#„851Ý4{ånó¡™ùÙÜø½Í”Ë%R\ æñìÄÌV½lºÎkçOç©«;ëS™<0e"C¤ë>;9»ßª7úÝ×ÍŸšÉæ/o¯%Óð’ÂÀ˜œ]*íy,xãÉs)#veg}67þèüéJ·]h5^;úäØä•uCQß°p!tkûÜÔ, ½ U›Éæ_Ø\žLeÞ¸p¶m™›µÒù™y„Å„s>™Î¦b±ËÛ«g'g×TŒOO]ØXO¦S±x4ÆA-!Ò±ÄD*óÂæÊ\nüM§(uš»ê#³'B”Ѐ³ùq…’+;ëç§O¼~áìRi·çXç&gΣLP@Ìž¼¼½*¤|û™‡ U»°±tvrö-§ج•ËÝæÃ³'À‚{dö_7úÆÞ¦é»ï8ûH.ž|zíöÙ‰°ŽCɇgžÛXÔõç^ƒ1~~}鑹…·ž~ðNq§mõš9pþ<NÏ÷]ûVaëÑgàûÅŸJç²ñäS+7ž]€½ „K"b¦é g¯ín¸w~z>àL!fš† õµs§¾°r+eÄò“ç¦ó'Ï.•výîëæNœ)Tñ{dîdßs®l¯½íôùן8ûìú.Ä7œ4eÄ?·xí5s'ÑšýÈì§ï\-‹ ¦Á—Q!” ‘2b'òŸ¼uéé90'G‡i:;9›Ð'–®¿vþÔÛÏ>¼TÚ­ö:ï8÷È|~ü©•3™|B7¸8˜22´ïÂ{qfb¦ÚëTºí‡fæg2ù;ÅCÕÎOÏ !7k¥ùÜÄɱÉývÝñ½ÓÓI=¶Q-åâIJH4„ñdºØnŒf³c„àªÓ¿¦aªõ;†ªjŠÚPʈu IÓ4¸JBÅ5ÝçÌgALÓÐa~ß*¸9ŒàÃO…ÆlG‘öG{r ÒÑF_Âá=BtV:øº2è8×ðï÷ùðÀEoTd¨ÝˆR)pP+:Þ£_åÙ•NâȽ™9\K« Æaˆ õ;;ñÐÂ`£†˜7ƒ h@? ï\ à[0(08‘af > €h–‰Á 5@à³1<„èw¸J†`ÓÑCÀ.¨T Ljá»È9‡d&`^Žš…\!€Öa1ð¤B‹1&d€Ïààò8,Øõ!Lp!¤¦(ÐF˜"„ר}!„àš> ê(¤"”Œà°ÉË“ †æ‘`ù€[ š¤Xæ½ C¿Cç°ÂC8<0ÎÁ| ª¢Ü=M°-z,PÿŒhà¯+ê YL!çŒsCUÁ[”¢REHÉÃf™àH¦ üJCf¨Úð4 !\èŠJ á‚ 9XŠnà+”ªTB0!TJ¡/Œ°®ªBJ7ð5EQHÄA³+„r!¼À7TâDÒP5Ž(„@PuŸ1MÇ;¾O0ÖUUá>8hF³òƒ<†Lp/bš3"‘„³pÍÀ¢ÒBqÁ¹ŽïÅ4Â8ø{(€ ÑUUÀL$t\;Æ*¥BË÷bš¦Ê8çRÀ,œ›,q4ð¾õ=„PLÓb¨\±q!`­Zž ^¡\pÛ÷âšA 8—R·> ªÀ‰—q®* Á¼ÈãšÎ…°<'®03–çªTÑU5àÜñ½¤nBlß“NhÂtݘ¦©TñYà± ©Ç†0Ürݤ£„8¾Ç…H1@±À96`̼”‡+lŒ°¦(\Óø{œ OÓ YÎMÏIqJ8û'˜€1ªPê±À ü”Ç÷]›×t!¥øºªŒ}Æ„°fz®m¨|qßKÅb“¾ë`Œ’zLHá3¦R…Ø,CÕB=ÇÖÅPµ€3ÓuÒ±%Äg”RW5!eϱâš]Nàeb ŒqϱBãºØ,MQ)!¶çœgâ )eô’úŒ™ž“%`…#„`{a-`Þý®m©Šó辡é O)%œ^º¶× ]US5¨E I1.„¾¤–ç²™ŽmªÓtŸ}×ÉÅ“f0ÒUÑq¬¤nhŠ0ÆɸO Õ%à¬k[Ùx|Íá%ᎡRê¾í¹¹D à”PãzŽ“4bê`ö…®jÃkFás‡"˜\Ûs UÑœÅÃwŸ‹Êg®ª“áíËcdVõ|_×´Ç{ìÇ~ìÇ(¥<¼G¾xùÒÛÞòVÁ9"ƒc*¼ûøýØïï°¶pðm…ÊÀ±*Ä žA ªêûßÿþÿðþƒ¢(!ÆØOþäOþʯü üé8å6\¾Â4Èñzļ>ÌÁ1jàqfÊûaðH³÷¼¤ˆ`ÃÇ•<öòå%¯3†õhü¢ï]kÀØÁ]ÀaSÐñc2D‡Ï£5®*0Ä×°Y":ä‘È€€Pt#ËãmQµŽ,ÆE–öp\ÀL¤| à/á‘—`PÒ° yÄÒ‹!5(d‹`Lè1k’AèHŠ–·82kEc¤„FËc<8™E¡ñ‚Q4¸È|8|Í8lÇB¢-@UŽ‘âƒiЦœb³F ‰ä¬:´ê¢ZÝ_J©)jdhDƒ›k êuø. ØVÂ<Í!•*CñaÜ;ª¢“”B´ˆÃAŒ5ª Ñ`š@¥¬´¡¾"¶55K#ÆHh;'ƒ®ƒRèÁ4Eq> !š28pkÊ —6ÆXWT5EŽÖ¢˜è¡”¢WcÀó·4‚gEÌèª:to00|T`ÑR-46 YYšr‹±¤(´áÛèNth>¡‘/:×ÅT .@ &†ª‘Áp°Ä¡íd(ÿ#ƃ“aLÕÀrO0mì3ð J*¥4ja„cªV…P¬†ë‡†ë“¤1h4ËÐBK6¥4Eb8\ÀÑ.SuX؉€}„!´ÀÁ`Ç@£áJ%”¨ÙFÒÀ°˜Ã'¡cª+P¡4¦éáå€6¾ÈðÞ…o< `}¦c‰ÀÃ#×t˜>U¡ Ck =†Ã>zß UÓU4´¨`¾hð{´õ m›+0¦é” þ »ÈS†V€„n€x'ý&!fÂ~uEUé`öº>˜\J³ñ$:`‡ ØPèк=xIû'¨k(<¥£ÐZ RÔE¥ Ðcbš#"˜$t]Ùb»Úà­8¼E‡Kîý^7•ÒHbª2H{?xØì¦c5ÜÈÐ=Làß&>áCr4tȽ¾Úúp£#|ÔÍçEu¤A¿÷n ½j4@¼Êc¾[Ÿ8Œd‰*Hc„ÐpD &MR$¢`ÈñâÁ/`µy, ˜ðÀ çl\p° ƒé‚pÎÅ¢g}Bˆg`hq_H¡P*²=W¡”` XUœžF`W°=WST!…é¹ph8ë».RSŸ3Û÷tUÅ›ž+¤P… Ñwì'뮪Žï÷];àΈ}׎izÀYǶ\æÃîß¶L]UÂÛ„¼BiÛ6a_ 8ïØ&œÕú®í>X›fOUJ¨ø]ÇJè€XÁ¶!¤¬÷»qM—RÔÍ®éÚ*UT ˆW¢RÅ ‚¦ÙKÅâ êýŽå¹1U3=§ÑïV®ÖïtlK!¯cMQf¯iö$’1MoY¦í{ ÝèØf­×83T½Úë´¬>|«ÊÝ–"¦é ³WëuàzºÔiµ-ÓPU7ðKí†ø€º-vš¹DÒ üB»Þsí„ntl«ÔiœÇ4­ÐnÔÍ®®¨>gû­ºå9)#VíwÊ&¼É{ÍjË2cš¦*Êf½l¨š¦({ÍZµ×!„Ä4}¯U 8OèF¹Û*¶\ˆ˜ªí4ªõ^7¦éŽïm7*–ç¦c±B»Qê´B ÝØoÕmÏKÅâÕ^{·Yó9KhÆN½Rî¶TªÄ4}£VR&tà ‚õZ1ŸHœ¯×Š~7®ëº¢.—÷uE5T­mõw›µ‰t¶çØëÕBÓêgã „ÐRy~Y­*ÝVLÕ M[*íBâš¾Y/ï¶j¡t,¾]¯ô\+—H;ÍZÉñ½|2]ëwöÕÉL®eö—Ëû-«ŸO¤ö[upc×íNq·Üi¦cñŽc.—öz®3‘Ê´¬þzµ8ÉaŒW+Ës³ñäN£ºV)‚'ôØâö~³ž4b¦ëÜ*l·ms*í¹öâî\nÜt[û[¥N3ŸHÕzÛÅ'ð3ñÄÂöV£¢)JÒˆÝÞßö9ËÆ«•Ârynدïmì5ë)#Óô«Ûk1]iúÍý­µjAWU)Ñ•õr§5žÌìµj· ÛnàO¤²{­úV½<›C]ÛY#˜¤ŒØ­ÂöRi¬’—·W÷[µ±dºÜm]ßÝè»Ît&_î¶‹» c“õ^çÊöZ¥×žLgת…›{[0e·V¶åt,×gÖnÇ4=iÄêýÎÕÝùI‚ñ­ý­žc§2nà?»¶8žJ몶Ө.—÷Æ& ­ÆÅ­•z¯3Ÿï»Îs닧Ƨ-Ïyn}i«^K¦ U}bùz>‘2Tíù¥¥Òž¦(¹Dò¹õEŸ³±dúÆÞæÕuÓ™Üj¥°Ó¨ÎåÆ#Äkʈ?¿±t«°1Oe^Ø\î:ÖT&çÁK×ÇS阦oÕˋœãS{ÍÚÓ«·ËæÉ±IÓuž\¾q"?¡*ÊÕµb»5Ÿ_.í=»¾Øµ­éLî¹õ;×÷¶tEÉ'R_\½íøþd:kzîgî\YÈOrÁ?¿x}±´;‘ÊTû'—oÔz33õ~÷éµÛg'g ÆÏo,6ÌÞlvìÆÞæ3k·-Ï™Hež\¾~c+Oõ\û³w®ÛÓãÓ¦ë|æÎÕ33 ¥—¶VvšÕ“ãSwŠ;O­ÜlYýÙÜØSË·.m­¤Œ˜ÏÙ'o]ÚªWò\ˆOÞ¼xblRWÔ{›‹Åݳ“³+åýÏ.^-w[ ùÉgVo=·¾ˆ ™Î俸z«Ôi-ŒM^ÛÝxrùFÛ6OOL/—ö.n­œŸ9±Y+êöåFåÜälÇ2?qã…sSs*¥/l.¯WŠg&gn¶?sçJ¥Û~`jn«^yrùÆ#³'1ÆŸ½s¥iõOä'ž]¿óäò ËuOML_Ûݸº³þÐ̉åÒÞ_ߺ¸ßjœŸž/wÚuã…‡f(!_X¹¹Û¬ž˜¾¸µòéÛWz®=›ûÄ.l,å“)ÓuþâÊ3›µòÓs=Çú‹+O?8=¯)Êó‹w ;NÏ_ÛYüÆ ånë¡™[õʧn_zÝü)‚ɧn]jÛÖ‰üÄVn~êöe˜²?¿üÌ ›ËÓ™|µÛùÓK_ØkV™=Yé¶ÿìòÓo:y®ÞïþÙ¥§oìožŸºSÜýèÕgÚ–yblòcWž}zõöX"mºÎ¿ðäFµøÐ̉¾ë|øùÏŸŸ>¡«ê³k·ïwÏOÏ_ÚZýØÕg‹íÆkæNm7*ÿýÚso>õ@¡Õøè•gV+ûg&fnìo~öÎ5ÓuNO-•ön¶ÏNÎlÖJO-߬vۧƧºŽõôê­…ñ)…Òk»M³;É3ΟÛXLÇqM¼ü\n¼ÑïÞÜßjZ½±dz·YÛ¨¹àÙxr¿Uoš=Øg¶êeÛ÷Ò±øn£êS|áùçŸøìçH˜ !ô¾ç?xú !¤ëX=dž#J­×ÁiŠÚ¶Í®k#„tU빶Ϙ¡j¡®m*„‚áÖö}]UÎ,Ïc‚+`ÒP]¼À'˜$|Ht€x¥xÙTå‰'žxöÙgáœ#„øº¯ûºoþæo¾ñY¡Ñmñ+JÇÂ#Ž*—¡éàˆ3Œƒ$%žÁY º<Ê‚\uÁ‡›A.œ ®ðøMzŒ1ĵÒ… pgÃÞêšRhT Vò`$‡9v‚ï™ßË <±˜¦3Á™àøÀøt€°CCfd§Õ ¼¸¦s)| ‹.²}OSTJ¨ãûáu*LkLÓlÏ;ܬ‚û ø†0œp!kºÜCAˆ#p¨²<—`Ótˆ¶%²K¨j¨ª(Û´=/›HzAжúᔪaÌ8w|/ŸLAS2„–ö+ŸHŒ5Íž"O@ )ˆÝ'¤0=g<•±}P“I#Ö²úÛÌ%R,ŒK–ð¶Õiº¦¨õ~âG¸¾_ëuB¹x²iõZf?Ob„«½ìk€ªÓ-¦éM³‡Âkâ¾kûœM¤2Í~!$„DRr!ºŽ5É›žSî¶(&éx¼ÖëÔÍîD*#¤(uZ.ó§2¹F¿ Y"„àfû^©Ó”HŽ%ÓÕ^ ÖöàÆ8'„Ôû]CÑRF¼Öm#„˜àIh .d«Ýv.‘Ò¨Rïw Áç@¿æ“i€p³}·ïØóÙñJ§³+¡Úm-ä'º®í>F˜ P¨©T–²Û¨vlëD~¢aöv›Õ¸¦ç©½f­ÜiÈOؾÛs¬Á…,B!ƹ”HHQíµOŽOµ,s»QQ‰2•Éí5kû­ú|n<à¼aö&pÁ]h×SF<Kl×Ë•nëÔøTßu6ke)щüÄ^³C@ùŒÕûÝs“³µ^g½ZŒkúx2ÎÆm«oy™ýV}³VšHeº¾^-Ôz§çk½œÙ‚0.ü,Ïm[ýóÓóÅvc­RÈÄ“¹Dj­Z(¶NÏ·­~ßµ1ÆðâoÔJ3Ù¼Bèri¯iöš]¨tÛK¥Ý˜¦O¥s›µ2ð o„ô‹$²•ùQ,C) Àzµxfb:à¬ØiRB\@.ít,žO¤6ªE¸Ö¤˜”;-'ðœž[¯£±ø,(´¯?qf¿Yƒ XQì=8Ç6Í^Ç6_;wjqÁÃ)“ DåbR.—÷œžãBì5ë”R7"qÁú\­_âLϵ¯í®{,xxöÄbi/ã †¢ ¥µ’®ª'Ǧnîo­”÷_;wÚòœR»AÃ[Ÿ¤@­U o>õ@£ß»²½F0ypjîÖþÖíÂöó'¸ÛJt‘ÌÀk¾XÜ}ãÉs=×¾´µê1ÿu'Nß.ì\ßÝ8;1£«êZµQ–ä °"‰ÝÜßzôÄ™€³¶–;¶õ–ÓÞÞ߆!À‹;o?óP¡Uï9vä¨p}oã‘Ù)ÑFµ¤Pê>0Ã`à7ö6Þzú|ÃìUº-Jp[ÀcD2àlµRøú^³V-º/ÃÀœWvÖÞ°pÎôœ­zE!Ä9¨Å`Œ· Ûï<÷H¹Ûzf펔ò g¯î¬_ÜZyíüI„ÐJy_¥ŠíÆ0óxewýç©õ:ÅvnÀá“2äB,•öþÖC¯ßiV¿°r3¦j¯;uacéòöê[OŸ7=w­RPµ=—`|y{\l¿°zk±¸ó ç­öÚO,]çR¼õôù‹[+Ïm,¾aá BèvaG¥Ší{0MpŠº´µò®ó¯«÷»»ªB(Üœ^Þ^=51‰%ž]¿³U+ýl7*àl±!ïw™;é±`¯U£„º,€!°pK„¢ÀŸBŠ@p„Ðn³6“É+DÙªW:¶yz|ºÞïÂ÷äYíµg2ù€ób»és6KYbˆ†aïÑïðyeœ{A6âðyކp05/ÀLè>ç\STÎ9FU÷•*R".Äa%ìK²è ò èݰëÚ+Nw©t_2TänÈQÇ{!Ñð‹öÝ"A³' Õ“è>ôßá†È™a8• Ý–ïD:RÀ7;ž!$%FpÃt:xÈ|—«f„d÷¾@V/`L0¹ü3\+І×p€††Ì ¸•.,®9@„„1øÿуk܃`0ð”xÐø¥Ü«b6"ÜRL&bàë@x¹E®~ !Ì~àw(!ƒfÑà’ I) ”Ѓ!„öf¸÷„ ãpÌ‚7pƒÃ«„F“©ïàË CP("Tºòƒ(„(!3\¾DÀ‡,„à “áûŒ±cveÞ˃R×RR‚ç`¢!ºì»r¶' ¥èn.Ä!T&м$¥”U0BŒsJ)’RªT¡0¹á¹ ¥ ¥LpbÃ1Î#O¾hÍ)0Fº¢"<ˆ[¡REé"\¼J)ÁQÌä!]QLÓÁp;XŸ`äf‚«”‚ÛÖàÎc. ¯öÀˆžga]QBç*¥ª¢Dþ©‘<!-»+:éãÐQAJùFÎ|0F…C³„`ŒÀs\WT>$s)1Bºª 0>ð€;k.8X»K"¼„·)ºËƒËa!¥®hà ˆ‡\)p蘗†àšvˆ™°¸*¥º¢‚ £¡j”PzÓ†â(b¸NúŒ)”ªF UƒyÄGˆ[L`¼1M£˜€G]LÕ@75TM£ œ|††@¢Ý#¦j ¡^PBbª>$O†ƒ˜¦áÐùȪ º»‡¢‹k:x.b|€™#áFè îo\ˆ˜¦)Q³CÈ€A>u‰âšN0w´¸n@Dª˜ªÃZÅÑpJI8F)eä[I†öRBÅ„ ŽLèFÈñ}MQÀÓŸ ×t…ÐáZ红ªæ3ˆ7‚‰ã{*UâºÎ‹kgfðP_0M‰pc€×  1ÃÃ-z`—2`)†^æ‘dŽó;zI)… ®¤Ñ`ÃáçÁÅœØéñ_໿áƒï`ô¡^;ä t¤¾D’„>0‘ Á"ûþ€— WËwî(Ý¥ÒE Ö7[ä̓"ðóa¶\%@ … ˆóè“ú<… (!á@0‚á[8°ê6 ˆÊ8á÷Éç,xÅgC³ WìÇFBâ|(t„O¿QŸ3]UU…‚õkàj0çlÈúwÜ®«*„êÖ¨"Â:pí[4%ÔUKay®zœš„°ýè±Í‹‘í3®¦ç‚Ç4š… ÂçÌôœ¸f ¸’ÑÀ%B(¡Çlßu|?KèŠÚ²ú”Ðl<pµ(L¡¡*ŠB•F¿ ·À" ˜ÐŒ¦ÙÃç“)!dÓì'õ £1QB E­õ:º¢æ“)7ð;¶™'RF¬av%’ ÍaܦL,ÑwÛwóÉtLӪݶBèD*pÖ0»Ùx2O4̘ßTJËÝVLÓÇSËszŽ Aƒ%’\Jà¡Òmeb „‚ ¡P×ôb§¡+êd:ë~Ëì%SÙx²Ümq!¦3y‚I¡ÝÔ’’K‰1Nñýv]!t&“8«vÛc‰BˆK€ˆäcÉtßµ›V,™\B̬ñT¦ÖïÚž;–HÁwˆ ‘O¦œÀƒPÃ!!$ø§kŠºÛ¬Ô—‹KC6žÜª—uEkã´‡ÉT¶Øn8¾w"?a¨Úv£’2b'òãÛªvÛs¹ñ±dz«^&˜db‰È°RD#OnÔJ1M?9>i¹Î~«>—›Îä¶&D>™baò’™L®ÑïÖz…üd.žÚ¬•Tªœž˜öX°]/O§s p&„¡jI=¶\ÞK‰33-«_ê4g²y-<—HŒW+û“éìɱÉB»Ù´ú§'¦Ó±Äbq®h!oÇ€[!ÎSFÜPµÅâîX2}fb¦Òm—;Í33ã©ÌbqÇP´l<ˆMèD~b§Qí;öƒÓs ݸ]ØNÇâNÍ5Íþ^³6Ÿ›@ƒ‹‚Á4±ƒøpa²(Z[4ŸŸX.ïûœOgòg\ !ÄÂØd­×)ušÌ¸Êä…·‹;'ò(ÌçSµl"ueg-ŸLC°±á°^c©¬ª(Ww6 ÆrÀ9§ à ƒ¹ã!tjlêNqÛ ‚¹ü8㜠.Ã!€ùg>7~y{•òè‰3ç7÷·NO£!3žD¼_NOµ,s¥²ÿÐô‰“ãSWwÖ¤”3Ù|À8äBøœQBf³c6–cšö¦“çúŽ}këüôüƒÓó×w7a)‚e.âÌ?§Æ§/l,cŒß|ꀳËÛ«g&g^3wòNq§iöNOGùW†k›š½´½êÁ[OŸ§„<·¾ùœBNä'ž^»‰%r‰”ÏÀ$žŸž¿º³ÑwÓãÓ>cìðBç&gŸ^»­)Ê\nÜ .b¶ù,ÐUm&;öù¥ëSélB7<3Íœ¸°±Ä…8=>å³€Ezƒ| §Æ§ž\¾×ôwœ}¸ïÚϯ/=2»ðè‰3—¶W{®ýÀÔœÇãvãð=8=ÿäòuMQÆ&½ `<â–Øb.7þéÛ—ó‰ôß|ðµµ^ç…­•7-œ{ÍÜ©§Wo3ÁÏNÎx,€1>:z½V\©ì¿ãÜ# c“Ÿ¹s%¦ißpþQÓu¾¸rëuó§ß|êç6»ŽõðÌ‚ÏXÀ¯ô…zhfá3w® ^í`0ð×ΟZ,îÚ·~h*}rùf>‘J1Ÿ3˜²Ó3×ö6ÎçsããÃòŒ‚²¡ð|°¥ä÷ZuÓsNOÇTm£ZLqJàT)BùD²ÐjÀRDUœ~ä´zð¡<ø(]¾I)/ÚµMðŒºœ;—N"4Á\…v`¾Uàƒ“3ç Ã kÇÚ¡B Ë¡2Q¢)ü%šèäPò È&upùy|(þWHVT>æ÷»òÃîó!ç`UâÈC! ð„ƒ=+üý ?æ!ã ~gœW€³¡‡Q³ÁA-Æ8ƒ‡>cP€s3ì ;è+ˆjàœG|ÆÀø,„ðY5åAX ¬%Dô0®À ã<*à>àBxCMyµ¼À‡fç^àGµ¼ €ZŒj¹þAܽB¿> 5&„p|ú s|j¹!3' šõßñ=¨e{.´ÍB-Ȩâ²<Zðßö\X9¶ç·g–ëÀœº¾7ÜlØW`¹NÔ¬ ú2]†ãú> ð„¦ë@³> L×1:¾@Œó¾k3nà›a³¶çFÍFÌØž;Ü,ÔòY`¹¼_¦ëØžc„TTÐ4+„°"f‚ çXlÐì`ŒŒó®mè¼À‡f…=džf!ÉŒÑrݾcC_]Û‚áø,è;6 Áò\h6`¬c™Ð¬í¹=Ûfº¶ |ôÞ;cC³Œó¶Õ‡f{^Ç6EX ªÕ¶ú Óu W•”²ç †àø^ÛêƒÀ»¶ÍÂ=>ÈÖñ½žcGµ` ŽÃ{¶Í2ΛfÖëû]ÛfÚVßtXÍ~úí9vÇ2At˃×A4˜G# Áñ=Èp%„hš=hÖg¬e†Ð±Mh– Ñ2ûЗå¼T¡€í¹ÐW­×ð\‚¢mö]߃Y¨õ:0û]Û‚¾`ŒÑ4EC¨÷» :Ÿ±F¿ K±çX=ÇyÖºmè×tZ¯ ÜF’aœAÎ()e×6!©ç¼ÚmCpՆРû*wZ0Ñ=ǪvÛ°fªÝ6ôë³ ÞïF“ Ü2ÎÊ–åºRʾkW:-à¶Öë´­>p[ïuAà}Çn™=`¦ÜiA¿–ç–ÚMà¶mõaF|Û xL×!!*ÝôëAµÛæyš±†qVl7`Œ–çÖ{˜ý¦ÙëÚ& ¼ÐªGcŒ$Sj7`Œ®ïU»mLËêÃ|ZuX?Ë,µP ÔnB7ð+ÝŒ± œq^hÕamÏ­tZfú]Xnàï5kÀLÓì•Ú øŠZu£ë{åN^í¶«Ý60³×¨ÂFѶÌB«ÎBÛ¦ÙƒfKí&Dîh[}`&`l¯Yƒ1Zž[î´ ÙJ·¼À‡c$äɯõÚ0/šf –¢ÝwQ´Ïxí !º¶â‚&×ñ=X´àª/©í8RÊßú­ßB 'N}áÒÅè; %…^D/7üä Iá¬}Ö9çAxáw\k„Aø¾=<¬™ 4+ß÷¥”?õS?…R@¯?ù“? bŒù¾)!Ð#<š’÷¦#U†U)hùØvŽ"!\`ÊC÷ÁCh^qOîÆuJyÏþÐÃÃÿÄÇ„áè¸t¿ÇFZ=\£0üÌ]ÜÞÓÔ)íë%)dònùXŽeûˆîÅíKrx¯vŽ–ºI|‘vŽÌã0îø%k+„—äý–<žÃ{Ëá%gäÅ%öås~÷<~©]|I}+™‘ÆËõýô{?szì²¶¿Tfн×ñ²½ºŸU÷â¯ö=>µ¿ !ÜO•Ù¿ÔöÅߦH(Šu¯[ä*þ’}ÝÿØïõ²©B>vfïóþë‹ñ~¸ý’6Àûø‹ ÷näKÚÃ_²Ö‹sË8Sõ·û·ôGt8ˆÉµk×ÞøÆ7rÎá𒜀2uÁݲ¬ t]ÇãÑC)% AÁèðô"AL<ÏÓu¦Æ¶m×u ÈÇãð„óÁõ}´I>Ê2Ï9 !ÿA˜¦‰1N$‡Yà)¥Ñ28Šx=~ß =‡@$×( >U!HáŠäñ WÑ P nÙ!ò!Q£``pa¶.$!$à,[ðXÀ¥P•¹A(W7˜à„ˆÆ(W.„Ë‚(’\½ )mߣ„@@ ˆ9 HAæxàxaú®Ï™F•€sÓs¥”*¥–ç:G1V(í»ŽRUÇ÷,Ï•iŠbûÄ+B¨ëX”P…RÓuLÏ%„¨Té¹6D)ƒ´ÖKÉ |Ës!@WÛ6Q6¹c™1MçR´í> m}´¬>BWÕ¶mö›¢*JËê )tEí9VÛ2ÁÓÅôÓsãº!¥¬÷»àðÔ²úmÛT%˜ÔzË÷⚆ªt[ºª)”šžÛ±Í¤ÃW»m„1\Ë‚›¼Bi¥Ûî¹6„(ušš¢ªT©õ:M³¯Pª«j¥Ûb‚Ç4½eõ«½BHSÔR·Õ¶Ì¸®{,(¶. RFÜñ½r§•‰%ΊíF×µ’z¬ïÚÅNSÓôR§Ù0»ºªjŠºßªI„cšæ±`¿UƒWµ^Â_ )v5]Q4E-´•^[¥Š¡iû­:Äv8ßn”“zL¡´Þﶬ~&žÀoÕË-¬ØnÛ ˜‘­z¹mõÓñDÛ¶¶.DÒ0vµr§e¨š¡j›!âµØiî6kWi£Zª÷;I#¦*ÊJy_S]ÕZV¯YOelß[«Û¶™‹'kýÎF­,‘LèúzµXê4SFÜñý•ʾ幹Dj¿YÛj”S²]¯ô\;OVzm€¦¦øz­¸ß¬šÓô•ò>‘¢”î·êµ~g,™®÷;Ëå=ËsÇñZ+Mgr}×¹SÜi˜Ý±d¦Òm-•ö„”)#~§¸»×¬fâ Û÷nîoõ]{,™ÞªWÖ*EBp:–ج•ÚV,™RÜØÛJ1]Õª½öf½4ÉcŒïv<dâ‰Ízy©´‹1ŽkÆýÍýV=Kèªv}wCSÔ¸n4ÍÞRio&;F0^*îö{,™vÿêÎÚx2C¾¾·¹Y/gãI;ð.o­vk*]­îv&ÙDrµR¨õ:“élÀùÅÍål·xm>7Ž~jåæbqw:“kZýÏ/^kY½ùüÄåíÕ6W4EK¦ŸßXj˜½™lÞcÁ§o_†¸Ç«•­Âö™‰Œñç—®q!ÆS™¶ÕrùÆÉñ)…Ы۫»ÍÚ‰±I.Å'o^JÇâ©Xü +·.n­dãI.Å'o^ÜiTOO-•vŸXºp>›»¹·¹\Ún?yó"%$ŸLÛ'—o<<»Ð±­OÞº´V)Ìç'JÿòÚó3Ù¼®ªŸ¹}åÒöêD*kùÞã×/ì·ç&g[Vÿ“7/Ÿ9aÞ_ݸx»¸3“ÍÇuããמË%’¤÷Ùõ;¹DRJôñkÏnÔJg&fnvþúÖ%!ÄD:ó‰¯ì¬M¤2éXü¿_{^WÕ|"Uh5>sçʃÓó”§×nï6«§Æ§oîoýÕÍlß›ËòæÅç×s‰d.‘úĘ“éì3kw>sç²”h.?~aci±¸ûÀÔüO/}1—Hfâ‰ÍZé3w®¾îÄéj·ýç—Ÿ^­˜šóûÈÅ'OŽM~üÂæÊ#³ ›µòŸ_~ºØn<<»Pî´>~í¹‡fJŸZ¹¹ßªŸŸvÿ/<9—OèÆÇ®>ûÔÊÍ©tÎ ü?ºðÄV½üàôüs‹yíyJèX2õ‘‹O]ÜZ931½Û¬ýñ O6ÍÞÙÉÙOݺôù¥ë ]ŸLçþúÖ¥®cÍ寝ì¬}öÎU'òË¥½;…íÓ3…VýóK7f÷D~âÆÞæåíU]Õ U{fýÎn£6É•»­ËÛkg¹Úm¯U‹³Ù±ŽmÞÜßj[ý‰TÖçìva{<™­–÷«½v:–°|w½Zò˜ŸŽ%ö›5Ÿâ‹.|þ3Ÿ=„xý'ßõÀ©3BÊZ¯Óq,ðì„DáqMï:v×1)&”жm:¯«šÏYϱ’*¡>窢Ôëõ?üÃ?üùÿïþçþ?þÇÿø¿ñøÀ>üá_ºt rêôiMU9çà£AüKùëѱˆ×·½ýíÿïÿ}„ÐÅ‹ÿŸÿôŸ~úßþÛ_ø…_øµ_ûµÇ{ìOÿôO———'''çææ"…òˆV)èœsEQºÝîïþîïþôOÿôÏýÜÏýò/ÿòoþæoþÎïüÎã?¾¶¶–H$fgg•(ˆ„¤¹Ku=ìnvXg<ô$Šo¤?“¡‡>ü.þËô òòð…6è’ òòA ´€sðЂC¸h8‡Jg”hRÊÐÃIF,‰ƒRzq¹A R… î>ãBWT spubEú<@¾µÉ |ˆ³÷Õ Us?¦jrq#+ˆ Q¥ ÿ ©CfxHåá];B™ÚoÕs‰”ÏXáÊ#‚Â÷šõéL¾Òm÷]FŠÚoÖRF,àl§Qé;ölv¬ÖïúŒ!$ó‰Ôn£Ê…˜Le»ŽµU/wk.7¶×ªÍåÆÎåÀyK˜ a-]¤„8+wZ c“ånÓô…Ò¸ªo7ªž8 A…`†`†, „àÜUê´Î&R™ÍZYH>•ɵmsµRhYý“ãS[ÊÉñ)Ê ÓoûÁ¸Úk›®3—[¯§29pB8+´êg&f í†é9”„žX¯ßrúAÛ÷À‰ á„H:ùBLJiû^¸Õ0€7®”÷çrc•n»Ôi¦c ¸3Bù¡Ï™”Èö\>h–GÍ‚—¼bõ\ „–J{§'¦wšÕZ¯ù7áa&–8¿µ¿Õ¶­§ç÷šµ€3Ÿ±ÙìØÂ6Bh!?Yî´ö›5ðæT½]Ù1TU¡Ê½­¾ë<8=¿^-|X–BJÓu(¡ëÕ¢”r*½¾·é3vvr¶Ôn^ÛY¯õ»NÏÝÚß~`jÎ ‚èxo†côY0€"dy.ÌÂtct€&–¨ï:“R»Ù0»LÍÞÜÛÔU R6_Ú^­vÛ¯?u{ûõ'Î0!"nͰY&8àîoîoæâÉ€ó;…íwœ{¤ëX ¡›µ²éºg&f¯ì¬!„NML—ÚõZq*ë:–Bé]U3jâúîÆ7¾æM=Ç&˜Ûj¯óÈìÂÕ CÕf²c¦ç<¿±TíµßpâìZ¥`z.ÆèD~âÒÖêw¼éàSÌôöÛsFpy{õ gWÊûŒ Ç÷˜ž»°¹|zbÆô!…í{Kå½·ž:ykõ­g΃»3¬™žc”Î!àÀ…¥™l¾ãØ×÷6ß|ò\Ƕ@ànXžƒzfýÎ#³ k•Âzµ˜Ž%:Ž5H&îyõ îv)!«•BË2_3wê¹%JðÙÉ™j¯óäòB»ñ¶3Ý*lÕ{µóÔÊ;ë¼éä¹µjñóK׫½ÎÎ>·±ôš¹S£!tkû-§¸¾·ùÆ…s\ € ^ßÛ<=1Uëu®ínÔûݦç6j%È9D0Y*íÚ¾wz|z·Y=íMËp#ÚnTò‰”é9•nk2•uŸRî¶FIÍ(¶ëLˆñTºçØ¥vÓñ½9cÀ0ÁFgº"®ém»Žk†ÏƒŽmù,Hè†å{>gqÊt³åøž¡¨BðŸþÙ_ø_ýµ^¯w¤åJ¥rûöí}èCoxãÿëý¯oyó›]×W4í8åå(º^(ÞûÞ÷>óÌ3GþT*•._¾üë¿þëÿä{¿÷?ÿçÿ<1>Î9àK¡(ÊÇ>ö±ýÑ­ÕjÃVÌF£±½½ýä“Oþâ/þâÞð†Ÿø‰Ÿxï{ßÙí›+ïaø<þ’ânkáᢑw Ä™â3±úB¶ð[ˆÀ‰òÓbë óˆ†À‰\]ÑÀ!Ót ‰¢©b¨*¸“ÇTM¥‚Y`1U'`ô°Ç•Ò*?† ú„傲&`Œá¬qäuEõ‚@0ãkŠÓtŸ3&x\×!¨Å$®Ø…’0/Fä¸7„ÑØ¸À'uIä¡h1M C°ÍÙw€I¤˜Â!MSÔ„nøœœ'4]¥Ô ÑSÉ`Г †XŸ±pà¡ÀIÄÌ hð°d¦ ÄÊ&$ òt,9ÀŽ 8K±¸®C6ˆL,AŒ)#î3æs–‰Åá JÂø®“#¡ fb‰JI"$.PŒ¥c¨¥%¸øQvAÓsB2±,{J H¦sDC°M„BhV¡4ж=-F ¥cU3ñdÀ¤mˆë(p¹x! ŒhFJ3‚±:Hm¤ŒxR7àm‚]Ñc¡i¹D |7ðsñDLÓ½ aDhIÝHñ¨!Ø ˆÕç³ÀöÝl,‘Ôc Rç“)„é: Ý€‹ƒ¾ÂKº(ò6 “¾H‰ÆiJhϵcšžO¤`OS ¥„ú, ˜Œ§Ò‰A" q€‘J•ƒ1 2±DR7\ßÇ«ô ;× K¦5UuŸ`Wè@t8ø†ªŽ'Ó^8¾—O¤ãšÑul‚ÉD*ƒê¹vʈç)ÓsÎÆSªm»¯)êX2͹@©T °É|2M0öy ¢„ï íL×QÍÄRJ'ðºÓ4Ç÷…”)# 7"P + 7Æ™FU]Ñào¨šBˆÏJˆv܇JˆJéÕG)€…1Æ Q”RŸI„º¦õûýwÛ·ÿüÏü¬iš”RJiR6(xxãúõwýÍ¿ùÄO$ŒÁ+‡Š‚öã?þÆ7¾ñ™gž!„(Šr¤Yxò'ùÈÛßö¶ÅÅE¸GŽ4ø/èyüàßóž÷Ôj5à-b HQŒñ­[·~ðð‡ø‡BpG|_9^½ä¾û!9H}‰…0ð|(ObX¸©`˜0Ñ¡RÊ@px½gƒ@w!žC!”p/ܪBÅùX;à¡nqHü*„€Nà)”èªêâUQJ 0OLÕ…”ŽïiƒXÕ,ˆËs)¥Qr°H22 ýoºÔGþ>Ï9xzÀ¡”RÆTÍ |Û÷⺮Qp)ÃàBôËPÕ°-±ô:–i…ì}naŒ¸mõ UM1ËsœÀkºDòÀ6ˆ†CûH!…¦(”f¿«Q%OØžÛw€ÄJ)…qMR4­>¤©åä2Õ¨RëuUª@0á¶m¦cñ„n4ú]!e|ñš2â}Ç6]7—HêªZíµ &cÉ4x|§ŒØ/£b˜Ã§"iBÊJ¯ k‰0&"W„€“bÀy=¡cÉtË4»Ž5‘ÎÆ5½ÐjŒ§29Ÿµ^âC´0CÕ4EÝkÖ UÌd»¶Ù´úðMЬ­"´•æ©Z¿Ós¬™LÎPµÝFUU”™LÞôœJ§=‘ÊäÉýVÃcÁlv c¼×ªPŒqÚˆo7*á¹Ü¸ãû…V=ŸH¡A€®ÁFÀ„@‘%Rpèw»^FH¦c @!„ÆS™J·Õ¶ÌùüxB×·je]UOä'z®½ßªO¥s©ìv£ê>\nT‹ÙX#p>°(ËAd;ØDØô/à,¦i1U])ï'tãÔødÓìÛÉtv˜Û¶ µ¶a)!Õd*kzÎV½<›ÍOgr›õ²ëûp»·TÜËÅ“ ô³!‹2ã|<•ñ8[-&S‚L U‹iúíÂvB7ÎMÎÖÍîn³6“CA>.t$.]ˆ™•ƒ‡`›3™üriÏõý©tv€‘ŒET ø ~›"`<|L¥Ï™Bh*“¿¹¿ÅŸLç‚0$Û‰üÄv½\ê4ÏOŸÈÆWvÖTª<2»Ðs¬ÅÒîÉñ©…üä­ÂŽí»³Ù±€s8,ŒMÛÍízå¡™ùÉTöòöÅd<™8cCqþÂ1Ê€1Æù‰±Éz¿»RÞ{`rv>7~uwÝ ü×ÍŸF]Þ^›ÍäB> ÂhvÈ?$oЬÏ#S¥„ ¬Ñ,Àš ó›Íœ]ÞZ]›::K<»¶˜'ãšLÑT ¨Ì³“3ëÕÂn³zzb ìåg ù‰¾k_Þ^;75w~úÄ•õ®m-ŒM(Mqf|f¯Y_.F,ð6Ÿ 8v}ñÔøôkçNÝ,lZõ7<—%¾°r3‹¿éÔ¹R§ycoóÌÄ A ˜ ¢pwnàLf²ù'WnhŠò¶Ó¶móÂÆ2Ôòó?O&Øç¯M¥óšÀp‹¼¡fÁpûÐô‰›û[…VãÁé9ˆ®/Ã[,0q=05ûôêm7ðOOƒ+Ñ`rÙ@à!@³™˜6=÷©•›ç§ç_7æùÅz¿ýÎsÄ5ýS·/%Óo?óÐv½re{ýM'Ï™˜ùÜâµ€³o8ÿ¨Ï‚'–®ŸŸB¹Ì‡ÈmãÉÌSË7R±xʈ{AàÖêäõ½MÓs_;š`|ug=ŸH=05·ßªÛͳ“³¹xòvqG!.O`!ADqËsÇSi.z Æ’éžkW{í‰T&KÚ &ÄT&'¤¬¸ý#9ÜQ—.¡‚ù'u#®ëÇ 8OÅâã®cªŠ×u'ðá“§jù.Bè½ïý¾'žxŒ[ Šá0d(aŒ1P­Çùîïþîõ MU¼§cÀ4-//7›M8D À¾#%`EÙÞÞþÖoýÖýý}J)„ JJé /¼ðc?öc I‡ C/µZír€xð!¿¦zäwy7v5üývU‚¦F 0¤¾ç‡}õ›Ý…ëS<0Ðwì¨Ù4•±žm·¶çö]æ1B/ŒERÓu™i§€ ¼È”õ;™€QBˆ¾cû8Ñ2¸‡ÉDRÇ÷"j§r}¯eöÙ`pÀl™=àÖr¶Õ‡yì…¸NÀB¿=ÇŠ@‘]ÛòPJÿÒhõCÀ`Ðèw¡_@ö–ªÙ@)ß«÷;ôŒÕ{hf7†…ö¡ÉÚV$cº`Êgµ^¦Ìõ}€Ý !šýnˆô«Ý6H©k[~˜©õ:¯Úm3=Ûê…Ã`z€z“R¶-3B¹Ó„1¶Ì> ¡@S߃¾¤”ËŒšõ^'‚àUºmØXʈÑtR»Ívl†ÜFK&ÌcËìÚÎöܽØìw+Ý ¡ÊÓñ½Z¯-Bô"ô0Ví¶ÓäÚõ^ÞÁb»1Œ^„ö€Á+ÝŒÑr@ƒJ)ë¡<}”;Ìc×¶ýì'{ÍÌø˜Š)Yí¶àáN½²mô»©˜s¾×¬5û=¸s/µ¯tZŠô‚`»^áXž—RV»mX«cÅVæ±Úmï7k°»îÔ+0§]Ûܪ•¡@­×¤$ 4aŒ]ÛªtÍ–;ÍBÓ÷ ­l~w :Î ­:¼zM³·Y+Á†¼Û¨–;-)¥å¹ë•bTšBZ©é:ûÍ,û½f­ÐªÃ ßoÖ`׺íÍZ ¾)›µ?mÏÝmTAà…V}·Q…f÷›5xqýîz¥¶êåb»}­”ö`ÊJíæf­ýî7ÐTÓuvÕÀ»­J8MË¥=mµÛ^« @¡U‡åѵ­¥â.Ìc½×ibœo‡“Û³­zf³ZÚoÖaÍlÕJ0oö»{ÍÌÝJiú5]g«V†!”;f|Æ6k%x÷+ÖriU¯”÷At]ÛºS؆~wÕõJÖÌÂN­×‹;ð [ @¼Zž»ZÞ‡7«m™0MŒóF–Gß±wê¨Ué¶"øm¡U‡¾lÏ…’Bˆz¯Ó —b+ÄÉvm ÄÅ8o™=˜¦¾mI)?ð Ãˆ×ç.¾«ë®èƒ¯Œå¹ƒ …2oµÛÓSS ÆÑ»4E HÇgµúOÿi¤EjŒç{rñU$CÙ ´y%RQB÷ïþÝa-KàÖïüÎï<2XJéùóçßþö·Ÿ _ª¸^Æòx‘a¾²c|ñZǾÿf_ÞBºkQÉ$~¯.^½i:²ïSÑæyŸ›ÃðNøªÎþKÖºŸ—ôå­™—±+¾Jc|ÙÓôj¿nÿ~w ¼8âõŇý.¥$„ôûýóçÏ—ËeEQcétú=ïyÏ·|Ë·œ9sc¼»»û»¿û»Ÿüä'‡«'‰ÅÅÅ“'OF˜„clñÊÂÛÞö¶üÁ|ãßhF©Túô§?ý‡ø‡Ýn—„^OPå±Çû‘ùƘñ!ÍfóüùóÍf3jêüùóþð‡ßò–· „‚ XYYùèG?úû¿ÿûûûû¡w¿ûÝ?þ8ÈáâU"Òqdë ƒ›„ÁfÈŽ0a˜LÁ‡îDRJÈô…1†Û®(Â5€ ~ÐXæàª\w &çg„°B J¨DrvaŒÎáâtpŒÀ•‡{,P©"¥tBÆœ;¾‡0©Ç…P€p)À‡)Š* qÚTE 83]œØlßoJ¨é9÷˜K÷ª„Ç÷¼ €˜ø=ןËsMϯ®cyo¨š]Û’©Té9¶åy*¥”RðbV( ëÚää6=j¹ß±L.¥¡j ºŽ× &xËê¹,€hìM³oh*!¶p…Ñ0{ç1MÌ,¤÷n[&Ä=¶<Ž_†¦›žÓu¬„óXPëwÜ ˆkz×±ý.!XWµŽmíÚòÝj¯Ã‡t®qÐ¥ÚkCèvÆy¥ÓŠëƸÒmwlÓÐ4…Òb»A …ô_õ~p²µ~ÇcA\7ºŽ]î´„”1M¯t[~ÏP5UQŠíBÒPµ0‡U¥Ðª&Ãö=·&˜å¹¥N+—HBvš¾ë¤c‰¶Ý/´ê!¸ùíØ&\kî6«à¸Vé¶Kíä/ušŽï'—b«^‰kºª(û­z¥ÛŠë|³V6=7OÔúÝf ²nWº­®ceâ !åF­¤REWÕŽeÚ|2…1ÞmT=$XÀùzµ˜6b”ÐÍZ¹Òm¥¸Ë‚µJÁ¼lµrk§YËa„>·x-—HÆ5}½Z\*B=½v› žO¦oío=¿±¤e<•¾¾»±ßªÍç'všÕ'—oØž7—¿°¹|y{5OI„>}çJ¡]?96å³àó‹×çóãã'WnÜÞߞɎµó3w®tlsalòÊöÚó닆¦å“é6—«½Î\n|­RxbéºÏùL&ÿ…•›på—ŠÅ?·xÍçl"•½¶»ñÅ•›šª¥cñOݺ²Tڛͪö×·.¥cñ”ßiTŸßX|`jcü…•›m»?›»]ØþÜâU„ðD:ûéÛW®ïnLe² =ö×·.iŠ’'/l.aùfÒˆšöøõ k•ÂÉñ)„äǯ=Š×*…6—ÏÏœ¨öÚßx¡Ðjœš½¶»ñ™;WÆÓÙüåíÕåòþÙÉ™ÍZùñz®}j|ú©•›_\¹•Ž%òÉÔK×»Ž5“ë9ö¿öÜÉñ)…*uóâÅíÕ…±ÉŽmþÅå§k½îÙÉÙg×?{ç à¬?zåÙ;Ås“³[õòÇ®=g{Þ©ñ©µJñ +7_3w²ÒmôÊÓ;Úùéù®côê3g&ftU½´µ²\Þ?;9»^-þÅ•gZVÿÜÔì^«ö™;Wž=IùÜⵞcÍdÇ,ÏýäÍKs¹q*O­Ü¼UØžHeâºñÔò ˆWß¶Í6—Æ&}Î^Ø\ÞoÕ'RYJÈ [+éD ßÙ¬•“†Óô¥â.<‹Új‰RÓôõj±Ökô~³Vò9K‰b»(äâ… Ÿ;ŒxýŽïýîs§NK)f·c[†ªq)ê½nÀ|;¶ih:ÁØôœ€1]U…”và¾ÿ[ø-Ó4…ßÿýßÿñü}ï{ß#<233333sþüùïû¾ï ‚üᤔ”RÏóÞùÎw¾æ5¯ñ cÈÿùñ ÷§Rʉ‰‰ßû½ßûõ_ÿõ·¼å-óóóÓÓÓçÎûÖoýÖ÷¾÷½Ï?ÿ|¡P CéRWVV~è‡~H×uÐÞ![[[¿ò+¿i¢¡ÿößþÛ»Þõ.𺣔NMMýí¿ý·äG~dnnîóŸÿü‰'Þ÷¾÷ÉcàáÉçØCØq%ÁLâ. ‡ÊÉ¡pÍG\Ǥ”àYæ1Äa N1g )Á$†H)Á'}Ø÷+ê-JÍ)Cp«ÇŒ0’ÒcAÀ¨J „ù (%\7ÆÕA6À'-Ç÷UEñ9sŸ ® ¶ƒ ØàT29lÁ”K*¶ïYž Q§Mϱ}WWU7ð8¦PÐ'ˆäC€H.hÈÓ¨ï:ºªÙa8DpEê96%” úhÀȃ…NÛ2TÔM Ž> üi:Ž׌¾ë„·Ã !Ô±MòÒ¶MËuãšÑ±L4mYý¸¦Û¾×²únàÇT­eöBQ¸y‰¤ËŒqϱ@«†à€â± çØ ` ×jšÝ¤aô»ÑÖï „¼ €ÄmÛL±–Õ«÷;°ôk½NÃì&õhÌ2„SÕz•*\ˆj·Ý2ûéX¼=Ã8é!°Ã{Aжû©X¼Üi!„Àñ&×ñ=Œ1ÄÃŒiz¹Ó*w[K¥Ôi¶Ì~6–(wÛpP ›•pÕŽcÝÀóKËw1&õ~×c¾¡j…v½Øn$õ˜å¹…v£m÷3ñD©ÓÜoÖ!(T¹Û"›ž‹n[ý¾ë$õdMµ#ô¢8€RzÌên£š‹'›f!–ë"„öZuMQ¹à;j©ÓK¦ íÌ,p»]/§cñ®mµ¬>,‘ÚnT6ª%`f½ZÚkÕ&RÙb»±^-ºŸÔcëÕBÈôp(´“éÌv£ºV)3†¦k[ãz¿Û´ú¹Dr£V\«šaûÞj¹°ßªOgrµBÈc <ñ—K{©L¥Ón[¦DNSk•Ä‹_.ïmÕËÓ™ü~«¾TÚµ<'eÄ—J»ðÆq!œÀß©Wg³cËå=„øà#%‚¦j½N½×K¦ow@†ƒ½Eˆ½èø>xâß.lO¥³eˆæŠPË2BK¥=•*BˆÛûÛk•Â\nl·Y»½¿ÝwìL,q»°}»¸3–LµÌ>¬“¦ÙW]©otss±¸;—ÛiTzŽÍ¥l[&BèVa VÚf­D m˜]ŠñFµd{^\7nîo!„ÚV?J³Û¶ú¡[…m•R.øRiW¡bÉ"„ßë8Ì~Ûêœ;¾¿\Ú[ÈO^ßÛ@Y¾ (Å+Ûkó¹ñ½fíÊöZµÛžJç®ím\ÙYKÇâ–ç­VöBëý®Bèje¿ï:©XüòÎêµõéL®Òm_ÚZÝiVOŒM^ÚZy‚À/ï¬-ŒOmT‹·VZV"•¹¸µŒjۦϘø· ۧƧoím½°¹Q ®î¬#„f^M³CèØ¦ãûRÊ+;kg&g‹;Ïo,Yž›'^Ø\FAìèŽm.•öNML_Ù^{nýŽJ.äµu…*µ^Ålßk˜=„гk‹c‰TÇ6Ÿ]»³TÚ=79 MYž K噵ۧƧvê•gÖnï·ê ã“O¯Þf@t\ðJ·M ½SØiYý±DêéÕÛÏ­/ÎfÇËÝæÓk·×ª…3“³7W¾¸r‹bB0þâê­¶–˜œ½¹¿Ùs¬@0ØH¿¸zs<™iô»·‹;”¸âGõ\»k›¡'–oœœ])ï—:M)QµÛ{NËêGÃ!*ÖZµØ2û¹x ÆmÛ„5Ã8oY&%tµRud½Z$„tm#\ïw›f?O@cËw™àÏ0–L—;­ýVs®Q¥Ðj”»­¤3]§Ümö]'¡]Ç>¢~@§¦ëxŒiŠÚ¶Í®miŠâ1æøB8rÊ<ðÙEˆ…pŒÐï}èCðëÙV×6ÝÀç‚wmSñ¯ÿÍ¿9}æÌ°—ÛÞÞ ³\2!¢|¯2lš}øá‡/]ºô=ßó= Àg nT}ß_XXøìç>û†7¼!2õQJ777üñHs8¢nÁïÓÓÓÃÜÏêºþ£?ú£«««ï{ßûP˜ýìØ¯CÍEÏî’u ÕŽZÂ÷Œdêh92TxAAX˜ à`éYõ§C¿A¼Â'röI$)¡c. SŽ )¥%„$Ö”R†pQ`F!£AîÅá,ŸCÙ䆶CpQ i±ª€L9ûÀšŽM‘ twÒI)¥¦(ü¤ÉShØ,>¨…Â26H(„ª6HozÉÆq®Rª«Ú Š ÆpOqHbfÀÇ5’$*„Æ4-4úb¨u)‘º¢Bˆ!dB7Áàd(ÏcLÕ4EOiRá0Pâᔎ•'õXa>H IFØçL!4®àˆÐ MQ@ÛKq8iDý¢æq äáŒC¸N‚1 8Ó-¡x'‹kTµ}`’ÔcB7ðºæU¢&}Î4E($hfˆ C" ÑÒ±¸BhÀEHB> ’F,®¶ïJ‰À`ðƒç€yôX@P›Ç‚„n$t˜QJUy¥¤$Äu"GúqMOÇâŽ?€RªTé;¶¦(ùD*àÌòÝt,ž4b¦çH‰r‰$F¸çØ1MÏÄ0CJ( QoùDš Þwí”1pÐFdv_WT@/:—ŽÅãšÞsmBÈx2-¥ôYijaŒùd rºSLÉä2?eÄ“F¬ï8¡ñTš`ܵ­˜¦çI?DJ*„xO OfÉ‚)ÑE0CÇ÷tUOe” † Ã%¡†àÖñTFSTgÀÌ@t¹x2KtKH9™Î*„t+¦écÉ´í{nàO¤21Mƒ5µßËÄÙx²ëØç`ô˜¯pŒ?–L'uU0&¶ï¦b±±DÊ <„ÀÒBª•‰%.¦* ì$ÑB UJÝÀØLgópHP©¢ ïl:“7T­iöãš1ɹßwÉT&mĆ˜Á¶ïeb‰©t¶ï8NàOgò Ãhš=]Q§Ó¹xNQTªÀ¹t6“-3eÄ'ÓYÇ÷BUTª8¾G ™Ës):¶™O¦Ç’éAhaâ`졹ìB¨eõsñäd:Ûˆ¦(Ì^S”ùܸÏYËê§2ãÉ´å»!H7 ï îlßÊäÒñDÝì*„.ä'…”pÔØœÏØ\n\SÕz¿›ÐôùÜ8ŒQSTX«c]Q Æ}×NñÙìxßµ-ÏË'ôX­×1õd~"à¼iöÆS™‰T"FŸ¢„šž«R˜±”°Ñ …P]Q@o3T-DVÀc¹m IDAT»¾Ú8På¿ýÙŸþ/?ð­~Ïg®išªbŒ)¡ªª2Îã±Ø7~ã7>#„ZÍæðw_¢ƒÚƒ=R„з|Ë·œ:uÊu]B¨ªÀö@(¥ªªAIg>øÁFw¯@ýèG‡?÷étÚ0Œá6?üá#„@5Ä!rcÌ[XXˆLtÇYéä!e <V9àá ¨„KبdTàXÄ)Èáð‹)!-‘J0¨Õ.FÁ!;{Àdû–ÃÑÃ\GˆWøŸBhÀ\UBˆøðÊF%ÌrBMUBŽï8_J ¥BØ- UãB¸¾œ”Cù^˜9l2”R¡Š”Òr]•RÈñê³ÀPuJˆéº㸦œÙž ï€Ͱ Ϩ}õ¨ŠÒslŒ‘F>ÔÍò\Ÿ1}ï ˜ uU…O‚®ªå$äîʱJhË2 &š¢9HÓô®cžj™=•*c.±àtEmZ=!e&ždœ·¬>¤©@¦MH&tà ‚®m$VÎ…Œi:B¨Þëê¡6 §¦(µ^! æ¦ÙKhFTÀP5Jpµ×†MÁôœžcecɘ¦Uºm)QLÕ¹ Ý& £eõ-ÏK¦UJKÝæ ·zhžD!v5®áR§ \1>T€s.èOµ^'Kdb‰j·m{ÞD:K0Þo×uU¥„0f6”0O"„„ì ÝaجDùÉÄ–çTºí|2‰% í†ø,µÐ®'tc"­÷»m«yl²š6ânàÛMÈHpEìcœ ^C¥cñÝf•K‘2âÐ,—HUº­–ÙŸÉä UÝnTtE5T-Á‰¹xr§Quƒ Kr>H:–H×{ÝZ¯ H[p~G‡1lJés&¤O¦[V¿ÐjLgr¹xr»^fœ/ŒMz,X¯³ñälv¬ÐnÔûݹ CÕV+•ÒSãS]ÛÚiTÇ’ƒ¾ÎRFœ`¼RÞOñ…±Ér·Ué¶&R)eÀ|,‘r­RKff2c»ÍjǶNO+„,wãš®)ªbó‰äriŸ 1–Lœû<@M§s…v½ÚkŸš˜ŠkúÂŽBé٩ٮcmÔJ¤\…ß.l§Œ\¾€Õ " BP=7ð—Š»ãÉ BÈ  DáçPc<™¹]؆Zy!4ɃõÜÔlR7®ïnbŒœšë:ÖJy>71“Éß.ìô]g:“ óRÌfÇàâþÜä,\K)!~!Ø3f³c«•ý†Ù›ÍAfO&ølv¬Öë¬U ó¹q„¦=ph.;¶Q-ÛùÜ¸Ò ˆWƹDÐÔÀ ü\"¥+Ê¥­•\< 3|Ñ'ÓY¸}~íüIÓs®î¬ÏfÇÎNÌÜ.ìTzí¹ì8Üe|>7^í¶o¶ÏMÎÎ寝l¯õûuó§ç·VàŠšUK¤.l.c„?Ý4{×÷6!©®¡L)MQž]»“'™=¹U+¯VöOäaŒC!}?‚ã{1MOñgÖîÄ5ãÑùÓ…vãæÞ&ävßcÁT:‡$zfíöT:ûèü™•òÞF­tj|š áøa¼FÎAý==1}mw£Òm¿iáœBÈS+7s‰„8…`‡³¹±gÖùÔ¦ç>³vRšF± …œ™˜©õ;—¶Vœž?=>ýÜÆ®m¾õôƒLˆ'–oL¤2oX8»RÞ[.ï¿þÄÙ±dúó‹×Jg2y×÷™³“³—¶Vf÷ìÄ, n›|Æ À\nì‰åëŒóù ×% |À ’€Õ=‘ŸhÛýÛ…í¹ƒ5øq·3Ù|±Ý,w›3™B(`,|,™öX°Y+ç)„ÏÀÒ5Eݪ—5EÎä»¶YëwÆ’©¤+všg“é ¢æYw«tðEƒ/i×±ãšÓ´Žm1ÁuU•R†`£ƒO<çüO>ò'ßý]ßÝèu ]×UÍ °¼ ÊçOœ@C¶?ŒÁÉCóAÒk˜+0¶ÊuX#’ Õ½ímoûÞïý^„`]B/^´m;Cœ „BÁB†h ðlo‰`2kD( +P’u„`±1B B1øSL0Âpî%RST°ÀÓtg¨t  ÐðtEK!$6(@JÁÈI …\“è°‘Š °!>'cMQ US©‚0Jh†¦(”R…Ò„f`ŒÁZÒ¶UQá…Jè1…R„0CáÀÓtCÕÀ9"Œ5ªª”ꊊ1J1UQ0Bª¢ÀQ8’€¡j£t,N Ř芢*Š®jᤋk:¸ôeãIª®¨ÿ¿öþ4è–å< D3³æiÕ¿yØóö9Ççh²tä¶-º[ú[!hÂØ–¹Ñ6Æ26\|mð. «Æ\°  ìFj Ùm!Ë’Î<ïyøö7ÏßšçZ5Weæýñ®µöÚãÙgû:âËqbíúª²2ßÌÊzëÍ÷yITYÆg4C“YEAÌê& –*IÊ¢"J²(I¢¨ˆRV7!UQeQTIR02„h†$ˆº¬`Œó†¥) \•7,Œ±$š¤@®!¤`dtEA—•œaj’‚1.˜à´Ó$Y•d]VB2šÑŒñ”•AÀ2ÒB² i²" ‚®¨!ÓvV DDˆÃC¬É2x<Š(•2¶¡h“¼aŸ–@Ȭˆ ÁPTE’8BŠ(² @—ð%A4U bš$k²¢Ê²*ʺ¢Lg²–ªcŒ‹VÆÖ CQ"ÌÚ…Œ¦K‚`k&8.ª$Š ¬Š$Ïç Y”,UO]QaΛª¦É²­á¹lA“Œ‰©¨º¢fT] ¤`fŠ–ÑtŒñRaJD‘–ªë²bk&xÖÎ[š†²TM“•Œ¦‹‚˜7Ì™l’MUn-KÕ EGßÖuˆ(˜Šf(Š©jª$Ûš1Ÿ/Úº‰ZÈó†e©š"IËùé¬nŠ‚P´ì;—Õ ‚Éraò´LU[.Le ¥é0…$A8YœÉ&Äùò%ι¡ªU‡7±.+'JÓyÃ"˜ÌæòÓ™\V7"œžƒÐNV7 E-˜‚ñ‰âŒ©j![3,UËê¦$ˆÓ™ì|®˜3,ãÓSsÀã•QõÓS³]V²º¡HrÞ°$A|lfQDY”²† ߦªÁܰuS—•ÇfB4YΛ–*É“Œ¦ç ¤_rºiªÚTÆÆŸ™šËhÆ8«M‡úgìüRaªhf!Í.-ÛTµŒ¦Ÿ›^(Z¶€ÉÉÒlѲ1ÂYݰ5=gXš$OeìS¥Ù’eŒŸ[4’7,[3J¦- Âraj.[`œeu¢z¦ªå ë±ÙEŒ±©¨E+£H²@HV73šQ43Š$Íe‹'K3”1[Ó VFDY fÆÖ „®¨3£ÉÊ´‰øÜòiYUI*YYKÕçÉùå;Ÿ7LCÑžZ81cç%AW€6|dùŒ$Šº¬LYYKÕærŒñ,žžÉ泺™ÕŒg—NBLU²l]Qçì¼$ŠÏ.žÍæuE™Ížœ[FYš>•É‚þMѲ f!¤+ÊT&g©Ú|®(òÜòéÙl!£é%Ëþ¥ÓKÕKVV“•Ùl^‘äž8;—-¨’¼\˜zlv‘r–3¬éLVEY”¦3Ù¼™™ËEBŸ]qê±¼™!OgrEÓ†Çy&›7U cœ3,ôŒfä ëüÂ2ÁÄPÕ’e+’,`’ÕMKÓs†©ˆRɲ— SŒ3CQ!ÇÖ“¥i‚‰*JM—EÉÖt󹂥êŠ(Š:•ÉAÚwѲ-U—1«™·®_ÿÖûo“¹t¿ð¥/--,‚„,ŠÍP$™`d*,ò’ Œß‰À®f syy9NbY’TI†w½$ˆ…ÏGŒ‰¢øö[o}÷»ßËB<ÿüóŸýìgãdÄÇá…^˜Tøô§?ý¹Ï}ŽR*ŒÈBÇ.|×BEùßù±æ8ÎOüÄO”J%ˆÃB<Ïûã?þã±ÏGùîw¿{ñâÅþáÎårC º‘òÄm—jì½N–1SÉð÷ýÞ{òÝW=øà#^õ(\*wý~`>@µxÂwÿ`}|Ȉ|¾×azÕNþxOýýPZ{ßËÙŸøT¼ýƒß4±åïjÏ{ïõð¾sfòO’Û#ZæƒßëQó(W=ü‰žÇG¯ö=L‡Žþû4Ý÷çiúþÍ™È{ºêû×ÂûŽéŸáß§iÿ(÷exå‡@ õ¯þÕ¿Bwòz\¾|™È;¾:MŽ5ü?q™O¦iš$ÉøŸõzý/þÅ¿îŽü­¿õ·8çqßnXó 8íñá´»F~©J½^Ïf³h‚Öä[ßúçÀ9‚à¹çžCÜ(Ðq˲þé?ý§ …Nžìæpã²ýïØÖäœÃvêÄŽ,7£Ø#ã®F˜š‡›/#…"Ø-H,(\q„ [vñ¢ee<Ún`œ? kã4« Ø UÓÏ£$ “ö³Ã$†}¥”Ò0‰1Æq?ŽÆùé~Ïô¢æG4&NÓ¡zÆaI É[NàGi‚1*qqÆ8wBß‹BŒpœ&}ßG'@æ5çÜ ü$M“ üÀc7 ý8ÄGiÒqp‹0MœÀǧŒB *\Õõ\°ŒƒÐ‡«Zƒ¾…c€A… 9(@µ…1v£ ç»0"m×. B¿ÞïÂïžïAµAÕz7 0Æ^¶\œýÖ Õ&4­÷»`®¾ïu}:[î¶úàÙr·Œ Õ^»9èÃ(Ôú]°í NSwº7Óõ܃v#HbÆy¥ÛªöÚ0ßÊÝô«áôÚ °mµ×†Öv}w·Y+µýæ ‡1öâp·Yƒ– ^íuÀ)£ûí:Lr·µÛ¬Å4Å´C#$ñ^«}¬õ:M§FÞ¨Aµ=ß=l7Á2íT¥Év³ »ÞïVºmèìZõ°Ööšu˜~‡fÓéÁ6âV£S´9èï·êÐì[•ƒ£n c\ëwWÊ{½ÀÃušÕ^¦ýF½ £Ðn¬”÷¸½RÞßmÕ 1µ#`ÏÚªWV+Ðǵêáp˜|w£^Ëì6kPmBéjå¦D­ßݪ—1Æn\=؆j+½öåý­žïRÎní­”÷ç]ß½´· ­m úkµCèãf½\íµÁòw×aк­ÍzF¥¼ÙmÕÞÙ]w?¡é•ý­›G{¡æ ÷öö*T[íwV*û0i/쬯W¡aWö·`qØiV·˜ŸW¶öp+Æxµ²_éµá¹¸¸»}Üo7VÊû0ý^ß\†m5*¯mÜìùnBÓwvÖ.ïo1ÎJßÞYƒ¹zãh÷õÍt~mcåæÑÆx§Y{ií ôV½¼^;‚IûÒÚ5¨¶1è]Ø]ƒ_9Ø8‹…olÝ‚UëÒþæk›+p‹·¶Wa2·]çÍ­U„P”&¯oÞ|{{ÏW7nºQ€1¾²¿õâêU/ aðÂê•«Û`¥W7nBžÉ›Û·^ݸ¦¯®ßl»ƸÖï¼½³–¹¸»±Ó¬‚ ¿uý ôFíèÒÞ&Ƹå:tãâõÃŒñ­Êþ·®¿Óôš¾°zõ•Œ³£n믾½Q/cŒ/ì¬ûÆÅA Âà[7.¼³³À‹«W¡Ù/¯_ÿÞ­+a#Œ¾·zµ1èaŒ/ïo}óÚÛ0=ÞÜ^]«Â(üþå7¶›U„Ы7¿uã<æ/¬^DεÃß¿üL »Ðñ„¦ßY¹“j»Y}ií î\}ëµÍŒñjåà÷.¼ O÷wV.ëúX!¿³r©áôBíÆß¼Íþ¿®¾õ½[WB[ÊWßyÆô…[WÿòNàaŒ¿»rSwºß¼ö<ûoï¬]Ø]‡)ñ_Þyéêá6Æx«^ùã›1Æoð{_}qí¬º¿å hùÖõ ߸ülwþÁ•7a"½±uëwÞz±ÜmaŒ_Y¿qsˆ­ñ¿qù èã­Ê>´¶Öïþî[/¼²~c|qoã?¼þýv#¡é½ôú7.¿¥IJéï]|µ9èCcþ¯«oAc~÷­¡†G»ÿû«ß^­`Œ/ím@U”±¯_| ŒüÚæÊo¿ñ]øýÒڵ뇻0L >‹1~}så[7.Àûëµ›ÐìõÚÑwV.×eìííµ ;k@Ù}iºÐr[å}˜Šëµ£z¿ ö¼v°ÝÎÕ.!´Û¬Á´÷£Ðå·wÇ¥îtÄ1Bmשö:ÀU^ïwû¾Ó£ë»|ô&«Ì9GÁ#c”qŒEÑqœÿü»¿ûçþÜŸ[^^þÚ×¾6ÞÞEciÆ€>ܘ{[Å'’þÙ( ^ph¡˜ššZíê_Žõúxk”1¦ªêúOÿizz:MSðê€÷Øó¼_üÅ_üÄ'>qáÂQÁAÄHƒû"^'7JY'«3½8š´¾ñ ” –ñ¡£8d—A3ÎB0"^9Gœ§”¦4…w0tn”¤)F˜1–¤)К@z ã!{ücÊ~ŽøH0iWÈõI)ü dMFIŒdŠ8ãF¸ç{“j¿ãÇãü°ÝDõGò‘qš8#p¢£jY?ÉGÆ|~l7«²(uÜÁA»QéutYÙk×÷š5HóÚmÖöZuCQÚ `ùïûÃjû& ãl§UµT}«QFqìŒpj=Ï…±(w[†¬l7+Û*ãÜ‹ÃíFe·Y³T}§Q¡ŒEiÕ®UQª9ݶëp„ ƒfÈ ðÁ2mw} “š¡žïA"|ÊhÛ^åEA?pÁ¹4µÒëlÖËGÝ–®(kµÃµê!ålø»Í:Ì=‚q¥Ûjú’ ܪܪ(¢ØôÖ«‡{­š­7Ë»¡AÀ@_?ܱ5c«Qd:|Þ „:îÀ¡Úëý®€Én³`Û•ÊB¨éô¤¥ ø:·*û)cƒ(ج—"ÔúŒðQ§Yëw$Q¼~´sãhWår·]é¶ÂÕ~`†nÆi oÍšÓ…ÉÄñ¸1-·"cW¶ó¦ue !äFaÇsBv7LU=h7nín7*–¦_=ؾr° rÏW¶¯îä s­rpí`§ÖïÈ¢tyëòþ¦*J‡ÝæA»1.÷Ú¢ ¬”÷Ák¿v¸®tÛŒñæ ¿Y/[ªöÖÎCê†!BèÂîzÞÌ\?ܽ´¿Ùö‚18ÄÕ~'¦é ðoíæ óÍ­[¡ŽçÀjÃ8¯ô:ð<ºaÏõÛ·dQ¬ôZ÷6n”wó¦uioóÝõAè'4½¸·‰*wÛÊæEa¥ÛF½½³Æ9o»ÎÛ;k—ö7 fæÊþÖÛ;kAO ä­[¡J¯ lÇ@J ]€Æ¼²q½hÚv7à5ß–¯nÜEi¿Ýب•1F{­º$W¶Ûž“RúÆÖ-øÒ`œ5œÞòn^7_\½†j8ÝÎp­¦ûz2ä"ð*½6Bè…Õ«¦ªo7«onݺv¸[43¯o®¼ºq3ˆ£A迳³&‰â^«£ï„>¬/¬^•Eñ¨ÛzuãæÛ;ëÓvî…Õ«P-˜Ž#´×®SFëN÷ÊþVÞ°¾{ë2B¨ÖïÂêñÚæÍ¢i_?ܹ´·Ywº".ìm „jN’óV+¶fÜ*ï­TöÃ4†¬YBHkЇ.DIGr£–ètÄêp—¢JrÏw;¾&1Á¸ë¹=Ï%„£$Î(Møèý› óYQL)ÐJÀ[Ò‹ASš¾ôòË?ÿó?îܹŸú‰Ÿøæ7¿†á]·ƒeŠéH+å>nÓDx/ÑǰÆBSSShÂ¥s]BiB÷ä“O¾øâ‹gΜ¯c œ W®\ùä'?ùOþÉ?E‘ƒk7¼Ûƒ»Ÿj×]ØÒñ»p®üN(å{òí ßmx&#(%!„€S»Ý|‚öžñHÐ|”sB0Á„rïB¼0>cŒcœ Ø 4ÒâîA¼2„ ¡-eTÀdŒ]…Ôº”QÀ[ÀÝÞɾ\sÇAŒ‡T/ §Têdš2ŠÑmÕK<2Uec§‰ S6ìÁÃ.h²‚§C:À‘ª)Á IJ0Ñdå¶j*ˆ˜!¤Ë*B(½¶9n?ºS<ÔPT Ž Œ2 ú’CÍ>„„Û²ªb—2¥)ÁÄRי貢ˆ2Ä5[§ d“$Œ¢”2¡)F8£éŒsÆ™0¢ç¦ŒeTÓ±ò&B0%<„‹¢(MI6AIŽLuÔ šeu“`’¤)!dÜß®VYFÀ·á¢§)¤c¯“‰ã ‰L2ôŒÓ$§›Š(-«ঋ·‘’CtX”$Š$åt3L’ Žr†©ÉòPË’Œq˜$¦ªf4V´±:$Áw4f À…ÛôO”&ÓÒd¥ç»’ -;¥Ô }[7lÝ„>¥´`f!Q’D'Z( B”$á©L–ržÐT„ Jˆ!%AœÊä€Ë&oXYÍèûã|ÚÎAHªBEIR°2ª(ûQðpx2 ‡ª…ôÐÉ. ¡*% P1$’BÇG}L§39E[®£ˆÒ¬]ˆÓÔ ý‚‘Éh†…€Cî]Q¦íDÙg²y]V›n_„ù\!eŒs)8¡”Ñù\Q$‚…"îlÌmÀ ÆØ ÃŒ¦OYYpdQ"£a‚YLEÄ„q,‰¢&Ë ¥)cú„°õoÒáUaŒ0à-MW$ù·û·ŸÿÄþ÷ŸùÌoþæoŽÅµææçÎ?õºý€'))îÇêqÛs¹›ä¶#„îÜAFwž~¥ô‰'žxûí·?ÿùϧiŠG’bcjå_þå_þéŸþi4ÞSŘ߫ñzHuÇŠG'cN“q”nܽ¡9tSÆÌ·é›A¯“Œä~á-N9ªa‚1Àþ1ÆãÚ &)¥Œ34$iŠ0‰±ý¡ô5¿ñ ʰãÀel3¼nÑd oë(IÆT))0†•"J”QxÓH‚&IJ)¨¦qjåã°*T;ÜÉž0T ì ‰#™aX¼8J•EqL­7ºŠÁÃì†çH—Õ”Q7 $Q@CYÕ!XØ < • lB­•1à:H,…t„xéù. ùŸ¼Š¢žˆŽPCl¤•±ë¹Œ3[×!¸­ˆ’®¨ƒÐÒD“d>!9ÊFR§Ãû2®J2G¼5p$Q´Tmø~êŠÂ9Î?` ézm¤Ä+ƨéô$AZ¨V¥Æ Ï8`2‡!ÕÂP´ Žz¾ éüéHå“#ž²!¿ /€AªýáÓ‰|ƒqµÉˆ•ŽDKuY©ô;°¬@xotÕmÄëX<^°0U{ ‰JV^$°ˆ'#aV„PJÓ”1SÕÂ$®ô:¶¦g ³ÚëxQÄÈ ¥ŒóŒ¦÷<¯9è$6NS=vwÀªå #漌ªuZ^Îfó)cû­º.+Ó™\Óé7þT&«É l#š »ÜN'4ÕdE d»YUEIÄxF£ØpFÕJwšKÕ§3ÙJ¯Ý8³Ù¼,Š[õ²$ˆT›¦¡¬n¶Ag 3¥4NÇÌ‹4iYŽó7•#Hðj’ò ‰Ì!„3£é[J”&' ÓqšlÔ,U›µóå^»í:3ÃÒ$e¬hfa°Ý¨–,»`d¶êåAœ,Î0ÆnUtIÁÇt¤5íVeŸs–ÕÍq2 B(¦ˆ×4¡œ•2vÇì·ê‰…˜.„PÉÊîµ §;mg瀙-Y¶[õòT&7•É®V_²ì„R ?Êä*½ÖQ·5cçB4…éÀzqšFi¬+ª*ÉWvdQÒd9Jã0B9üy´;ƒ3Ós)£7Ë{¶n,å§¶•ƒNãtiÎPTØ›>;=ßvµÊÁ|¶0›Í߬ì÷|·dÙ)M¡ 3vî°ÓÜmÖæ²ècœ&¥ŒíÅáõÃÐŒ“˜ntY¹r°% ÂÙ™…J·½V=œµópU”$E3“Rzy³`X¡ ‰âÛì’mh@\v6›¿q´WwzOÌ-r„.ì®›Švvzn¯U߬WflÀ“ư”¥ŒArÎ|¶¸ZÙßoן]”EñuE’ž˜]¬tÛ7Ë{Ó™áUé(®ïǬoq’À~NFÕßÜ^%„”2v˜ÄPíB®xãh·9èÏç Ma›b)_Úo5VÊû1vÉ)+ëÇÑ[Û«E3ƒîÜdð¢h¼a›B3vîÂÎzÏ÷žY8¥Ék7s†y~~y³v´Y//¦8ç^¤J(…¸×B®ty«îôžY8…zyýú˜’ † ²•Â$žÏ£$yms¥hÙÐBàÑ%`ÛÆOÎ-µýµêყ àX¯îꊲ˜/•»í†Ó…ŽÒtâšXˆ†+†({íº$ˆ¢ $c±àI kÄÇËÈdéxĹ¥éQ’ Â@“eE’œÀO)ÚÿIÄëdþÍ,Ã\ÛØøÌþè¿øÅ••aô}ûäSçý×ýððð¯üôO£{|/>äü¾âïmÕ襺ñ:v„Ða9„®ëhH1öêlÛþú׿þ¯ÿõ¿6Mö^ag–R*IÒüÿñ¯ü•¿2éL"^ºÇå¼dÿÆÐ×Û-¸"£X rt ½ì1«`'ÁAp+\% ÆqtÛO­´QUQà49dÈœ„ ¾Mý%` aŽHÒÆ€´á¸ãaÄB „#®J <Ä«rÄá¢VäˆK¢¤JžuYÖŽC QuL Ù€c§qfʪ0¼Šv•q®I |2BÆÌI¢ J‚ "ÄÆTY„­¥Ð*€+Ê¢Ä8ËhôQDIÑè»ÄÈ…³º£#‰¢$ª(QÎlÍ€–|,¯H|N‰Q†æÂ² Ê¢^Îõ)‚1 熬XªÎ2´'B²(A¿ŒI†þrÄ fF—UŽ&)YÝ„ñR%Y–$‘¢er¾UQ¢œOY¶(#E”I7odÀÿƒW|Ÿ  ¿nM–!`@‚‰¡¨¢ `„dAÔcŒ1ÑdE‘$CQSJ§3Yh9@Ma"!±’ šŠ Xo]RTY6U-¥é”•Õ!¤Hàm ƺ¢*’„0’ˆ`ª|?ÀËÌÒ´”Ñ¢eçM øhò%@g벪É2tÁT4ˆƒŠ‚0Ÿ+Úš‘RZ´2y#Ã9—ÉPTSÕÆš,Ïç cM—#¬Ê²©hðL™Š¦É2ÂHÄŒ¦Ã×àL³ºS:mgÜÇ8?QœÎçÜÒô…|ÉRõ8M— S@L£+Š¥ê!KÕUIΔS¥YY”B  ]°4M“CVB§J³3“2–3¬Å|)£ê1MO•fTIFD.oZqšÎç 3jÀVŒCF!§›P×%£êð­bk†&ËaE”d*`b©ZFÓLa©05cçaXÏM/”¬lÊhÑÌ,§瀱µ4]%E”ÎM/ÍL”&ó¹âB¾h©ZÊØ“óËŠ(ŽÕTµ‚™ “øìô¼¥éˆ#CUsº ɘK•dÀuŠD0TõñÙ%‚°$ y3£J2BØP”œaÍ ã¬deO•fcŠ$å 3£Š()’ôäÜÒT&%Érqz6[àœéŠšÓÍ¢•Ág óñ™EŽ,Š%ËfJSU€F$BÞÈì7N“gO겨ö¬nÎdrAŸžš[.L[ªÆ9fñÔ|¶@›ÊdŸ],X™0‰Ÿœ_^È—IR$ù™ÅSÓ™\˜Ä§J3 ùã\—•¼aÌ Æ8§›OÍŸàÉ¢T43ͰT`òÑç`&Í PÊEIÀO€l?»tZ=­–ªç “2öñ“ÁºT´l@Ú*’ SÀç-{ÖÎGirª4{nz!odâ4ýØÉs‹ù)ŒQÞ°ž[:’Eq*“ƒ·€­S™ì¬Ohº”/=9¢dÙAôÄÙåâ4º|6eT“”ù\A‘d‚Iΰf³ùÅ| óÔ‰)+¤ñ<öŒ¡¨“’eƒ÷¦JÒ¬Ïê&° üð¹§ÁàS™¬­³ÙBDY>»˜/É¢¤+ÊsËgÀ23c(jV7gOÎ-ÏØyÎyN·NOÍÂÖVΰ`!®ÊÉÃT4ÊèRa Þzº¬ÂS)ÁPTØ@˪ƥ ¿ùÍoN"^ÿ?ó¿ž?uVDA 0TQbœéŠªÉ2G\$Â8Š/h) Æ#Y’/\xçÏ|æÏlmlŠ¢{ÿøÇÿí¿ý·_þòÿç?ñ A^~å•ï}ï{·¡¬Ï?ÿÙÏ~–3î¸V¢ |o¤§}êùç?÷¹Ï±‘bÖ]ˆWx¿‡aøþÑ?ê÷ûcoïgögÏ;Ç;?|¤Ô û©Ÿú©ƒƒƒ••<Š"1Æ$Iºzõªa?ôC?Ñ»÷‰x½/”ãCFÜ|`8÷@rÞ×U ùym~{èUïé¾B>Ê}Þò÷aöЪÆÓéÑûøð”Á}tÓݧwÐ…÷}¯wýG¹ï{܇´ö!Cüˆÿó¾'ÕC–÷1¸ü„{ðè}£ÿáÚóûg™÷7©ñªä}!^T-d¤ÌÍÍ¡¤”òå/Ne”AÀ9ÿò—¿Œ& ¬ïñÊî‡x½qãÆ]~Þõëס/÷ú$IàÂo|ã³³³h”؆GÔÄ;;;ödDZÄ!âq¹A ­ŒM 5`Sxe1ÆŒ³Û”ª”$7¶ø0H8‚Ä&£ Mâ–ã}ˆ-4•ÒtœÛ% ÀQAòÜBÓ ÌŠ1]#6JZh!eÌ‹BØçÒÄCØõ¢0JHqƒ89œø8ÊØ @A!J7 `³Ðp•…ÐBÀ Yú¾á¢Ô‹>”6†s>}0=ßþ¨6¥tøÐðNÇu®åE!ðƒsÎ;ÞDŒóžïBU$ ¾ß÷7šÐt½8çmw˜_ 5Àˆq²0¡žïB2VBÓqvyÛ€¬B¨í:ÐÚ~àÕúˆ×ûݶ7ÀûqTé¶!¡µ5pjýÜ¢=èƒú_î¶¢4áˆ×úÆ ÇGj3T×v£n âËÝVkÐÇ;¡Ðn@N­ß©ôÚ°“uÐn ¡¸qTwz0vGV­ß#ï¶j€ê­÷»í&Ì„Z¿y†Â†¢dNÇ€‘·U·ÖûÝÝf 4…w›µšÓÅÇiZî´Æ i€“õãh³^èVÃénÕË®õ;`ð”ÒÃv&U¹ÛÚnT`bvšc$ïzíp^õ~4Ó(cíŒ~¥×^¯:-èxÛsnUö'Ûôì‰ÚkÕaZ:¿×ªÃØ•»­1üv·Yƒ½È¶ë¶Aõ ïµê=߃î‚î Õ2ηG ÝÃNóÆÑ.ôq¿U„]sлz°fܨÝ*ïó¹Ó¬ÄØ }€…&”Þ<Ú[¯ïÒÞ&€¶êåë‡;ðn7*0 n¬×ŽgŒó[•ƒ›G{ñ~à]ÜÝ(wÛãÝVíòþ¦‡ãF°5AÝ*ïÃ>]­×ÙnT1ÆñÕÊ€õöÛõ·wÖ@âìÊÁÖJy¤óVÊû0›ƒþZõ¦Ä;;ë GæÅá£]˜H‡Æ^«]xcs µ£7·WaÖ­Ub\íu^Û¸Ywº`O0(´€w§Y}uã&`VÞÙ]Y­Ö ÿòúu@®”÷_ß\>Þ8Ús¹apå`ó1˜2ve T§Znÿúá.<Ú·*€( “øâîŒÝ^«¾Z9€9se ·Ízù{·®t¼åì­[ïì®CÅ;;ë*w[×v`h^\»zýh¬tqoÞo﬽ºqƒrÖöß¾y L·RÞÿÎÍKÜyiíÀE£4y{{ FüÂîÆ «Wa¶_Ü]‡§x­zøG×/ÀÓ½RÞøvBÓ·¶Wa­;ê4/în`Œaðí›—.îmŽm +Õzí¼ÍAï›×Þ¾UÙ~óÚÛ=ß‹Óôo^z}sc¼ßnüþ•7v›5Œñ›Û«tãÈjÿáµ·.ïoÁêôÚæ <û+å}Au[߸ü`HÛ·¶Wáiº°»zz›õò×/½Óc­zãºÓû¯—_¤v­ß}yý:Æ8Hâo]çåõ0_X½ oW7nþÁ•·Â$îùÞ×/½(æŽ7øÞ­+Œó„¦tãâݸÈ8¯ô:_}çeÀw¿µ½ú{_sBß‹ÃÿzéõW6n€•þxåä$|wåò\y3¦iËuþË;/]ÚßÄ_ÜÛüÚ…W`ÿÖ ¯¬_çÅiòêÆM7 áÙ{Bÿ¥µk7Ë{0‘^^¿ àN£ ˆþ®ï¾³³«Ç^«~õ`;Lâ„Ò•ò¹ínŽàðû­úN£ 4×Û TÄQ|¿Äµæ O‚[4œdp5ý1Ÿ´!äÞ§B|¿ò+¿R©T4Šúß~ý×ÿößþÛ4¥Qi‚FNν;ª”³$Mlj:ÞxEh”Ü…'¯p»o~ó›œó±{º°°pêÔ)4@€÷!ÀYLÓôÇ~ìÇ®_¿þÙÏ~–ôd¥ûþÀÊßñzW9 '°‚ƒ> ø¸Ã8ω·Ó(9,¥Äajâ@Ùð I(∲— Y‡#N…d„P’R`Í€y 9¼ù@à–1Î)eQ2tÑ¢$t7ç e´ã:Nà!Ä›®9ƒÐ‡pX»N¯áôcØÕ®çº#¿1èqÄ#œPzÔi"„Z¤GÝ&Ád·Ys®™s^wº”1'ðëN—s¶×ª£z‘q¾×ª DØiVBƒ0èºøN«;]øV ’Âà½AµŒ1pÇ¡ãcPdÝé‚Â$®õ;0©º#P3ç¼ÚëÀ'àþ6kG¡ºÓ„ç|³^ˆ°Û¬îµj]ßõãVéu`æqTî¶B»Í*(ï6kÛŠ@ÈN³ºß®×½(M׫G¡j¯íF!3ªV%a(9:”tB/¯[%Ën{Nœ¦Kù’H„šÓ5u>W†rœÃLPŒ±2RÞ‰ €Ÿ ã†$ˆË…é0‰»þ`ÊÊæt”÷&¯JdÆáb¾¤ËJ?ð"(’ai¨†‰â49Qœ‘E±Òmж\œ†gA%Y€·èôÔãÒ$MîF¼QN¨LÂ$îx.@Ú®&±®(Œ³”˜c©SU”ƒ>P™$iÒrô°G0.ÄQJSƹ¡¨n¶Ž©¨pd4sΛƒ¤ '#aV„PJSʘ¡¨a7=XÄš&Œ¸Öï@gL:ˆl¥ÍšŽiï@¼Ž±«ñÄU1MÑd:<£$M)c¦¢qî ,Ü MrЮ‹D˜ÎäºÞ áô,EV;ŒñymÍh8½¶ëLer¢ ì·ëã;×üJ¯mª*B ¢0«áª¬n¶=§Þï–,[•äÝV26—-¸QxØi‚.pœ&·¯ÉñJÇHÉ8MJ3šžÐt§UÕe¥hÚµ~§í ²ºÁ&q²”B¤ÜRõ½VÍ¢œa¦ŒŽÕZ:¬V•ä­F°#nì4ª–ª¡a?ÞŸÚ‘@ „ˆF8Ù­zÅ£åÂTœ&›õ²¡¨3vî Ó¬÷» ù¢"JëÕ#ÆùB¾äþ^»pæ0‰‡b¬Œ…q̇ýJ'РC%Ótñ¥I†PÊ ‰øˆ<2š¸*N“¬nRÆÖkG¦ªÍe û­z­ßDvDPmB)8Ð9ÝÜl”{¾—3, {GÍL¥×Þo×— %[ÓWÊAššuµz3̹l~³^nz3C9 ã˜rV´2Ao«Q¤$Pjç +¡éÍòqü Ä«O"^#„PÑʬ׎ÚÞ`*“Mh$ÍjøH°uãfyÏóÓóýÀ¿~¸[43K…©ÚÑQ§yº4+ äÚÁŽ(S¥ÙZ¿³Z=œµó ÅëÞ”e¼×¢!âUÐ.â(oZcÄ+îó$}¸¸·¡ËŠ"ÉÁh?ÇÖŒ«;1MK–%ñкQ+—»íÙln˜5Dé\®ÐôníÍç %˾²¿=ü™L.Nðtçr…ýVc«Q935gÈêÛ»k)£O/œh¹Î¥½MÀj\?Úm{Îl¶ÐÔ‹BÆØ|®Xî4WÊ{'K3yú°»áGÑ3 '!2š5Ì¥ÂdÌØ9ÆØáèpô³º¹Q?rÿTi†R¶^=RD6ÓáûÒ„Ò¹lÞ‹££nô÷ª½Î ¦2YŒp¹×"„ätË ü®7Ȩº*Ê §«"íûÝ]R²ì¹â”µUCŸ)NMK²¦e³Ù™|¡˜/ȪZʧ²9Ó´LÝ(Ú9p`vw÷ÐD¬*‰‡\ÀØ•Œö±rä#Ä9O’!tGj¢ ¿‡ a @¦4MÁÑeùË_þò?ÿçÿÐcJéc=öc?öc¡±“×ëõþÒ_úKý¯ÿõ~¿?Þr… ü!Ò½ah*|Éßñ: }¶O‚[‡á&>Áš†ÐHãuÄCN¥p›lˆxeCZ,SÖU‰£0!·}MYŽ Ñ50" ^9GcY0Î%AGQò9ø<¦œ+¢$‰"<Þ@HYG |.‡ „PÎTQ}àrmôå£@ˆ( k0dUDJ©*˲(qŽ@Z_bH¡;ØPŠhËáˆ` ²°ªøjB©¡(º¢Â@f4]‘ä”RE’ Ek(ë``‡6¥QµD%E’)e²(fTqŽ0V%™Üæ[’ÁËQD 0¿cE’Q¢œ‰DÈ&T«Š2€éç#£+JL©&É • ˜vSÕgÔ‚>‚ÜÙ¢•1-¡)ȹrÄ1Bš,«’ ¬dÙº¬FibªZΰ$AˆÓ´dÙÍ ”J‚8ee5Y’8oZº¬rÄEB E…h¢®¨EËVD)Lã’eguÝ3™!„s¤+ª$ˆˆ#Bˆ©¨`:U–UIÖ%%HbVÄqÄg³yKÕƒ$¶5#oXœqðYÉ.-bÔ¢¢i¬ p#‚s®+ Øcl(š¡ªð€,äKPƒ©¨ª,+¢§éb~JEι&+º¬À¤5UÍ5r¹8%qd(Š&+š¤I´T˜R$‰1®É2 A9B ¢ˆ8D]9⺢AµcXDˆ«’diúpv©º*Ɉs¶nŒ9瀨…ÑÏh:`åg§§æ€‘ÇR5p|ý8:Yœ™ÊdcšJ¢xª4 _“¶fȢĜ­Ag4ýdiÆPT7 Ngfì<|Sž‰WAcD"00JR]VÎLÏgTÝ ý¥ÂÔ|®qúÇf%AdœÛº¡Ë çH $oZ  YÝÊ#Ð6U%)Lâ'f—f29/³ºyjj²f fØTYÎVÞ°œ ˜Ïæ²Pø.Zι¡h¶fä ³ï{§¦f S„”ѧæOÂ8f Îqÿüü²¡¨Œ3ÓL«ç»ËÅ©¥E’Â$~jáx¨9Ã|bnÙÖŒžï>6³¸T˜‚]‘gOK‚À8+CQ`>meRÑÖô¬nÂèOelÀP+’ Nã÷”¥ê”±¬nLÛ¹™l¾átŸ]<=Ÿ+ùÑB¾4—-ôw6›ÿÈòÙ„¦f³…i;m?|îé…|±îôžœ[>3=—R¦HÒ|®8Ÿ+¸a3Ì:ûT)“­;Ý8÷äÜ2ÄD~ôñgN–f›NÿÌÔüÓ 'šJ‚8—+ÌçŠa’è²ú#=3—+Tûg—N=³xJ•d/ ôñgN•f»¾;—-<·|&¥<—-Á‚¡h%Ë.Yv×s— Sg§ç5Iö¢ð™ÅSÀšQõŒfd Ó üÅ™¹\XTÏLÍç Ó¼i-䊚,ûq´˜/­Lʨ$ ù¢¡¨AÌŒ¥é)¥͸|â5ât}uõâ[oï…^|éÅ«.¾õúëßþÞwß|íõËï\x饗¿÷â Þ|ëí7ßúî‹/¼öúk¯¾ô²¬ÈK‹K/^üö·¿=Þµ¸îÏþìÏ꺖¦)Á8ISE’EAø?ÿÏß{û­·ÀåaŒ}úÓŸ†$6Ur Lñ…‘Æ+lãš–õ‰üA˲Y*ÎBÙÜÜüùŸÿùöÏþÙø¾@ü•¯|åãÿxš¦Ð58ów÷w/\¸ðïÿý¿'„œ?^×õñFŸ$I×®]ûão2ø ûØÇ~ò'’RzÄë½pž{ÿúžà*  æû ÃဩGoÌ$ åA?î¼ÜQíƒt9Ôȇ7æÝT>?\Ó=¨ ʈ¼¿Ñ¯óóOrXy¯–yô'wòOŸH2Á>DÓ½ë}?Ä™öïBôáZæ'€™6^îTß§azø\½ÝŒ?‘‡ô¾—¿¿§éMôˆ£?y8Nßã-ýàûÜ÷wÕƒ¯ï©@¸ëüƒÀ9ÿÃ?üÃÉpBè—~é—8ç£Ü~ž¦éßû{ïv4PB?÷s?Íû—ÿò_‚$k†|ñ:¨[\\üÌg>óã?þã?÷s?÷Å/~ñãÿ¸4b(ƒsàŸŸÿüçÇ÷÷ôþàB²<Ì‹(‹?ó3?óµ¯}íòå˯½öÚ¯ýÚ¯>ìd¿¾ò•¯pÎã8Fé8BqŽ0šm;€|â7šÈ¢DœÒÑÀ°Ó Ò[ðÃÆ +Œ{ûªhž0™Œ‡AK6bvIhʈ‘LÈQ‹Ó”2*Œôà`ÊhBSH‹Ò²ÜgªHb㈇ÃR´à^a§”Š¢À†0X _rQš@Ï#ʸ$ŠŒ±pt0Hâ8M!MÊ#2º04"„¼8L(•E)eÔ L°(IšFI ¤tƒÐgŒÉ¢Dõ£bxnDI¢ˆRÊ(( A¸.ˆ#Ø›ƒØPvÃPBˆA)’Ì8ëùç\¥„¦^(¢Äê^”$š,'4íz®€±$Š Ã¥H2!¤x@¤$qÏs%Q¡ë¹AA­ç»"AˆÓÔHÊéã\EÊXÏ÷I"„ô|Ï|UR!oÉŽ M{¾§É G¼å:AŠ¥ ¤kÈ’$ñ ðuEç²aJXš¤ C<¦)äs˜@F—q¢%QšÆ4¥Œ¥4Ó$LÆ9lüSFaƒ?ˆcP“a`cð“4@hG”± ‰¢4´• ‰ý$Jì'G&¢$‰’8¡é]GÐqP¦Cyq§i˜Æ~ºaR’œó„R?‰BƒÐOœ)ãPâ #¥±…ƒ  ŒõŸ1–2 ØU4bSBaäÇ‘…Qš ¿ï{)¥=ßî`m~Ç~:¡ßõݔѮïºaà„~œ¦•ì~LSÎy{àPÆ:î ï{^úQŠÈ½ÀƒÌª8MzþmÍ>°ã¬ã ânô/ˆã¶ë „z¾ áÉ´ã¹ã®çzQ0ƒŽ7hú)£5§Ë9’¤ã»¡Æ ©l=ßm ú)¥Õ^! †9Úv˜&¡0IàF¡®çgz¹×JiZëwÚ®Óõ^ÕB¨9èGi’2ZéµJñ×ó\Àºv)Mº-ðì[#4hsÐâs~ØiÄ4=ê¶N¯ã œÀííz¿ ¹D~Öû]„P¥Û~ÛuNï¨ÓŠÓà‡ƒ0W[ïwœ§ ^Ôz™V{ƒv=J’ƒN³9èUúm/ ÛÍÃNÓ ƒJ¯Ýó]Ž8l×nÃéõ| GÝTëÅ!€LÚÍ®ïÖ^¥×ÞmÖbšn6Ê0—D•»- ýÙjT¢$ÞnTÚÖ ßôËp4@Ð?ì´BÛj?ðº­J·½Ý¨DI²Õ¨€&i×ì¶ê.¶Ó¬VzífÍÃÍFy·Yo»ƒj¿sÐnlÔÂ$ÑÕÃN³xÛêV½ì†Áv£Ò÷½„¦;Í*Jñ 9ÝR%©x£¢e§Œ‚ÆëÕ+ XœŒ32G)›€K(YYΑøº¬duP. ãc\²l`FAÆYBéT&‡Ž’xR­U$‚@„0MG3vŽ2Öó][3lݹÃ{USý8Ê›–¥jÀó2›Í3Σ4‘Èm@뚊1ä©…9ÝÌVÇs¢4ËEBšƒ¾!«ÓvnúNàOÛ9CQ½(ð0ÓÔ C[7@Æ !$‹w#^Ð\g{ऌBZXÄ#}‘ac$Að£ˆ`²/…IÜrûEË.˜p€I÷ˆ‡:7kçlݨ;]Œðrq:¡iÍéæÌŒëz/ rEY”jý®*IË…i/ [ƒþŒ+švÃ饔ž,Î0Ϋ½vF3sÅžçö!_Òd¥x"dq¨ñ*B ,çašœžš9ê¶LE].LTSEI!wþÌÔ\LÓ8MdqˆëôÂðtiV„^àŽSB’(È¢˜RÓôìôâü°Ó°5c¹0 ”(Š(É‚èFøÜÌBœ&Õ~g:“›µóµ~7ˆ£s3ó¢ îµê¦ªž™žs¼),êNv¤…ꟛ^P$©ç $A¼š*ˆ£«Æznz¾wvjÞRõ¶ëˆ‚aòÖ ?kæ²ð ‡g×Ñdåñ™ÅžïÕî驹’eï6k)¥ççOª@•dUj’>>»d©Ún«& Ò³Kƒ(@i’<”ÅX“}II†Öª’, Æ wÒôçsÅÅ™ýV£xOÏŸPey»Q±5ãüü2|°i’¢J²‡qš>³x2¥0òc#¨’Ä’Ç–QF›\š¬Ü…xmzOÌ-NeìÍzY ÂsËgü8ÚkÖ– S§§f›ƒtG¥Ö o*ês˧›®³ßn<>»¸˜/m6Ê)¥=q6NS'ðUIVGÑ$ÆQ ðI•^ûdiæDqºÖë‚Ö ÿ$ ±C˨’Ôõ]Žøžz<ˆãõêá‰âôsK{ÍZ×w?vâœ,ˆÍAOeV©ôÚÏ.œ(L¯Wcš~êôñ.6Ì¥n œž8—ÑŒj¿#‹4¦Üm,Íœ›^ج•Ý(øÔ™'%A¸~´[²ìž8 SB—UØàœ=úÉ8Mת‡'Š3O/žÜiVÛ®ó©ÓO(’TíuTIáÄZ¿ûøÌâB¾´U¯$4ýÈòYÄÑV£R43Í,ÔœNÛužœ[Îhúv£* ÂsKaqÎIè1ˆ¬ W a(Å;—Í›Šæž€ÉíG{½’d*“‰$d¤Ý`zßEB(Ã_ýÕ_ý³öÏÆqŒG‘”®“p^² Šñãˆr‰ÆÃ¯ †I¦1à’Ü(@i²§ÔCX@!‘’ÓaÒÑa’I,ƒJ,„'$\Ù=‹8œ ‹R”¦nÂc|]‹P:†ßÆQDº¤Œû‡8õ³á ‚è„~”&¦¢qŽ@‘v¨ñ:2BJé˜hRŒ•r ŽN×w⦢q<x…C”W‘$ÆY×sáyH¥ŒÂ7FÇs8‡­ðIWJSD!ÞvrÃ`øª¬ Ãö°1”"„I‚§­éãÖÀŽ ¸T Sì ÁiM–ûß÷½ŒfˆDhz)c9ÝþL]V Em»ŽGª$ •s®ËÊ º¾lÉ5F¼²ÒñNàÛº! äÀª(A|ܘ”RM–)gu§+ bV7»ÞöÊBÉX±‘1p…uYm¹Î ô fÜ2ÀÄô}·5p,MW%¹1èÉK”$Õ~Ô½Z®ÓõyÓ"„Tzm„PѲÝ0¨;=SÕ E©÷»a›ªñõ±Æ+Ð5K‚”ÔSVÖ‹Cx!„â4M(Õ$!~Øi ÑשHÒQ·•ÐÔR´IlBiLSQLÚMàVpB¿Úk¸MEeœí·ë¢ ÌLÛušn¿`ZŠ(í·êIšÎe ^¶ÀšaXÂNv|_MRöÛõ(I2š‘Þ)ÆšÜV†ÙH¦6âdÕývà [7 Áƒ#nëFsÐkzYÝ@Ã’4£aï·ë¦¢æ ë°Óè¸Î|®HÙnT0Æš¬DI]º¢ìµjnÌe 1Mw[5 )} 4"ãd#Ìã'%ñb ‚¡Yݨ;Ýr·5›ÍŠºÕ¨q¼+9¡¿Ó¬:Lâ0MtYojŠ%ñ$üª¥Œ†# iœ&ñ¾Ä#ËŒ¯¶nì6ë-×YÌOA,Šs¹b¥×>ì´ s HΩYÝt£p­zhkÆŒßmÖ*½öb®TÀ!M“$LîmÌP¶hfÊÝÖQ·3,ιG°.&,3’†I%IFÓç7Žv%Q\.Δ»ííFu6›7mµzÓ$oXc>Ñ‚™Ùk5ʽöraš`rãhWÀÄÖŒpHAŠ2š¾Z9„~ÑÌ$éÉ[²ìr·½ß®/æKŠ(]?܉iznz¾ã nUöAƒË£(I,Uç]?Ú9Qœ.÷Z›µò\¶`©úõ£Ý0‰‹–}»1†µ×®øš¼Z=àˆ/åK]ÏÝo×óF&£ê;Íê óÅ”Òf Q:€æQšŽä†‡ ‘&ÉÍAßC€ %·í!ô^„Žç¤Œª¢Ì8K)…ä3YUdUÑu]ÕTYQUÕu]Õ4ø¡iš¢ªÃßú𠜠jBH”$6·þÎÿñ»í¾lÃišFQE!äG>ó™?üÖû7ÿæßüØÿôçÿÎÿë—h(P †ŸúâO]¿yãcûç\’¤”Ò¿ü—ÿòþþÞoþÖoþÏŸÿŸ—––`6½³€··°°ð ¿ð 7Wnþãüá¥<éÏ<nšæ?ü‡ÿpccã+_ùÊüÀÀîê]µ©ªú…/|áÊ•+?ù“?™¦) e1Æw`tï-ãæ±wÅGþ¹ŸaÈ„Cá:Æä´aŽ FØó#˜@ªøÝ!À2Œ 1 îÔ8ü#‰b’¦„I1Å)£’(ŠDˆRŽFá7˜C¡Œ*¢D0Ó˜`¬ˆ¢ÀH”&ª$ ÏA!¤J2$ºA.¨ü*¢Ä8Gˆ«’L$ñø“†1F^h)e >àQof,ã(Œ¤²Œ2Å CL°.«’úQTS…²T}š¬@¨O—ι¡¨ÀÕl©ZB©ú–ªAø >ËÐðC>±¡hˆs]V 4ekå¬ï{–ªÉ¢§)Md4èømMW%Éñ½ŒnŠÊ9OhšÕ-„¡j–—7,7 r†¥ˆexmpÎ3ª.ŽFÇ¡ ME)ê’Œn „,U: ÓeT}¨ŽJ„¬fpÎóF¦Éz€.Ô“¸ã:¥LƇS™\sгTà‡=ßámCV‡Ž3Æ€±E)¢X?„­ ï5k:ž3•Ée4r§t6›Cå pÇÓ™\?ð-£êð´˜+5½ÙlPÀ¹Îxé&ó¹bÇÌeó¦ªwBãEÓ†è‹&É+ƒšÏ:-Qf³MVëNw1?…Òu¥+š6¼þ%A*Y6ç|.›?`!WhA¹×šËæKV–qæ†ÁbaŠ`²×ªM»`fâ4±sŒó;Ìœ‹…Bh:“'L“”éL!´\œÞmÖDAX*LYªVî¶O—f!]iüðNgrª¬H‚x¢0Ýrû'K3–ªoÑ2Bh©PâœÏfó&1mÚÎ!„ÎLÏmÕ+–©/¦TI®ôZC WJã4=]š “x«QYÌóSã¶ëœšW%y­z( ÂÉ⌭{­úÉÒÌŒ↳3ó”±õêáb¾”7,/ ó%ˆ‚Ì ¸ªççOì4ª'Š3‹ùG¼ë»çç–B3v±'ç–;ͧæO „²š$O/œÜ¨*ÍZšÎo©0]ŸÎd%AB=³xr§Y=7³ž†çç–BK…)]V%Q²|æúáî©©Ù;ïEá¹éyÆø¹™?Š(gOÎ-qÎÏNÏË¢dëÆ¹™…æ ÿÜÒiE’/înMûüü²­éëµ£Ÿ| ÜhÉüà©Ç¯lŸžbnI ä°ÓüäéÇBóù"Ìj‘ç¦ça¡+šöxΜ,ÍBˆ]•äs3ó”±'ç–¼(LhúÜÒ™^à^ÚÛóä›Ûk§KsÏ.6u½zø‰“ÖjJéÇNœE=9· (ûg—N—»­OyÒ՗ׯ—2öÇNž+Z™k‡;ÿݹ§¡1c¾ÆÇfsº‰²4ý©…œó<ç'Áä#Ëg(gÏ,žqç’i?>»W›™Ï–H„9÷ôÍÊþógŸ\.LI§ÉógÎ÷|÷µÍ•Oœ|È’ž^<‰úôÙó/¯_Ÿ’²Ÿ:óÄŒ»¸·ñ™Çc}úô³Ï=wòÔIøÇÿïô—þâÿòꫯöú½ù¹ùÏ|æ3§N(=„c³3³õgÿêÏýÕŸ Ãpwwwkkëàà ^¯»®‹1¶m{iiéüùóO=õdÎv—…F¤$pB±Xü¥_ú¥¿ù7ÿæÚÚÚÕ«W÷öö:c,—Ë=öØcÏ?ÿü„ý&!#øA¸ÛLÂ÷Ûu<‚r÷GN¼ÛÁ»îõ«>ø ¤1w|ïU£Ñ†ò=ÌÌ 1wÙö¾õßgDÜÚ‡Ü÷½š=ByxËß«eîî×½ñäÉÊ!„ü!Í™»žˆG·Ì#Vû »=úT„à÷1øïã#N¤÷<ÐÖÂ÷:¿¯Õ>d>?ßuÉ}HînËÒ}Ü¡aïÚÈG´ç{½×{Šš`ï©1¸*>ÊÓôÁW§q§Ýï^-5?êCú^M÷ 3?Ä)ñ yurÆÈí\¯á]Æ(O4‘Ð6îÝ0eí΃àäÁñû¶v\?\>¦ »·Sãã·Ç;#yãÆ9|“UÝáÒ ·M'ç=Bcô¾žÿ‡—û|׫Þ÷Éï¯1ï©<èUôûxß«î; ºn¸§þaØó_ß?Ë<|¦}ðÞ“óñÁûˆºL¿ïòa5æ}Wû}*ßÁ½÷„Éøý ÆËæøÌw½ê!ßÓU÷Þw|cÌ&ÉëÜÚU;YÕCZKF)ÑøÝ,soµl‚£ŒFÞ­ÚwmÌ=]åùŒ~ßc™ñ !4ñ?´1œ@ÆÎWAý÷½ öÞí^wWËGEîîã5Ü·1ƒìð Æ˜q6¶‡ G|âÙÇh\ÛC«}“êCyrч‘H7vŒÆÕòÑ 'À ¸V÷þõAÝS±Üu_¸|âUü.M{÷V8nɽîã¯xâ‚;NôᾦyÑýî…&Ö¦; wÏBùГo?÷Ïuû®ñ¸ëîp/4‘í7éOLz|Ÿ•t|ò诣ÚFCŽÑ]Õ¿„îi Ÿ|ò'¶ÛWÝ9ºwÕp÷ëyÔ¬}œáÒݹ©ÿjï>alé÷rÕCƒü!qŸ!»Ó2·OÀèQÏØ}«E#¢l>‰šháý¿Ñßcñª{#Á÷Ç÷Øt߯Œ ÈÑCMwŸj''Ò{ŽI<¸“ÏÂÝÃtOµwXõsæÞ>ÞñLM4ßoíº}pò¾“Atÿjï¯{«½»1÷¿j¸<Ž«ü^¿çÌ{[øjÑýìyWcn¿2î4îC,so ©ÚG°Ì}ú .ßh&Á‹õž3ñ¨…£æ#~;Áè½M&âX“¯|ÿËñð¿»®zXµ@Á~Gm“'Œ—ßû4枃ã…z8ôã¥ßw†ß]-GCóá“êkéèÆ-×ð …ý®5ü/¯û¿ò&ßn“^ém3‚‹|w Ý~£ñ”ݯÜ×·ywæ¼G‹6Ž_j¯ðn»ýI~^—ãr\ŽËq9.Ç帗ïGy$×ãr\ŽËq9.Ç帗ãòÿÏ娥;.Ç帗ãr\ŽËqùS_Ž]ºãr\ŽËq9.Ç帗?õ娥;.Ç帗ãr\ŽËqùS_Ž]ºãr\ŽËq9.Ç帗?õ娥;.Ç帗ãr\ŽËqùS_Ž]ºãr\ŽËq9.Ç帗?õ娥;.Ç帗ãr\ŽËqùS_Ž]ºãr\ŽËq9.Ç帗?õåÿêÃúUš–›IEND®B`‚ldns-1.6.17/doc/doxyparse.pl0000775000175100017510000001641612264060151015246 0ustar willemwillem#!/usr/bin/env perl # Doxygen is usefull for html documentation, but sucks # in making manual pages. Still tool also parses the .h # files with the doxygen documentation and creates # the man page we want # # 2 way process # 1. All the .h files are processed to create in file in which: # filename | API | description | return values # are documented # 2. Another file is parsed which states which function should # be grouped together in which manpage. Symlinks are also created. # # With this all in place, all documentation should be autogenerated # from the doxydoc. use Getopt::Std; my $state; my $description; my $struct_description; my $key; my $return; my $param; my $api; my $const; my %description; my %api; my %return; my %options; my %manpages; my %see_also; my $BASE="doc/man"; my $MAN_SECTION = "3"; my $MAN_HEADER = ".TH ldns $MAN_SECTION \"30 May 2006\"\n"; my $MAN_MIDDLE = ".SH AUTHOR The ldns team at NLnet Labs. Which consists out of Jelte Jansen and Miek Gieben. .SH REPORTING BUGS Please report bugs to ldns-team\@nlnetlabs.nl or in our bugzilla at http://www.nlnetlabs.nl/bugs/index.html .SH COPYRIGHT Copyright (c) 2004 - 2006 NLnet Labs. .PP Licensed under the BSD License. There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. "; my $MAN_FOOTER = ".SH REMARKS This manpage was automaticly generated from the ldns source code by use of Doxygen and some perl. "; getopts("m:",\%options); # if -m manpage file is given process that file # parse the file which tells us what manpages go together my $functions, $see_also; if (defined $options{'m'}) { # process open(MAN, "<$options{'m'}") or die "Cannot open $options{'m'}"; # it's line based: # func1, func2, .. | see_also1, see_also2, ... while() { chomp; if (/^#/) { next; } if (/^$/) { next; } ($functions, $see_also) = split /[\t ]*\|[\t ]*/, $_; #print "{$functions}\n"; #print "{$see_also}\n"; my @funcs = split /[\t ]*,[\t ]*/, $functions; my @also = split /[\t ]*,[\t ]*/, $see_also; $manpages{$funcs[0]} = \@funcs; $see_also{$funcs[0]} = \@also; #print "[", $funcs[0], "]\n"; } close(MAN); } else { print "Need -m file to process the .h files\n"; exit 1; } # 0 - somewhere in the file # 1 - in a doxygen par # 2 - after doxygen, expect function # create our pwd mkdir "doc"; mkdir "doc/man"; mkdir "doc/man/man$MAN_SECTION"; $state = 0; my $i; my @lines = ; my $max = @lines; while($i < $max) { $typedef = ""; if ($lines[$i] =~ /^typedef struct/ and $lines[$i + 1] =~ /^struct/) { # move typedef to below struct $typedef = $lines[$i]; $j = $i; while ($lines[$j] !~ /}/) { $lines[$j] = $lines[$j+1]; $j++; } $lines[$j] = $lines[$j+1]; $lines[$j + 1] = $typedef; } $cur_line = $lines[$i]; chomp($cur_line); if ($cur_line =~ /^\/\*\*[\t ]*$/) { # /** Seen #print "Comment seen! [$cur_line]\n"; $state = 1; undef $description; undef $struct_description; $i++; next; } if ($cur_line =~ /\*\// and $state == 1) { #print "END Comment seen!\n"; if ($description =~ /^\\\\file/mg) { # Doxygen text for the file, do not expect # a function coming. # $state = 0; } else { $state = 2; } $i++; next; } if ($state == 1) { # inside doxygen $cur_line =~ s/\\/\\\\/g; $cur_line =~ s/^[ \t]*\* ?//; $description = $description . "\n" . $cur_line; #$description = $description . "\n.br\n" . $cur_line; } if ($state == 2 and $cur_line =~ /const/) { # the const word exists in the function call #$const = "const"; #s/[\t ]*const[\t ]*//; } else { #undef $const; } if ($cur_line =~ /^INLINE/) { $cur_line =~ s/^INLINE\s*//; while ($cur_line !~ /{/) { $i++; $cur_line .= " ".$lines[$i]; $cur_line =~ s/\n//; } $cur_line =~ s/{/;/; } if ($cur_line =~ /^[^#*\/ ]([\w\*]+)[\t ]+(.*?)[({](.*)\s*/ and $state == 2) { while ($cur_line !~ /\)\s*;/) { $i++; $cur_line .= $lines[$i]; chomp($cur_line); $cur_line =~ s/\n/ /g; $cur_line =~ s/\s\s*/ /g; } $cur_line =~ /([\w\* ]+)[\t ]+(.*?)\((.*)\)\s*;/; # this should also end the current comment parsing $return = $1; $key = $2; $api = $3; # sometimes the * is stuck to the function # name instead to the return type if ($key =~ /^\*/) { #print"Name starts with *\n"; $key =~ s/^\*//; if (defined($const)) { $return = $const . " " . $return . '*'; } else { $return = $return . '*'; } } $description =~ s/\\param\[in\][ \t]*([\*\w]+)[ \t]+/.br\n\\fB$1\\fR: /g; $description =~ s/\\param\[out\][ \t]*([\*\w]+)[ \t]+/.br\n\\fB$1\\fR: /g; $description =~ s/\\return[ \t]*/.br\nReturns /g; # Delete leading spaces to prevent manpages to be ascii format- # ted and enable justification of text. # $description =~ s/^[ \t]*//mg; # Prevent hyphening of all caps and underscore words $description =~ s/\b([A-Z_]+)\b/\\%$1/g; $description{$key} = $description; $api{$key} = $api; $return{$key} = $return; undef $description; undef $struct_description; $state = 0; } elsif ($state == 2 and ( $cur_line =~ /^typedef\sstruct\s(\w+)\s(\w+);/ or $cur_line =~ /^typedef\senum\s(\w+)\s(\w+);/)) { $struct_description .= "\n.br\n" . $cur_line; $key = $2; $struct_description =~ s/\/\*\*\s*(.*?)\s*\*\//\\fB$1:\\fR/g; $description{$key} = $struct_description; $api{$key} = "struct"; $return{$key} = $1; undef $description; undef $struct_description; $state = 0; } else { $struct_description .= "\n.br\n" . $cur_line; } $i++; } # create the manpages foreach (keys %manpages) { $name = $manpages{$_}; $also = $see_also{$_}; $filename = @$name[0]; $filename = "$BASE/man$MAN_SECTION/$filename.$MAN_SECTION"; my $symlink_file = @$name[0] . "." . $MAN_SECTION; # print STDOUT $filename,"\n"; open (MAN, ">$filename") or die "Can not open $filename"; print MAN $MAN_HEADER; print MAN ".SH NAME\n"; print MAN join ", ", @$name; print MAN "\n\n"; print MAN ".SH SYNOPSIS\n"; print MAN "#include \n.br\n"; print MAN "#include \n.br\n"; print MAN ".PP\n"; print MAN "#include \n"; print MAN ".PP\n"; foreach (@$name) { $b = $return{$_}; $b =~ s/\s+$//; if ($api{$_} ne "struct") { print MAN $b, " ", $_; print MAN "(", $api{$_},");\n"; print MAN ".PP\n"; } } print MAN "\n.SH DESCRIPTION\n"; foreach (@$name) { print MAN ".HP\n"; print MAN "\\fI", $_, "\\fR"; if ($api{$_} ne "struct") { print MAN "()"; } # print MAN ".br\n"; print MAN $description{$_}; print MAN "\n.PP\n"; } print MAN $MAN_MIDDLE; if (defined(@$also)) { print MAN "\n.SH SEE ALSO\n\\fI"; print MAN join "\\fR, \\fI", @$also; print MAN "\\fR.\nAnd "; print MAN "\\fBperldoc Net::DNS\\fR, \\fBRFC1034\\fR, \\fBRFC1035\\fR, \\fBRFC4033\\fR, \\fBRFC4034\\fR and \\fBRFC4035\\fR.\n"; } else { print MAN ".SH SEE ALSO \\fBperldoc Net::DNS\\fR, \\fBRFC1034\\fR, \\fBRFC1035\\fR, \\fBRFC4033\\fR, \\fBRFC4034\\fR and \\fBRFC4035\\fR.\n"; } print MAN $MAN_FOOTER; # create symlinks chdir("$BASE/man$MAN_SECTION"); foreach (@$name) { print STDERR $_,"\n"; my $new_file = $_ . "." . $MAN_SECTION; if ($new_file eq $symlink_file) { next; } #print STDOUT "\t", $new_file, " -> ", $symlink_file, "\n"; symlink $symlink_file, $new_file; } chdir("../../.."); # and back, tricky and fragile... close(MAN); } ldns-1.6.17/doc/dns-lib-implementations0000664000175100017510000000414112264060151017341 0ustar willemwillemhttp://www.posadis.org/projects/poslib.php Poslib DNS library - Default branch http://www.posadis.org/poslib?DokuWiki=2b00f9da090fb9d4ad3d6e98b9c2f61f Poslib is the C++ library for applications using the Domain Name System that is used by all Posadis tools, including the Posadis DNS server and the Zoneedit and Dnsquery tools. It consists of a library for creating client applications using DNS, and a server library for DNS servers. FireDNS Library http://firestuff.org/projects/firedns FireDNS Library --------------- (c) 2002 Ian Gulliver under the GNU Public License, Version 2. See GPL for more details. From libfiredns(3): libfiredns is a library for handling asynchronous DNS requests. It provides a very simple interface for sending requests and parsing reponses, as well as low-timeout blocking functions. libfiredns functions have much lower timeouts than the stock functions and tend to be faster because they send requests to all configured system nameservers at the same time. If you have questions or comments, you can reach me at ian@penguinhosting.net. skadns Skadns is Kind of an Asynchronous DNS client software. * Kind of: it's small. Really small. But it just works. * Asynchronous: all DNS operations are non-blocking. * DNS client software: it's a DNS client, what you may know as a "stub resolver". To perform full DNS resolution, you will still need a full resolver like dnscache. Similar work * ares is an asynchronous DNS resolver library with a nice interface * and more configuration options than skadns (and a very reasonable * size). Use it if you find that skadns lacks configurability (you * shouldn't need more than it provides, but well, you're the user). * Yet it doesn't hide the DNS internals as opaquely as skadns does, * giving you a bunch of fds to select() on instead of just one. * adns works fine, and is small for a GNU project. Impressive. But * the interface is still too complex and much too generic - the * usual problems with GNU software. ADNS; documentation scares - is it still active simular aims - different ways ldns-1.6.17/doc/CodingStyle0000664000175100017510000000427612264060151015040 0ustar willemwillemThe libdns coding style guide * Use of tabs (real tabs, 8 positions long) * Spaces only after comma's, and in between operators. And after keywords (if, while, for) * Underscores to make long names readable * prefix (exported) identifiers with 'ldns_' * no unneeded parentheses after 'return' * always curly brackets in if-statements * use defines for (weird) constants, and masks * type 'bool', constants 'true'/'false'. Don't compare bools for equality. * always use LDNS_MALLOC/FREE etc, or the new/free/deep_free functions * buffer can scale, so don't alloc the max size, but the min size * make lint (uses splint) is your friend * Return values: - status code (structure to fill is usually passed as a first argument) - new/pointer: return pointer or NULL on error - 'read' functions: ldns_status wire2thing(uint8_t *p, size_t max, size_t pos, *thing); - void functions like ldns_rr_free - bool functions * Parameter sequence: (dest, [dest_meta, ] src, [src_meta] etc) * structure/union field names start with _ when "private" * enum for rcode, opcode, types etc, example: enum ldns_rcode { LDNS_RCODE_OK = 0, ... = ., LDNS_RCODE_FIRST = LDNS_RCODE_OK, LDNS_RCODE_LAST = 15, LDNS_RCODE_COUNT = LDNS_RCODE_LAST + 1 } * Everything by reference, all data structures an optional _clone() function * arrays: ps[] with size_t p_count for the number of elements * _size for size in bytes * _free and _clone copies perform deep free/copy. * Standard abbreviations, don't abbreviate other names: id = identity rr = resource record rrset = resource record set rdata = resource data rdf = resource data field rcode = result code qr = query/resource bit aa = authoritative answer tc = truncated rd = recursion disabled cd = checking disabled ra = recursion available ad = authentic data qdcount = question section count ancount = answer section count nscount = authority section count arcount = additional section count ldns- * use exit(EXIT_FAILURE)/ exit(SUCCES) * ldns-1.6.17/dname.c0000664000175100017510000003202212264060151013342 0ustar willemwillem/* * dname.c * * dname specific rdata implementations * A dname is a rdf structure with type LDNS_RDF_TYPE_DNAME * It is not a /real/ type! All function must therefor check * for LDNS_RDF_TYPE_DNAME. * * a Net::DNS like library for C * * (c) NLnet Labs, 2004-2006 * * See the file LICENSE for the license */ #include #include #ifdef HAVE_NETINET_IN_H #include #endif #ifdef HAVE_SYS_SOCKET_H #include #endif #ifdef HAVE_NETDB_H #include #endif #ifdef HAVE_ARPA_INET_H #include #endif /* Returns whether the last label in the name is a root label (a empty label). * Note that it is not enough to just test the last character to be 0, * because it may be part of the last label itself. */ static bool ldns_dname_last_label_is_root_label(const ldns_rdf* dname) { size_t src_pos; size_t len = 0; for (src_pos = 0; src_pos < ldns_rdf_size(dname); src_pos += len + 1) { len = ldns_rdf_data(dname)[src_pos]; } assert(src_pos == ldns_rdf_size(dname)); return src_pos > 0 && len == 0; } ldns_rdf * ldns_dname_cat_clone(const ldns_rdf *rd1, const ldns_rdf *rd2) { ldns_rdf *new; uint16_t new_size; uint8_t *buf; uint16_t left_size; if (ldns_rdf_get_type(rd1) != LDNS_RDF_TYPE_DNAME || ldns_rdf_get_type(rd2) != LDNS_RDF_TYPE_DNAME) { return NULL; } /* remove root label if it is present at the end of the left * rd, by reducing the size with 1 */ left_size = ldns_rdf_size(rd1); if (ldns_dname_last_label_is_root_label(rd1)) { left_size--; } /* we overwrite the nullbyte of rd1 */ new_size = left_size + ldns_rdf_size(rd2); buf = LDNS_XMALLOC(uint8_t, new_size); if (!buf) { return NULL; } /* put the two dname's after each other */ memcpy(buf, ldns_rdf_data(rd1), left_size); memcpy(buf + left_size, ldns_rdf_data(rd2), ldns_rdf_size(rd2)); new = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_DNAME, new_size, buf); LDNS_FREE(buf); return new; } ldns_status ldns_dname_cat(ldns_rdf *rd1, ldns_rdf *rd2) { uint16_t left_size; uint16_t size; uint8_t* newd; if (ldns_rdf_get_type(rd1) != LDNS_RDF_TYPE_DNAME || ldns_rdf_get_type(rd2) != LDNS_RDF_TYPE_DNAME) { return LDNS_STATUS_ERR; } /* remove root label if it is present at the end of the left * rd, by reducing the size with 1 */ left_size = ldns_rdf_size(rd1); if (ldns_dname_last_label_is_root_label(rd1)) { left_size--; } size = left_size + ldns_rdf_size(rd2); newd = LDNS_XREALLOC(ldns_rdf_data(rd1), uint8_t, size); if(!newd) { return LDNS_STATUS_MEM_ERR; } ldns_rdf_set_data(rd1, newd); memcpy(ldns_rdf_data(rd1) + left_size, ldns_rdf_data(rd2), ldns_rdf_size(rd2)); ldns_rdf_set_size(rd1, size); return LDNS_STATUS_OK; } ldns_rdf* ldns_dname_reverse(const ldns_rdf *dname) { size_t rd_size; uint8_t* buf; ldns_rdf* new; size_t src_pos; size_t len ; assert(ldns_rdf_get_type(dname) == LDNS_RDF_TYPE_DNAME); rd_size = ldns_rdf_size(dname); buf = LDNS_XMALLOC(uint8_t, rd_size); if (! buf) { return NULL; } new = ldns_rdf_new(LDNS_RDF_TYPE_DNAME, rd_size, buf); if (! new) { LDNS_FREE(buf); return NULL; } /* If dname ends in a root label, the reverse should too. */ if (ldns_dname_last_label_is_root_label(dname)) { buf[rd_size - 1] = 0; rd_size -= 1; } for (src_pos = 0; src_pos < rd_size; src_pos += len + 1) { len = ldns_rdf_data(dname)[src_pos]; memcpy(&buf[rd_size - src_pos - len - 1], &ldns_rdf_data(dname)[src_pos], len + 1); } return new; } ldns_rdf * ldns_dname_clone_from(const ldns_rdf *d, uint16_t n) { uint8_t *data; uint8_t label_size; size_t data_size; if (!d || ldns_rdf_get_type(d) != LDNS_RDF_TYPE_DNAME || ldns_dname_label_count(d) < n) { return NULL; } data = ldns_rdf_data(d); data_size = ldns_rdf_size(d); while (n > 0) { label_size = data[0] + 1; data += label_size; if (data_size < label_size) { /* this label is very broken */ return NULL; } data_size -= label_size; n--; } return ldns_dname_new_frm_data(data_size, data); } ldns_rdf * ldns_dname_left_chop(const ldns_rdf *d) { uint8_t label_pos; ldns_rdf *chop; if (!d) { return NULL; } if (ldns_rdf_get_type(d) != LDNS_RDF_TYPE_DNAME) { return NULL; } if (ldns_dname_label_count(d) == 0) { /* root label */ return NULL; } /* 05blaat02nl00 */ label_pos = ldns_rdf_data(d)[0]; chop = ldns_dname_new_frm_data(ldns_rdf_size(d) - label_pos - 1, ldns_rdf_data(d) + label_pos + 1); return chop; } uint8_t ldns_dname_label_count(const ldns_rdf *r) { uint16_t src_pos; uint16_t len; uint8_t i; size_t r_size; if (!r) { return 0; } i = 0; src_pos = 0; r_size = ldns_rdf_size(r); if (ldns_rdf_get_type(r) != LDNS_RDF_TYPE_DNAME) { return 0; } else { len = ldns_rdf_data(r)[src_pos]; /* start of the label */ /* single root label */ if (1 == r_size) { return 0; } else { while ((len > 0) && src_pos < r_size) { src_pos++; src_pos += len; len = ldns_rdf_data(r)[src_pos]; i++; } } } return i; } ldns_rdf * ldns_dname_new(uint16_t s, void *d) { ldns_rdf *rd; rd = LDNS_MALLOC(ldns_rdf); if (!rd) { return NULL; } ldns_rdf_set_size(rd, s); ldns_rdf_set_type(rd, LDNS_RDF_TYPE_DNAME); ldns_rdf_set_data(rd, d); return rd; } ldns_rdf * ldns_dname_new_frm_str(const char *str) { return ldns_rdf_new_frm_str(LDNS_RDF_TYPE_DNAME, str); } ldns_rdf * ldns_dname_new_frm_data(uint16_t size, const void *data) { return ldns_rdf_new_frm_data(LDNS_RDF_TYPE_DNAME, size, data); } void ldns_dname2canonical(const ldns_rdf *rd) { uint8_t *rdd; uint16_t i; if (ldns_rdf_get_type(rd) != LDNS_RDF_TYPE_DNAME) { return; } rdd = (uint8_t*)ldns_rdf_data(rd); for (i = 0; i < ldns_rdf_size(rd); i++, rdd++) { *rdd = (uint8_t)LDNS_DNAME_NORMALIZE((int)*rdd); } } bool ldns_dname_is_subdomain(const ldns_rdf *sub, const ldns_rdf *parent) { uint8_t sub_lab; uint8_t par_lab; int8_t i, j; ldns_rdf *tmp_sub = NULL; ldns_rdf *tmp_par = NULL; ldns_rdf *sub_clone; ldns_rdf *parent_clone; bool result = true; if (ldns_rdf_get_type(sub) != LDNS_RDF_TYPE_DNAME || ldns_rdf_get_type(parent) != LDNS_RDF_TYPE_DNAME || ldns_rdf_compare(sub, parent) == 0) { return false; } /* would be nicer if we do not have to clone... */ sub_clone = ldns_dname_clone_from(sub, 0); parent_clone = ldns_dname_clone_from(parent, 0); ldns_dname2canonical(sub_clone); ldns_dname2canonical(parent_clone); sub_lab = ldns_dname_label_count(sub_clone); par_lab = ldns_dname_label_count(parent_clone); /* if sub sits above parent, it cannot be a child/sub domain */ if (sub_lab < par_lab) { result = false; } else { /* check all labels the from the parent labels, from right to left. * When they /all/ match we have found a subdomain */ j = sub_lab - 1; /* we count from zero, thank you */ for (i = par_lab -1; i >= 0; i--) { tmp_sub = ldns_dname_label(sub_clone, j); tmp_par = ldns_dname_label(parent_clone, i); if (!tmp_sub || !tmp_par) { /* deep free does null check */ ldns_rdf_deep_free(tmp_sub); ldns_rdf_deep_free(tmp_par); result = false; break; } if (ldns_rdf_compare(tmp_sub, tmp_par) != 0) { /* they are not equal */ ldns_rdf_deep_free(tmp_sub); ldns_rdf_deep_free(tmp_par); result = false; break; } ldns_rdf_deep_free(tmp_sub); ldns_rdf_deep_free(tmp_par); j--; } } ldns_rdf_deep_free(sub_clone); ldns_rdf_deep_free(parent_clone); return result; } int ldns_dname_compare(const ldns_rdf *dname1, const ldns_rdf *dname2) { size_t lc1, lc2, lc1f, lc2f; size_t i; int result = 0; uint8_t *lp1, *lp2; /* see RFC4034 for this algorithm */ /* this algorithm assumes the names are normalized to case */ /* only when both are not NULL we can say anything about them */ if (!dname1 && !dname2) { return 0; } if (!dname1 || !dname2) { return -1; } /* asserts must happen later as we are looking in the * dname, which could be NULL. But this case is handled * above */ assert(ldns_rdf_get_type(dname1) == LDNS_RDF_TYPE_DNAME); assert(ldns_rdf_get_type(dname2) == LDNS_RDF_TYPE_DNAME); lc1 = ldns_dname_label_count(dname1); lc2 = ldns_dname_label_count(dname2); if (lc1 == 0 && lc2 == 0) { return 0; } if (lc1 == 0) { return -1; } if (lc2 == 0) { return 1; } lc1--; lc2--; /* we start at the last label */ while (true) { /* find the label first */ lc1f = lc1; lp1 = ldns_rdf_data(dname1); while (lc1f > 0) { lp1 += *lp1 + 1; lc1f--; } /* and find the other one */ lc2f = lc2; lp2 = ldns_rdf_data(dname2); while (lc2f > 0) { lp2 += *lp2 + 1; lc2f--; } /* now check the label character for character. */ for (i = 1; i < (size_t)(*lp1 + 1); i++) { if (i > *lp2) { /* apparently label 1 is larger */ result = 1; goto done; } if (LDNS_DNAME_NORMALIZE((int) *(lp1 + i)) < LDNS_DNAME_NORMALIZE((int) *(lp2 + i))) { result = -1; goto done; } else if (LDNS_DNAME_NORMALIZE((int) *(lp1 + i)) > LDNS_DNAME_NORMALIZE((int) *(lp2 + i))) { result = 1; goto done; } } if (*lp1 < *lp2) { /* apparently label 2 is larger */ result = -1; goto done; } if (lc1 == 0 && lc2 > 0) { result = -1; goto done; } else if (lc1 > 0 && lc2 == 0) { result = 1; goto done; } else if (lc1 == 0 && lc2 == 0) { result = 0; goto done; } lc1--; lc2--; } done: return result; } int ldns_dname_is_wildcard(const ldns_rdf* dname) { return ( ldns_dname_label_count(dname) > 0 && ldns_rdf_data(dname)[0] == 1 && ldns_rdf_data(dname)[1] == '*'); } int ldns_dname_match_wildcard(const ldns_rdf *dname, const ldns_rdf *wildcard) { ldns_rdf *wc_chopped; int result; /* check whether it really is a wildcard */ if (ldns_dname_is_wildcard(wildcard)) { /* ok, so the dname needs to be a subdomain of the wildcard * without the * */ wc_chopped = ldns_dname_left_chop(wildcard); result = (int) ldns_dname_is_subdomain(dname, wc_chopped); ldns_rdf_deep_free(wc_chopped); } else { result = (ldns_dname_compare(dname, wildcard) == 0); } return result; } /* nsec test: does prev <= middle < next * -1 = yes * 0 = error/can't tell * 1 = no */ int ldns_dname_interval(const ldns_rdf *prev, const ldns_rdf *middle, const ldns_rdf *next) { int prev_check, next_check; assert(ldns_rdf_get_type(prev) == LDNS_RDF_TYPE_DNAME); assert(ldns_rdf_get_type(middle) == LDNS_RDF_TYPE_DNAME); assert(ldns_rdf_get_type(next) == LDNS_RDF_TYPE_DNAME); prev_check = ldns_dname_compare(prev, middle); next_check = ldns_dname_compare(middle, next); /* <= next. This cannot be the case for nsec, because then we would * have gotten the nsec of next... */ if (next_check == 0) { return 0; } /* <= */ if ((prev_check == -1 || prev_check == 0) && /* < */ next_check == -1) { return -1; } else { return 1; } } bool ldns_dname_str_absolute(const char *dname_str) { const char* s; if(dname_str && strcmp(dname_str, ".") == 0) return 1; if(!dname_str || strlen(dname_str) < 2) return 0; if(dname_str[strlen(dname_str) - 1] != '.') return 0; if(dname_str[strlen(dname_str) - 2] != '\\') return 1; /* ends in . and no \ before it */ /* so we have the case of ends in . and there is \ before it */ for(s=dname_str; *s; s++) { if(*s == '\\') { if(s[1] && s[2] && s[3] /* check length */ && isdigit(s[1]) && isdigit(s[2]) && isdigit(s[3])) s += 3; else if(!s[1] || isdigit(s[1])) /* escape of nul,0-9 */ return 0; /* parse error */ else s++; /* another character escaped */ } else if(!*(s+1) && *s == '.') return 1; /* trailing dot, unescaped */ } return 0; } bool ldns_dname_absolute(const ldns_rdf *rdf) { char *str = ldns_rdf2str(rdf); if (str) { bool r = ldns_dname_str_absolute(str); LDNS_FREE(str); return r; } return false; } ldns_rdf * ldns_dname_label(const ldns_rdf *rdf, uint8_t labelpos) { uint8_t labelcnt; uint16_t src_pos; uint16_t len; ldns_rdf *tmpnew; size_t s; uint8_t *data; if (ldns_rdf_get_type(rdf) != LDNS_RDF_TYPE_DNAME) { return NULL; } labelcnt = 0; src_pos = 0; s = ldns_rdf_size(rdf); len = ldns_rdf_data(rdf)[src_pos]; /* label start */ while ((len > 0) && src_pos < s) { if (labelcnt == labelpos) { /* found our label */ data = LDNS_XMALLOC(uint8_t, len + 2); if (!data) { return NULL; } memcpy(data, ldns_rdf_data(rdf) + src_pos, len + 1); data[len + 2 - 1] = 0; tmpnew = ldns_rdf_new( LDNS_RDF_TYPE_DNAME , len + 2, data); if (!tmpnew) { LDNS_FREE(data); return NULL; } return tmpnew; } src_pos++; src_pos += len; len = ldns_rdf_data(rdf)[src_pos]; labelcnt++; } return NULL; } ldns-1.6.17/acx_nlnetlabs.m40000664000175100017510000011620212264060151015174 0ustar willemwillem# acx_nlnetlabs.m4 - common macros for configure checks # Copyright 2009, Wouter Wijngaards, NLnet Labs. # BSD licensed. # # Version 26 # 2013-09-19 FLTO help text improved. # 2013-07-18 Enable ACX_CHECK_COMPILER_FLAG to test for -Wstrict-prototypes # 2013-06-25 FLTO has --disable-flto option. # 2013-05-03 Update W32_SLEEP for newer mingw that links but not defines it. # 2013-03-22 Fix ACX_RSRC_VERSION for long version numbers. # 2012-02-09 Fix AHX_MEMCMP_BROKEN with undef in compat/memcmp.h. # 2012-01-20 Fix COMPILER_FLAGS_UNBOUND for gcc 4.6.2 assigned-not-used-warns. # 2011-12-05 Fix getaddrinfowithincludes on windows with fedora16 mingw32-gcc. # Fix ACX_MALLOC for redefined malloc error. # Fix GETADDRINFO_WITH_INCLUDES to add -lws2_32 # 2011-11-10 Fix FLTO test to not drop a.out in current directory. # 2011-11-01 Fix FLTO test for llvm on Lion. # 2011-08-01 Fix nonblock test (broken at v13). # 2011-08-01 Fix autoconf 2.68 warnings # 2011-06-23 Add ACX_CHECK_FLTO to check -flto. # 2010-08-16 Fix FLAG_OMITTED for AS_TR_CPP changes in autoconf-2.66. # 2010-07-02 Add check for ss_family (for minix). # 2010-04-26 Fix to use CPPFLAGS for CHECK_COMPILER_FLAGS. # 2010-03-01 Fix RPATH using CONFIG_COMMANDS to run at the very end. # 2010-02-18 WITH_SSL outputs the LIBSSL_LDFLAGS, LIBS, CPPFLAGS separate, -ldl # 2010-02-01 added ACX_CHECK_MEMCMP_SIGNED, AHX_MEMCMP_BROKEN # 2010-01-20 added AHX_COONFIG_STRLCAT # 2009-07-14 U_CHAR detection improved for windows crosscompile. # added ACX_FUNC_MALLOC # fixup some #if to #ifdef # NONBLOCKING test for mingw crosscompile. # 2009-07-13 added ACX_WITH_SSL_OPTIONAL # 2009-07-03 fixup LDFLAGS for empty ssl dir. # # Automates some of the checking constructs. Aims at portability for POSIX. # Documentation for functions is below. # # the following macro's are provided in this file: # (see below for details on each macro). # # ACX_ESCAPE_BACKSLASH - escape backslashes in var for C-preproc. # ACX_RSRC_VERSION - create windows resource version number. # ACX_CHECK_COMPILER_FLAG - see if cc supports a flag. # ACX_CHECK_ERROR_FLAGS - see which flag is -werror (used below). # ACX_CHECK_COMPILER_FLAG_NEEDED - see if flags make the code compile cleanly. # ACX_DEPFLAG - find cc dependency flags. # ACX_DETERMINE_EXT_FLAGS_UNBOUND - find out which flags enable BSD and POSIX. # ACX_CHECK_FORMAT_ATTRIBUTE - find cc printf format syntax. # ACX_CHECK_UNUSED_ATTRIBUTE - find cc variable unused syntax. # ACX_CHECK_FLTO - see if cc supports -flto and use it if so. # ACX_LIBTOOL_C_ONLY - create libtool for C only, improved. # ACX_TYPE_U_CHAR - u_char type. # ACX_TYPE_RLIM_T - rlim_t type. # ACX_TYPE_SOCKLEN_T - socklen_t type. # ACX_TYPE_IN_ADDR_T - in_addr_t type. # ACX_TYPE_IN_PORT_T - in_port_t type. # ACX_ARG_RPATH - add --disable-rpath option. # ACX_WITH_SSL - add --with-ssl option, link -lcrypto. # ACX_WITH_SSL_OPTIONAL - add --with-ssl option, link -lcrypto, # where --without-ssl is also accepted # ACX_LIB_SSL - setup to link -lssl. # ACX_SYS_LARGEFILE - improved sys_largefile, fseeko, >2G files. # ACX_CHECK_GETADDRINFO_WITH_INCLUDES - find getaddrinfo, portably. # ACX_FUNC_DEPRECATED - see if func is deprecated. # ACX_CHECK_NONBLOCKING_BROKEN - see if nonblocking sockets really work. # ACX_MKDIR_ONE_ARG - determine mkdir(2) number of arguments. # ACX_FUNC_IOCTLSOCKET - find ioctlsocket, portably. # ACX_FUNC_MALLOC - check malloc, define replacement . # AHX_CONFIG_FORMAT_ATTRIBUTE - config.h text for format. # AHX_CONFIG_UNUSED_ATTRIBUTE - config.h text for unused. # AHX_CONFIG_FSEEKO - define fseeko, ftello fallback. # AHX_CONFIG_RAND_MAX - define RAND_MAX if needed. # AHX_CONFIG_MAXHOSTNAMELEN - define MAXHOSTNAMELEN if needed. # AHX_CONFIG_IPV6_MIN_MTU - define IPV6_MIN_MTU if needed. # AHX_CONFIG_SNPRINTF - snprintf compat prototype # AHX_CONFIG_INET_PTON - inet_pton compat prototype # AHX_CONFIG_INET_NTOP - inet_ntop compat prototype # AHX_CONFIG_INET_ATON - inet_aton compat prototype # AHX_CONFIG_MEMMOVE - memmove compat prototype # AHX_CONFIG_STRLCAT - strlcat compat prototype # AHX_CONFIG_STRLCPY - strlcpy compat prototype # AHX_CONFIG_GMTIME_R - gmtime_r compat prototype # AHX_CONFIG_W32_SLEEP - w32 compat for sleep # AHX_CONFIG_W32_USLEEP - w32 compat for usleep # AHX_CONFIG_W32_RANDOM - w32 compat for random # AHX_CONFIG_W32_SRANDOM - w32 compat for srandom # AHX_CONFIG_W32_FD_SET_T - w32 detection of FD_SET_T. # ACX_CFLAGS_STRIP - strip one flag from CFLAGS # ACX_STRIP_EXT_FLAGS - strip extension flags from CFLAGS # AHX_CONFIG_FLAG_OMITTED - define omitted flag # AHX_CONFIG_FLAG_EXT - define omitted extension flag # AHX_CONFIG_EXT_FLAGS - define the stripped extension flags # ACX_CHECK_MEMCMP_SIGNED - check if memcmp uses signed characters. # AHX_MEMCMP_BROKEN - replace memcmp func for CHECK_MEMCMP_SIGNED. # ACX_CHECK_SS_FAMILY - check for sockaddr_storage.ss_family # dnl Escape backslashes as \\, for C:\ paths, for the C preprocessor defines. dnl for example, ACX_ESCAPE_BACKSLASH($from_var, to_var) dnl $1: the text to change. dnl $2: the result. AC_DEFUN([ACX_ESCAPE_BACKSLASH], [$2="`echo $1 | sed -e 's/\\\\/\\\\\\\\/g'`" ]) dnl Calculate comma separated windows-resource numbers from package version. dnl Picks the first three(,0) or four numbers out of the name. dnl $1: variable for the result AC_DEFUN([ACX_RSRC_VERSION], [$1=[`echo $PACKAGE_VERSION | sed -e 's/^[^0-9]*\([0-9][0-9]*\)[^0-9][^0-9]*\([0-9][0-9]*\)[^0-9][^0-9]*\([0-9][0-9]*\)[^0-9][^0-9]*\([0-9][0-9]*\).*$/\1,\2,\3,\4/' -e 's/^[^0-9]*\([0-9][0-9]*\)[^0-9][^0-9]*\([0-9][0-9]*\)[^0-9][^0-9]*\([0-9][0-9]*\)[^0-9]*$/\1,\2,\3,0/' `] ]) dnl Routine to help check for compiler flags. dnl Checks if the compiler will accept the flag. dnl $1: the flag without a - in front, so g to check -g. dnl $2: executed if yes dnl $3: executed if no AC_DEFUN([ACX_CHECK_COMPILER_FLAG], [ AC_REQUIRE([AC_PROG_CC]) AC_MSG_CHECKING(whether $CC supports -$1) cache=`echo $1 | sed 'y%.=/+-%___p_%'` AC_CACHE_VAL(cv_prog_cc_flag_$cache, [ echo 'void f(void){}' >conftest.c if test -z "`$CC $CPPFLAGS $CFLAGS -$1 -c conftest.c 2>&1`"; then eval "cv_prog_cc_flag_$cache=yes" else eval "cv_prog_cc_flag_$cache=no" fi rm -f conftest conftest.o conftest.c ]) if eval "test \"`echo '$cv_prog_cc_flag_'$cache`\" = yes"; then AC_MSG_RESULT(yes) : $2 else AC_MSG_RESULT(no) : $3 fi ]) dnl setup flags for ACX_CHECK_COMPILER_FLAG_NEEDED dnl ERRFLAG: result, compiler flag to turn warnings into errors AC_DEFUN([ACX_CHECK_ERROR_FLAGS], [ ACX_CHECK_COMPILER_FLAG(Werror, [ERRFLAG="-Werror"], [ERRFLAG="-errwarn"]) ACX_CHECK_COMPILER_FLAG(Wall, [ERRFLAG="$ERRFLAG -Wall"], [ERRFLAG="$ERRFLAG -errfmt"]) ]) dnl Routine to help check for needed compiler flags. dnl $1: flags for CC dnl $2: the includes and code dnl $3: if the given code only compiles with the flag, execute argument 3 dnl $4: if the given code compiles without the flag, execute argument 4 dnl $5: with and without flag the compile fails, execute argument 5. AC_DEFUN([ACX_CHECK_COMPILER_FLAG_NEEDED], [ AC_REQUIRE([AC_PROG_CC]) AC_REQUIRE([ACX_CHECK_ERROR_FLAGS]) AC_MSG_CHECKING(whether we need $1 as a flag for $CC) cache=AS_TR_SH($1) dnl cache=`echo $1 | sed 'y%.=/+- %___p__%'` AC_CACHE_VAL(cv_prog_cc_flag_needed_$cache, [ echo '$2' > conftest.c echo 'void f(){}' >>conftest.c if test -z "`$CC $CPPFLAGS $CFLAGS $ERRFLAG -c conftest.c 2>&1`"; then eval "cv_prog_cc_flag_needed_$cache=no" else [ if test -z "`$CC $CPPFLAGS $CFLAGS $1 $ERRFLAG -c conftest.c 2>&1`"; then eval "cv_prog_cc_flag_needed_$cache=yes" else eval "cv_prog_cc_flag_needed_$cache=fail" #echo 'Test with flag fails too!' #cat conftest.c #echo "$CC $CPPFLAGS $CFLAGS $1 $ERRFLAG -c conftest.c 2>&1" #echo `$CC $CPPFLAGS $CFLAGS $1 $ERRFLAG -c conftest.c 2>&1` #exit 1 fi ] fi rm -f conftest conftest.c conftest.o ]) if eval "test \"`echo '$cv_prog_cc_flag_needed_'$cache`\" = yes"; then AC_MSG_RESULT(yes) : $3 else if eval "test \"`echo '$cv_prog_cc_flag_needed_'$cache`\" = no"; then AC_MSG_RESULT(no) #echo 'Test with flag is no!' #cat conftest.c #echo "$CC $CPPFLAGS $CFLAGS $1 $ERRFLAG -c conftest.c 2>&1" #echo `$CC $CPPFLAGS $CFLAGS $1 $ERRFLAG -c conftest.c 2>&1` #exit 1 : $4 else AC_MSG_RESULT(failed) : $5 fi fi ]) dnl Check for CC dependency flag dnl DEPFLAG: set to flag that generates dependencies. AC_DEFUN([ACX_DEPFLAG], [ AC_MSG_CHECKING([$CC dependency flag]) echo 'void f(){}' >conftest.c if test "`$CC -MM conftest.c 2>&1`" = "conftest.o: conftest.c"; then DEPFLAG="-MM" else if test "`$CC -xM1 conftest.c 2>&1`" = "conftest.o: conftest.c"; then DEPFLAG="-xM1" else DEPFLAG="-MM" # dunno do something fi fi AC_MSG_RESULT($DEPFLAG) rm -f conftest.c AC_SUBST(DEPFLAG) ]) dnl Determine flags that gives POSIX and BSD functionality. dnl CFLAGS is modified for the result. AC_DEFUN([ACX_DETERMINE_EXT_FLAGS_UNBOUND], [ ACX_CHECK_COMPILER_FLAG(std=c99, [C99FLAG="-std=c99"]) ACX_CHECK_COMPILER_FLAG(xc99, [C99FLAG="-xc99"]) AC_CHECK_HEADERS([getopt.h time.h],,, [AC_INCLUDES_DEFAULT]) ACX_CHECK_COMPILER_FLAG_NEEDED($C99FLAG -D__EXTENSIONS__ -D_BSD_SOURCE -D_POSIX_C_SOURCE=200112 -D_XOPEN_SOURCE=600 -D_XOPEN_SOURCE_EXTENDED=1 -D_ALL_SOURCE, [ #include "confdefs.h" #include #include #include #ifdef HAVE_TIME_H #include #endif #include #include #ifdef HAVE_GETOPT_H #include #endif int test() { int a; char **opts = NULL; struct timeval tv; char *t; time_t time = 0; char *buf = NULL; const char* str = NULL; struct msghdr msg; msg.msg_control = 0; t = ctime_r(&time, buf); tv.tv_usec = 10; srandom(32); a = getopt(2, opts, "a"); a = isascii(32); str = gai_strerror(0); if(str && t && tv.tv_usec && msg.msg_control) a = 0; return a; } ], [CFLAGS="$CFLAGS $C99FLAG -D__EXTENSIONS__ -D_BSD_SOURCE -D_POSIX_C_SOURCE=200112 -D_XOPEN_SOURCE=600 -D_XOPEN_SOURCE_EXTENDED=1 -D_ALL_SOURCE"]) ACX_CHECK_COMPILER_FLAG_NEEDED($C99FLAG -D__EXTENSIONS__ -D_BSD_SOURCE -D_POSIX_C_SOURCE=200112 -D_XOPEN_SOURCE=600 -D_ALL_SOURCE, [ #include "confdefs.h" #include #include #include #ifdef HAVE_TIME_H #include #endif #include #include #ifdef HAVE_GETOPT_H #include #endif int test() { int a; char **opts = NULL; struct timeval tv; char *t; time_t time = 0; char *buf = NULL; const char* str = NULL; struct msghdr msg; msg.msg_control = 0; t = ctime_r(&time, buf); tv.tv_usec = 10; srandom(32); a = getopt(2, opts, "a"); a = isascii(32); str = gai_strerror(0); if(str && t && tv.tv_usec && msg.msg_control) a = 0; return a; } ], [CFLAGS="$CFLAGS $C99FLAG -D__EXTENSIONS__ -D_BSD_SOURCE -D_POSIX_C_SOURCE=200112 -D_XOPEN_SOURCE=600 -D_ALL_SOURCE"]) ACX_CHECK_COMPILER_FLAG_NEEDED($C99FLAG, [ #include #include int test() { int a = 0; return a; } ], [CFLAGS="$CFLAGS $C99FLAG"]) ACX_CHECK_COMPILER_FLAG_NEEDED(-D_BSD_SOURCE, [ #include int test() { int a; a = isascii(32); return a; } ], [CFLAGS="$CFLAGS -D_BSD_SOURCE"]) ACX_CHECK_COMPILER_FLAG_NEEDED(-D_GNU_SOURCE, [ #include int test() { struct in6_pktinfo inf; int a = (int)sizeof(inf); return a; } ], [CFLAGS="$CFLAGS -D_GNU_SOURCE"]) # check again for GNU_SOURCE for setresgid. May fail if setresgid # is not available at all. -D_FRSRESGID is to make this check unique. # otherwise we would get the previous cached result. ACX_CHECK_COMPILER_FLAG_NEEDED(-D_GNU_SOURCE -D_FRSRESGID, [ #include int test() { int a = setresgid(0,0,0); a = setresuid(0,0,0); return a; } ], [CFLAGS="$CFLAGS -D_GNU_SOURCE"]) ACX_CHECK_COMPILER_FLAG_NEEDED(-D_POSIX_C_SOURCE=200112, [ #include "confdefs.h" #ifdef HAVE_TIME_H #include #endif #include int test() { int a = 0; char *t; time_t time = 0; char *buf = NULL; const char* str = NULL; t = ctime_r(&time, buf); str = gai_strerror(0); if(t && str) a = 0; return a; } ], [CFLAGS="$CFLAGS -D_POSIX_C_SOURCE=200112"]) ACX_CHECK_COMPILER_FLAG_NEEDED(-D__EXTENSIONS__, [ #include "confdefs.h" #include #include #include #ifdef HAVE_TIME_H #include #endif #include #ifdef HAVE_GETOPT_H #include #endif int test() { int a; char **opts = NULL; struct timeval tv; tv.tv_usec = 10; srandom(32); a = getopt(2, opts, "a"); a = isascii(32); if(tv.tv_usec) a = 0; return a; } ], [CFLAGS="$CFLAGS -D__EXTENSIONS__"]) ])dnl End of ACX_DETERMINE_EXT_FLAGS_UNBOUND dnl Check if CC supports -flto. dnl in a way that supports clang and suncc (that flag does something else, dnl but fails to link). It sets it in CFLAGS if it works. AC_DEFUN([ACX_CHECK_FLTO], [ AC_ARG_ENABLE([flto], AS_HELP_STRING([--disable-flto], [Disable link-time optimization (gcc specific option)])) AS_IF([test "x$enable_flto" != "xno"], [ AC_MSG_CHECKING([if $CC supports -flto]) BAKCFLAGS="$CFLAGS" CFLAGS="$CFLAGS -flto" AC_LINK_IFELSE([AC_LANG_PROGRAM([], [])], [ if $CC $CFLAGS -o conftest conftest.c 2>&1 | grep "warning: no debug symbols in executable" >/dev/null; then CFLAGS="$BAKCFLAGS" AC_MSG_RESULT(no) else AC_MSG_RESULT(yes) fi rm -f conftest conftest.c conftest.o ], [CFLAGS="$BAKCFLAGS" ; AC_MSG_RESULT(no)]) ]) ]) dnl Check the printf-format attribute (if any) dnl result in HAVE_ATTR_FORMAT. dnl Make sure you also include the AHX_CONFIG_FORMAT_ATTRIBUTE. AC_DEFUN([ACX_CHECK_FORMAT_ATTRIBUTE], [AC_REQUIRE([AC_PROG_CC]) AC_MSG_CHECKING(whether the C compiler (${CC-cc}) accepts the "format" attribute) AC_CACHE_VAL(ac_cv_c_format_attribute, [ac_cv_c_format_attribute=no AC_TRY_COMPILE( [#include void f (char *format, ...) __attribute__ ((format (printf, 1, 2))); void (*pf) (char *format, ...) __attribute__ ((format (printf, 1, 2))); ], [ f ("%s", "str"); ], [ac_cv_c_format_attribute="yes"], [ac_cv_c_format_attribute="no"]) ]) AC_MSG_RESULT($ac_cv_c_format_attribute) if test $ac_cv_c_format_attribute = yes; then AC_DEFINE(HAVE_ATTR_FORMAT, 1, [Whether the C compiler accepts the "format" attribute]) fi ])dnl End of ACX_CHECK_FORMAT_ATTRIBUTE dnl Setup ATTR_FORMAT config.h parts. dnl make sure you call ACX_CHECK_FORMAT_ATTRIBUTE also. AC_DEFUN([AHX_CONFIG_FORMAT_ATTRIBUTE], [ #ifdef HAVE_ATTR_FORMAT # define ATTR_FORMAT(archetype, string_index, first_to_check) \ __attribute__ ((format (archetype, string_index, first_to_check))) #else /* !HAVE_ATTR_FORMAT */ # define ATTR_FORMAT(archetype, string_index, first_to_check) /* empty */ #endif /* !HAVE_ATTR_FORMAT */ ]) dnl Check how to mark function arguments as unused. dnl result in HAVE_ATTR_UNUSED. dnl Make sure you include AHX_CONFIG_UNUSED_ATTRIBUTE also. AC_DEFUN([ACX_CHECK_UNUSED_ATTRIBUTE], [AC_REQUIRE([AC_PROG_CC]) AC_MSG_CHECKING(whether the C compiler (${CC-cc}) accepts the "unused" attribute) AC_CACHE_VAL(ac_cv_c_unused_attribute, [ac_cv_c_unused_attribute=no AC_TRY_COMPILE( [#include void f (char *u __attribute__((unused))); ], [ f ("x"); ], [ac_cv_c_unused_attribute="yes"], [ac_cv_c_unused_attribute="no"]) ]) dnl Setup ATTR_UNUSED config.h parts. dnl make sure you call ACX_CHECK_UNUSED_ATTRIBUTE also. AC_DEFUN([AHX_CONFIG_UNUSED_ATTRIBUTE], [ #if defined(DOXYGEN) # define ATTR_UNUSED(x) x #elif defined(__cplusplus) # define ATTR_UNUSED(x) #elif defined(HAVE_ATTR_UNUSED) # define ATTR_UNUSED(x) x __attribute__((unused)) #else /* !HAVE_ATTR_UNUSED */ # define ATTR_UNUSED(x) x #endif /* !HAVE_ATTR_UNUSED */ ]) AC_MSG_RESULT($ac_cv_c_unused_attribute) if test $ac_cv_c_unused_attribute = yes; then AC_DEFINE(HAVE_ATTR_UNUSED, 1, [Whether the C compiler accepts the "unused" attribute]) fi ])dnl dnl Pre-fun for ACX_LIBTOOL_C_ONLY AC_DEFUN([ACX_LIBTOOL_C_PRE], [ # skip these tests, we do not need them. AC_DEFUN([AC_PROG_F77], [:]) AC_DEFUN([AC_PROG_FC], [:]) AC_DEFUN([AC_PROG_CXX], [:]) AC_DEFUN([AC_PROG_CXXCPP], [:]) AC_DEFUN([AC_PROG_OBJC], [:]) AC_DEFUN([AC_PROG_OBJCCPP], [:]) AC_DEFUN([AC_LIBTOOL_CXX], [:]) AC_DEFUN([AC_LIBTOOL_F77], [:]) # always use ./libtool unless override from commandline (libtool=mylibtool) if test -z "$libtool"; then libtool="./libtool" fi AC_SUBST(libtool) # avoid libtool max commandline length test on systems that fork slowly. AC_CANONICAL_HOST if echo "$host_os" | grep "sunos4" >/dev/null; then lt_cv_sys_max_cmd_len=32750; fi AC_PATH_TOOL(AR, ar, [false]) if test $AR = false; then AC_MSG_ERROR([Cannot find 'ar', please extend PATH to include it]) fi ]) dnl Perform libtool check, portably, only for C AC_DEFUN([ACX_LIBTOOL_C_ONLY], [ dnl as a requirement so that is gets called before LIBTOOL dnl because libtools 'AC_REQUIRE' names are right after this one, before dnl this function contents. AC_REQUIRE([ACX_LIBTOOL_C_PRE]) AC_PROG_LIBTOOL ]) dnl Detect if u_char type is defined, otherwise define it. AC_DEFUN([ACX_TYPE_U_CHAR], [AC_CHECK_TYPE([u_char], , [AC_DEFINE([u_char], [unsigned char], [Define to 'unsigned char if not defined])], [ AC_INCLUDES_DEFAULT #ifdef HAVE_WINSOCK2_H # include #endif ]) ]) dnl Detect if rlim_t type is defined, otherwise define it. AC_DEFUN([ACX_TYPE_RLIM_T], [AC_CHECK_TYPE(rlim_t, , [AC_DEFINE([rlim_t], [unsigned long], [Define to 'int' if not defined])], [ AC_INCLUDES_DEFAULT #ifdef HAVE_SYS_RESOURCE_H # include #endif ]) ]) dnl Detect if socklen_t type is defined, otherwise define it. AC_DEFUN([ACX_TYPE_SOCKLEN_T], [ AC_CHECK_TYPE(socklen_t, , [AC_DEFINE([socklen_t], [int], [Define to 'int' if not defined])], [ AC_INCLUDES_DEFAULT #ifdef HAVE_SYS_SOCKET_H # include #endif #ifdef HAVE_WS2TCPIP_H # include #endif ]) ]) dnl Detect if in_addr_t type is defined, otherwise define it. AC_DEFUN([ACX_TYPE_IN_ADDR_T], [ AC_CHECK_TYPE(in_addr_t, [], [AC_DEFINE([in_addr_t], [uint32_t], [in_addr_t])], [ AC_INCLUDES_DEFAULT #ifdef HAVE_SYS_TYPES_H # include #endif #ifdef HAVE_NETINET_IN_H # include #endif ]) ]) dnl Detect if in_port_t type is defined, otherwise define it. AC_DEFUN([ACX_TYPE_IN_PORT_T], [ AC_CHECK_TYPE(in_port_t, [], [AC_DEFINE([in_port_t], [uint16_t], [in_port_t])], [ AC_INCLUDES_DEFAULT #ifdef HAVE_SYS_TYPES_H # include #endif #ifdef HAVE_NETINET_IN_H # include #endif ]) ]) dnl Add option to disable the evil rpath. Check whether to use rpath or not. dnl Adds the --disable-rpath option. Uses trick to edit the ./libtool. AC_DEFUN([ACX_ARG_RPATH], [ AC_ARG_ENABLE(rpath, [ --disable-rpath disable hardcoded rpath (default=enabled)], enable_rpath=$enableval, enable_rpath=yes) if test "x$enable_rpath" = xno; then dnl AC_MSG_RESULT([Fixing libtool for -rpath problems.]) AC_CONFIG_COMMANDS([disable-rpath], [ sed < libtool > libtool-2 \ 's/^hardcode_libdir_flag_spec.*$'/'hardcode_libdir_flag_spec=" -D__LIBTOOL_RPATH_SED__ "/' mv libtool-2 libtool chmod 755 libtool libtool="./libtool" ]) fi ]) dnl Add a -R to the RUNTIME_PATH. Only if rpath is enabled and it is dnl an absolute path. dnl $1: the pathname to add. AC_DEFUN([ACX_RUNTIME_PATH_ADD], [ if test "x$enable_rpath" = xyes; then if echo "$1" | grep "^/" >/dev/null; then RUNTIME_PATH="$RUNTIME_PATH -R$1" fi fi ]) dnl Common code for both ACX_WITH_SSL and ACX_WITH_SSL_OPTIONAL dnl Takes one argument; the withval checked in those 2 functions dnl sets up the environment for the given openssl path AC_DEFUN([ACX_SSL_CHECKS], [ withval=$1 if test x_$withval != x_no; then AC_MSG_CHECKING(for SSL) if test x_$withval = x_ -o x_$withval = x_yes; then withval="/usr/local/ssl /usr/lib/ssl /usr/ssl /usr/pkg /usr/local /opt/local /usr/sfw /usr" fi for dir in $withval; do ssldir="$dir" if test -f "$dir/include/openssl/ssl.h"; then found_ssl="yes" AC_DEFINE_UNQUOTED([HAVE_SSL], [], [Define if you have the SSL libraries installed.]) dnl assume /usr/include is already in the include-path. if test "$ssldir" != "/usr"; then CPPFLAGS="$CPPFLAGS -I$ssldir/include" LIBSSL_CPPFLAGS="$LIBSSL_CPPFLAGS -I$ssldir/include" fi break; fi done if test x_$found_ssl != x_yes; then AC_MSG_ERROR(Cannot find the SSL libraries in $withval) else AC_MSG_RESULT(found in $ssldir) HAVE_SSL=yes dnl assume /usr is already in the lib and dynlib paths. if test "$ssldir" != "/usr" -a "$ssldir" != ""; then LDFLAGS="$LDFLAGS -L$ssldir/lib" LIBSSL_LDFLAGS="$LIBSSL_LDFLAGS -L$ssldir/lib" ACX_RUNTIME_PATH_ADD([$ssldir/lib]) fi AC_MSG_CHECKING([for HMAC_CTX_init in -lcrypto]) LIBS="$LIBS -lcrypto" LIBSSL_LIBS="$LIBSSL_LIBS -lcrypto" AC_TRY_LINK(, [ int HMAC_CTX_init(void); (void)HMAC_CTX_init(); ], [ AC_MSG_RESULT(yes) AC_DEFINE([HAVE_HMAC_CTX_INIT], 1, [If you have HMAC_CTX_init]) ], [ AC_MSG_RESULT(no) # check if -lwsock32 or -lgdi32 are needed. BAKLIBS="$LIBS" BAKSSLLIBS="$LIBSSL_LIBS" LIBS="$LIBS -lgdi32" LIBSSL_LIBS="$LIBSSL_LIBS -lgdi32" AC_MSG_CHECKING([if -lcrypto needs -lgdi32]) AC_TRY_LINK([], [ int HMAC_CTX_init(void); (void)HMAC_CTX_init(); ],[ AC_DEFINE([HAVE_HMAC_CTX_INIT], 1, [If you have HMAC_CTX_init]) AC_MSG_RESULT(yes) ],[ AC_MSG_RESULT(no) LIBS="$BAKLIBS" LIBSSL_LIBS="$BAKSSLLIBS" LIBS="$LIBS -ldl" LIBSSL_LIBS="$LIBSSL_LIBS -ldl" AC_MSG_CHECKING([if -lcrypto needs -ldl]) AC_TRY_LINK([], [ int HMAC_CTX_init(void); (void)HMAC_CTX_init(); ],[ AC_DEFINE([HAVE_HMAC_CTX_INIT], 1, [If you have HMAC_CTX_init]) AC_MSG_RESULT(yes) ],[ AC_MSG_RESULT(no) AC_MSG_ERROR([OpenSSL found in $ssldir, but version 0.9.7 or higher is required]) ]) ]) ]) fi AC_SUBST(HAVE_SSL) AC_SUBST(RUNTIME_PATH) # openssl engine functionality needs dlopen(). BAKLIBS="$LIBS" AC_SEARCH_LIBS([dlopen], [dl]) if test "$LIBS" != "$BAKLIBS"; then LIBSSL_LIBS="$LIBSSL_LIBS -ldl" fi fi AC_CHECK_HEADERS([openssl/ssl.h],,, [AC_INCLUDES_DEFAULT]) AC_CHECK_HEADERS([openssl/err.h],,, [AC_INCLUDES_DEFAULT]) AC_CHECK_HEADERS([openssl/rand.h],,, [AC_INCLUDES_DEFAULT]) ])dnl End of ACX_SSL_CHECKS dnl Check for SSL, where SSL is mandatory dnl Adds --with-ssl option, searches for openssl and defines HAVE_SSL if found dnl Setup of CPPFLAGS, CFLAGS. Adds -lcrypto to LIBS. dnl Checks main header files of SSL. dnl AC_DEFUN([ACX_WITH_SSL], [ AC_ARG_WITH(ssl, AC_HELP_STRING([--with-ssl=pathname], [enable SSL (will check /usr/local/ssl /usr/lib/ssl /usr/ssl /usr/pkg /usr/local /opt/local /usr/sfw /usr)]),[ ],[ withval="yes" ]) if test x_$withval = x_no; then AC_MSG_ERROR([Need SSL library to do digital signature cryptography]) fi ACX_SSL_CHECKS($withval) ])dnl End of ACX_WITH_SSL dnl Check for SSL, where ssl is optional (--without-ssl is allowed) dnl Adds --with-ssl option, searches for openssl and defines HAVE_SSL if found dnl Setup of CPPFLAGS, CFLAGS. Adds -lcrypto to LIBS. dnl Checks main header files of SSL. dnl AC_DEFUN([ACX_WITH_SSL_OPTIONAL], [ AC_ARG_WITH(ssl, AC_HELP_STRING([--with-ssl=pathname], [enable SSL (will check /usr/local/ssl /usr/lib/ssl /usr/ssl /usr/pkg /usr/local /opt/local /usr/sfw /usr)]),[ ],[ withval="yes" ]) ACX_SSL_CHECKS($withval) ])dnl End of ACX_WITH_SSL_OPTIONAL dnl Setup to use -lssl dnl To use -lcrypto, use the ACX_WITH_SSL setup (before this one). AC_DEFUN([ACX_LIB_SSL], [ # check if libssl needs libdl BAKLIBS="$LIBS" LIBS="-lssl $LIBS" AC_MSG_CHECKING([if libssl needs libdl]) AC_TRY_LINK_FUNC([SSL_CTX_new], [ AC_MSG_RESULT([no]) LIBS="$BAKLIBS" ] , [ AC_MSG_RESULT([yes]) LIBS="$BAKLIBS" AC_SEARCH_LIBS([dlopen], [dl]) ]) ])dnl End of ACX_LIB_SSL dnl Setup to use very large files (>2Gb). dnl setups fseeko and its own AC_DEFUN([ACX_SYS_LARGEFILE], [ AC_SYS_LARGEFILE dnl try to see if an additional _LARGEFILE_SOURCE 1 is needed to get fseeko ACX_CHECK_COMPILER_FLAG_NEEDED(-D_LARGEFILE_SOURCE=1, [ #include int test() { int a = fseeko(stdin, 0, 0); return a; } ], [CFLAGS="$CFLAGS -D_LARGEFILE_SOURCE=1"]) ]) dnl Check getaddrinfo. dnl Works on linux, solaris, bsd and windows(links winsock). dnl defines HAVE_GETADDRINFO, USE_WINSOCK. AC_DEFUN([ACX_CHECK_GETADDRINFO_WITH_INCLUDES], [AC_REQUIRE([AC_PROG_CC]) AC_MSG_CHECKING(for getaddrinfo) ac_cv_func_getaddrinfo=no AC_LINK_IFELSE( [AC_LANG_SOURCE([[ #ifdef __cplusplus extern "C" { #endif char* getaddrinfo(); char* (*f) () = getaddrinfo; #ifdef __cplusplus } #endif int main() { ; return 0; } ]])], dnl this case on linux, solaris, bsd [ac_cv_func_getaddrinfo="yes" dnl see if on windows if test "$ac_cv_header_windows_h" = "yes"; then AC_DEFINE(USE_WINSOCK, 1, [Whether the windows socket API is used]) USE_WINSOCK="1" LIBS="$LIBS -lws2_32" fi ], dnl no quick getaddrinfo, try mingw32 and winsock2 library. ORIGLIBS="$LIBS" LIBS="$LIBS -lws2_32" AC_LINK_IFELSE( [AC_LANG_PROGRAM( [ #ifdef HAVE_WS2TCPIP_H #include #endif ], [ (void)getaddrinfo(NULL, NULL, NULL, NULL); ] )], [ ac_cv_func_getaddrinfo="yes" dnl already: LIBS="$LIBS -lws2_32" AC_DEFINE(USE_WINSOCK, 1, [Whether the windows socket API is used]) USE_WINSOCK="1" ], [ ac_cv_func_getaddrinfo="no" LIBS="$ORIGLIBS" ]) ) AC_MSG_RESULT($ac_cv_func_getaddrinfo) if test $ac_cv_func_getaddrinfo = yes; then AC_DEFINE(HAVE_GETADDRINFO, 1, [Whether getaddrinfo is available]) fi ])dnl Endof AC_CHECK_GETADDRINFO_WITH_INCLUDES dnl check if a function is deprecated. defines DEPRECATED_func in config.h. dnl $1: function name dnl $2: C-statement that calls the function. dnl $3: includes for the program. dnl $4: executes if yes dnl $5: executes if no AC_DEFUN([ACX_FUNC_DEPRECATED], [ AC_REQUIRE([AC_PROG_CC]) AC_MSG_CHECKING(if $1 is deprecated) cache=`echo $1 | sed 'y%.=/+-%___p_%'` AC_CACHE_VAL(cv_cc_deprecated_$cache, [ echo '$3' >conftest.c echo 'void f(){ $2 }' >>conftest.c if test -z "`$CC -c conftest.c 2>&1 | grep deprecated`"; then eval "cv_cc_deprecated_$cache=no" else eval "cv_cc_deprecated_$cache=yes" fi rm -f conftest conftest.o conftest.c ]) if eval "test \"`echo '$cv_cc_deprecated_'$cache`\" = yes"; then AC_MSG_RESULT(yes) AC_DEFINE_UNQUOTED(AS_TR_CPP([DEPRECATED_$1]), 1, [Whether $1 is deprecated]) : $4 else AC_MSG_RESULT(no) : $5 fi ])dnl end of ACX_FUNC_DEPRECATED dnl check if select and nonblocking sockets actually work. dnl Needs fork(2) and select(2). dnl defines NONBLOCKING_IS_BROKEN, and if that is true multiple reads from dnl a nonblocking socket do not work, a new call to select is necessary. AC_DEFUN([ACX_CHECK_NONBLOCKING_BROKEN], [ AC_MSG_CHECKING([if nonblocking sockets work]) if echo $target | grep mingw32 >/dev/null; then AC_MSG_RESULT([no (windows)]) AC_DEFINE([NONBLOCKING_IS_BROKEN], 1, [Define if the network stack does not fully support nonblocking io (causes lower performance).]) else AC_RUN_IFELSE([ AC_LANG_SOURCE([[ #include #include #include #include #include #ifdef HAVE_SYS_TYPES_H #include #endif #ifdef HAVE_SYS_SOCKET_H #include #endif #ifdef HAVE_NETINET_IN_H #include #endif #ifdef HAVE_ARPA_INET_H #include #endif #ifdef HAVE_UNISTD_H #include #endif #ifdef HAVE_TIME_H #include #endif int main(void) { int port; int sfd, cfd; int num = 10; int i, p; struct sockaddr_in a; /* test if select and nonblocking reads work well together */ /* open port. fork child to send 10 messages. select to read. then try to nonblocking read the 10 messages then, nonblocking read must give EAGAIN */ port = 12345 + (time(0)%32); sfd = socket(PF_INET, SOCK_DGRAM, 0); if(sfd == -1) { perror("socket"); return 1; } memset(&a, 0, sizeof(a)); a.sin_family = AF_INET; a.sin_port = htons(port); a.sin_addr.s_addr = inet_addr("127.0.0.1"); if(bind(sfd, (struct sockaddr*)&a, sizeof(a)) < 0) { perror("bind"); return 1; } if(fcntl(sfd, F_SETFL, O_NONBLOCK) == -1) { perror("fcntl"); return 1; } cfd = socket(PF_INET, SOCK_DGRAM, 0); if(cfd == -1) { perror("client socket"); return 1; } a.sin_port = 0; if(bind(cfd, (struct sockaddr*)&a, sizeof(a)) < 0) { perror("client bind"); return 1; } a.sin_port = htons(port); /* no handler, causes exit in 10 seconds */ alarm(10); /* send and receive on the socket */ if((p=fork()) == 0) { for(i=0; i #include #ifdef HAVE_WINSOCK2_H #include #endif #ifdef HAVE_SYS_STAT_H #include #endif ], [ (void)mkdir("directory"); ], AC_MSG_RESULT(yes) AC_DEFINE(MKDIR_HAS_ONE_ARG, 1, [Define if mkdir has one argument.]) , AC_MSG_RESULT(no) ) ])dnl end of ACX_MKDIR_ONE_ARG dnl Check for ioctlsocket function. works on mingw32 too. AC_DEFUN([ACX_FUNC_IOCTLSOCKET], [ # check ioctlsocket AC_MSG_CHECKING(for ioctlsocket) AC_LINK_IFELSE([AC_LANG_PROGRAM([ #ifdef HAVE_WINSOCK2_H #include #endif ], [ (void)ioctlsocket(0, 0, NULL); ])], [ AC_MSG_RESULT(yes) AC_DEFINE(HAVE_IOCTLSOCKET, 1, [if the function 'ioctlsocket' is available]) ],[AC_MSG_RESULT(no)]) ])dnl end of ACX_FUNC_IOCTLSOCKET dnl detect malloc and provide malloc compat prototype. dnl $1: unique name for compat code AC_DEFUN([ACX_FUNC_MALLOC], [ AC_MSG_CHECKING([for GNU libc compatible malloc]) AC_RUN_IFELSE([AC_LANG_PROGRAM( [[#if defined STDC_HEADERS || defined HAVE_STDLIB_H #include #else char *malloc (); #endif ]], [ if(malloc(0) != 0) return 1;]) ], [AC_MSG_RESULT([no]) AC_LIBOBJ(malloc) AC_DEFINE_UNQUOTED([malloc], [rpl_malloc_$1], [Define if replacement function should be used.])] , [AC_MSG_RESULT([yes]) AC_DEFINE([HAVE_MALLOC], 1, [If have GNU libc compatible malloc])], [AC_MSG_RESULT([no (crosscompile)]) AC_LIBOBJ(malloc) AC_DEFINE_UNQUOTED([malloc], [rpl_malloc_$1], [Define if replacement function should be used.])] ) ]) dnl Define fallback for fseeko and ftello if needed. AC_DEFUN([AHX_CONFIG_FSEEKO], [ #ifndef HAVE_FSEEKO #define fseeko fseek #define ftello ftell #endif /* HAVE_FSEEKO */ ]) dnl Define RAND_MAX if not defined AC_DEFUN([AHX_CONFIG_RAND_MAX], [ #ifndef RAND_MAX #define RAND_MAX 2147483647 #endif ]) dnl Define MAXHOSTNAMELEN if not defined AC_DEFUN([AHX_CONFIG_MAXHOSTNAMELEN], [ #ifndef MAXHOSTNAMELEN #define MAXHOSTNAMELEN 256 #endif ]) dnl Define IPV6_MIN_MTU if not defined AC_DEFUN([AHX_CONFIG_IPV6_MIN_MTU], [ #ifndef IPV6_MIN_MTU #define IPV6_MIN_MTU 1280 #endif /* IPV6_MIN_MTU */ ]) dnl provide snprintf, vsnprintf compat prototype dnl $1: unique name for compat code AC_DEFUN([AHX_CONFIG_SNPRINTF], [ #ifndef HAVE_SNPRINTF #define snprintf snprintf_$1 #define vsnprintf vsnprintf_$1 #include int snprintf (char *str, size_t count, const char *fmt, ...); int vsnprintf (char *str, size_t count, const char *fmt, va_list arg); #endif /* HAVE_SNPRINTF */ ]) dnl provide inet_pton compat prototype. dnl $1: unique name for compat code AC_DEFUN([AHX_CONFIG_INET_PTON], [ #ifndef HAVE_INET_PTON #define inet_pton inet_pton_$1 int inet_pton(int af, const char* src, void* dst); #endif /* HAVE_INET_PTON */ ]) dnl provide inet_ntop compat prototype. dnl $1: unique name for compat code AC_DEFUN([AHX_CONFIG_INET_NTOP], [ #ifndef HAVE_INET_NTOP #define inet_ntop inet_ntop_$1 const char *inet_ntop(int af, const void *src, char *dst, size_t size); #endif ]) dnl provide inet_aton compat prototype. dnl $1: unique name for compat code AC_DEFUN([AHX_CONFIG_INET_ATON], [ #ifndef HAVE_INET_ATON #define inet_aton inet_aton_$1 int inet_aton(const char *cp, struct in_addr *addr); #endif ]) dnl provide memmove compat prototype. dnl $1: unique name for compat code AC_DEFUN([AHX_CONFIG_MEMMOVE], [ #ifndef HAVE_MEMMOVE #define memmove memmove_$1 void *memmove(void *dest, const void *src, size_t n); #endif ]) dnl provide strlcat compat prototype. dnl $1: unique name for compat code AC_DEFUN([AHX_CONFIG_STRLCAT], [ #ifndef HAVE_STRLCAT #define strlcat strlcat_$1 size_t strlcat(char *dst, const char *src, size_t siz); #endif ]) dnl provide strlcpy compat prototype. dnl $1: unique name for compat code AC_DEFUN([AHX_CONFIG_STRLCPY], [ #ifndef HAVE_STRLCPY #define strlcpy strlcpy_$1 size_t strlcpy(char *dst, const char *src, size_t siz); #endif ]) dnl provide gmtime_r compat prototype. dnl $1: unique name for compat code AC_DEFUN([AHX_CONFIG_GMTIME_R], [ #ifndef HAVE_GMTIME_R #define gmtime_r gmtime_r_$1 struct tm *gmtime_r(const time_t *timep, struct tm *result); #endif ]) dnl provide w32 compat definition for sleep AC_DEFUN([AHX_CONFIG_W32_SLEEP], [ #if !defined(HAVE_SLEEP) || defined(HAVE_WINDOWS_H) #define sleep(x) Sleep((x)*1000) /* on win32 */ #endif /* HAVE_SLEEP */ ]) dnl provide w32 compat definition for usleep AC_DEFUN([AHX_CONFIG_W32_USLEEP], [ #ifndef HAVE_USLEEP #define usleep(x) Sleep((x)/1000 + 1) /* on win32 */ #endif /* HAVE_USLEEP */ ]) dnl provide w32 compat definition for random AC_DEFUN([AHX_CONFIG_W32_RANDOM], [ #ifndef HAVE_RANDOM #define random rand /* on win32, for tests only (bad random) */ #endif /* HAVE_RANDOM */ ]) dnl provide w32 compat definition for srandom AC_DEFUN([AHX_CONFIG_W32_SRANDOM], [ #ifndef HAVE_SRANDOM #define srandom(x) srand(x) /* on win32, for tests only (bad random) */ #endif /* HAVE_SRANDOM */ ]) dnl provide w32 compat definition for FD_SET_T AC_DEFUN([AHX_CONFIG_W32_FD_SET_T], [ /* detect if we need to cast to unsigned int for FD_SET to avoid warnings */ #ifdef HAVE_WINSOCK2_H #define FD_SET_T (u_int) #else #define FD_SET_T #endif ]) dnl Remove an extension flag from CFLAGS, define replacement to be made. dnl Used by ACX_STRIP_EXT_FLAGS. dnl $1: the name of the flag, for example -D_GNU_SOURCE. AC_DEFUN([ACX_CFLAGS_STRIP], [ if echo $CFLAGS | grep " $1" >/dev/null 2>&1; then CFLAGS="`echo $CFLAGS | sed -e 's/ $1//g'`" AC_DEFINE(m4_bpatsubst(OMITTED_$1,[[-=]],_), 1, Put $1 define in config.h) fi ]) dnl Remove EXT flags from the CFLAGS and set them to be defined in config.h dnl use with ACX_DETERMINE_EXT_FLAGS. AC_DEFUN([ACX_STRIP_EXT_FLAGS], [ AC_MSG_NOTICE([Stripping extension flags...]) ACX_CFLAGS_STRIP(-D_GNU_SOURCE) ACX_CFLAGS_STRIP(-D_BSD_SOURCE) ACX_CFLAGS_STRIP(-D__EXTENSIONS__) ACX_CFLAGS_STRIP(-D_POSIX_C_SOURCE=200112) ACX_CFLAGS_STRIP(-D_XOPEN_SOURCE=600) ACX_CFLAGS_STRIP(-D_XOPEN_SOURCE_EXTENDED=1) ACX_CFLAGS_STRIP(-D_ALL_SOURCE) ACX_CFLAGS_STRIP(-D_LARGEFILE_SOURCE=1) ]) dnl End of ACX_STRIP_EXT_FLAGS dnl define one omitted flag for config.h dnl $1: flag name. -D_GNU_SOURCE dnl $2: replacement define. _GNU_SOURCE dnl $3: define value, 1 AC_DEFUN([AHX_CONFIG_FLAG_OMITTED], [#if defined($1) && !defined($2) #define $2 $3 [#]endif ]) dnl Wrapper for AHX_CONFIG_FLAG_OMITTED for -D style flags dnl $1: the -DNAME or -DNAME=value string. AC_DEFUN([AHX_CONFIG_FLAG_EXT], [AHX_CONFIG_FLAG_OMITTED(m4_bpatsubst(OMITTED_$1,[[-=]],_),m4_bpatsubst(m4_bpatsubst($1,-D,),=.*$,),m4_if(m4_bregexp($1,=),-1,1,m4_bpatsubst($1,^.*=,))) ]) dnl config.h part to define omitted cflags, use with ACX_STRIP_EXT_FLAGS. AC_DEFUN([AHX_CONFIG_EXT_FLAGS], [AHX_CONFIG_FLAG_EXT(-D_GNU_SOURCE) AHX_CONFIG_FLAG_EXT(-D_BSD_SOURCE) AHX_CONFIG_FLAG_EXT(-D__EXTENSIONS__) AHX_CONFIG_FLAG_EXT(-D_POSIX_C_SOURCE=200112) AHX_CONFIG_FLAG_EXT(-D_XOPEN_SOURCE=600) AHX_CONFIG_FLAG_EXT(-D_XOPEN_SOURCE_EXTENDED=1) AHX_CONFIG_FLAG_EXT(-D_ALL_SOURCE) AHX_CONFIG_FLAG_EXT(-D_LARGEFILE_SOURCE=1) ]) dnl check if memcmp is using signed characters and replace if so. AC_DEFUN([ACX_CHECK_MEMCMP_SIGNED], [AC_MSG_CHECKING([if memcmp compares unsigned]) AC_RUN_IFELSE([AC_LANG_SOURCE([[ #include #include #include int main(void) { char a = 255, b = 0; if(memcmp(&a, &b, 1) < 0) return 1; return 0; } ]])], [AC_MSG_RESULT([yes]) ], [ AC_MSG_RESULT([no]) AC_DEFINE([MEMCMP_IS_BROKEN], [1], [Define if memcmp() does not compare unsigned bytes]) AC_LIBOBJ([memcmp]) ], [ AC_MSG_RESULT([cross-compile no]) AC_DEFINE([MEMCMP_IS_BROKEN], [1], [Define if memcmp() does not compare unsigned bytes]) AC_LIBOBJ([memcmp]) ]) ]) dnl define memcmp to its replacement, pass unique id for program as arg AC_DEFUN([AHX_MEMCMP_BROKEN], [ #ifdef MEMCMP_IS_BROKEN #include "compat/memcmp.h" #define memcmp memcmp_$1 int memcmp(const void *x, const void *y, size_t n); #endif ]) dnl ACX_CHECK_SS_FAMILY - check for sockaddr_storage.ss_family AC_DEFUN([ACX_CHECK_SS_FAMILY], [AC_CHECK_MEMBER([struct sockaddr_storage.ss_family], [], [ AC_CHECK_MEMBER([struct sockaddr_storage.__ss_family], [ AC_DEFINE([ss_family], [__ss_family], [Fallback member name for socket family in struct sockaddr_storage]) ],, [AC_INCLUDES_DEFAULT #ifdef HAVE_NETINET_IN_H #include #endif #ifdef HAVE_SYS_SOCKET_H #include #endif #ifdef HAVE_NETDB_H #include #endif #ifdef HAVE_ARPA_INET_H #include #endif ]) ], [AC_INCLUDES_DEFAULT #ifdef HAVE_NETINET_IN_H #include #endif #ifdef HAVE_SYS_SOCKET_H #include #endif #ifdef HAVE_NETDB_H #include #endif #ifdef HAVE_ARPA_INET_H #include #endif ]) ]) dnl End of file ldns-1.6.17/configure.ac0000664000175100017510000005725512264060151014417 0ustar willemwillem# -*- Autoconf -*- # Process this file with autoconf to produce a configure script. AC_PREREQ(2.56) sinclude(acx_nlnetlabs.m4) # must be numbers. ac_defun because of later processing. m4_define([VERSION_MAJOR],[1]) m4_define([VERSION_MINOR],[6]) m4_define([VERSION_MICRO],[17]) AC_INIT(ldns, m4_defn([VERSION_MAJOR]).m4_defn([VERSION_MINOR]).m4_defn([VERSION_MICRO]), libdns@nlnetlabs.nl, libdns) AC_CONFIG_SRCDIR([packet.c]) # needed to build correct soname AC_SUBST(LDNS_VERSION_MAJOR, [VERSION_MAJOR]) AC_SUBST(LDNS_VERSION_MINOR, [VERSION_MINOR]) AC_SUBST(LDNS_VERSION_MICRO, [VERSION_MICRO]) AC_SUBST(VERSION_INFO, [VERSION_MAJOR:VERSION_MINOR:VERSION_MICRO]) AC_AIX LT_INIT AC_CONFIG_MACRO_DIR([m4]) OURCPPFLAGS='' CPPFLAGS=${CPPFLAGS:-${OURCPPFLAGS}} CFLAGS="$CFLAGS" # Checks for programs. AC_PROG_CC ACX_DEPFLAG AC_PROG_MAKE_SET # Extra (sp)lint flags for NetBSD AC_CANONICAL_HOST case "$host_os" in netbsd*) LINTFLAGS="'-D__RENAME(x)=' -D_NETINET_IN_H_ $LINTFLAGS" ;; *) LINTFLAGS="$LINTFLAGS" ;; esac AC_SUBST(LINTFLAGS) AC_DEFINE(WINVER, 0x0502, [the version of the windows API enabled]) ACX_CHECK_COMPILER_FLAG(std=c99, [C99FLAG="-std=c99"]) ACX_CHECK_COMPILER_FLAG(xc99, [C99FLAG="-xc99"]) # routine to copy files # argument 1 is a list of files (relative to the source dir) # argument 2 is a destination directory (relative to the current # working directory AC_DEFUN([COPY_FILES], [ for file in $1; do sh $srcdir/install-sh -m 644 $file $2 done ]) # copy all .h files in the dir at argument 1 # (relative to source) to the dir at argument 2 # (relative to current dir) AC_DEFUN([COPY_HEADER_FILES], [ echo "copying header files" COPY_FILES($srcdir/$1/*.h, $2) ]) # Checks for typedefs, structures, and compiler characteristics. AC_C_CONST AC_LANG_C if test "x$CFLAGS" = "x" ; then ACX_CHECK_COMPILER_FLAG(g, [CFLAGS="-g"]) ACX_CHECK_COMPILER_FLAG(O2, [CFLAGS="-O2 $CFLAGS"]) fi ACX_CHECK_COMPILER_FLAG(Wall, [CFLAGS="-Wall $CFLAGS"]) ACX_CHECK_COMPILER_FLAG(W, [CFLAGS="-W $CFLAGS"]) ACX_CHECK_COMPILER_FLAG(Wwrite-strings, [CFLAGS="-Wwrite-strings $CFLAGS"]) ACX_CHECK_COMPILER_FLAG(Wstrict-prototypes, [CFLAGS="-Wstrict-prototypes $CFLAGS"]) AC_CHECK_HEADERS([getopt.h time.h],,, [AC_INCLUDES_DEFAULT]) # MinGW32 tests AC_CHECK_HEADERS([winsock2.h ws2tcpip.h],,, [AC_INCLUDES_DEFAULT]) # end mingw32 tests ACX_DETERMINE_EXT_FLAGS_UNBOUND AC_C_INLINE AC_CHECK_TYPE(int8_t, char) AC_CHECK_TYPE(int16_t, short) AC_CHECK_TYPE(int32_t, int) AC_CHECK_TYPE(int64_t, long long) AC_CHECK_TYPE(uint8_t, unsigned char) AC_CHECK_TYPE(uint16_t, unsigned short) AC_CHECK_TYPE(uint32_t, unsigned int) AC_CHECK_TYPE(uint64_t, unsigned long long) # my own checks AC_CHECK_PROG(doxygen, doxygen, doxygen) # check to see if libraries are needed for these functions. AC_SEARCH_LIBS([socket], [socket]) AC_SEARCH_LIBS([inet_pton], [nsl]) AC_ARG_WITH(drill, AC_HELP_STRING([--with-drill], [Also build drill.]), [],[with_drill="no"]) if test x_$with_drill != x_no ; then AC_SUBST(DRILL,[drill]) AC_SUBST(INSTALL_DRILL,[install-drill]) AC_SUBST(UNINSTALL_DRILL,[uninstall-drill]) AC_SUBST(CLEAN_DRILL,[clean-drill]) AC_SUBST(LINT_DRILL,[lint-drill]) if test -e $srcdir/drill/config.h -o -e drill/config.h ; then AC_MSG_ERROR([ A config.h was detected in the drill subdirectory. This does not work with the --with-drill option. Please remove the config.h from the drill subdirectory or do not use the --with-drill option.]) fi DRILL_CONFIG=" drill/drill.1" else AC_SUBST(DRILL,[""]) AC_SUBST(INSTALL_DRILL,[""]) AC_SUBST(UNINSTALL_DRILL,[""]) AC_SUBST(CLEAN_DRILL,[""]) AC_SUBST(LINT_DRILL,[""]) DRILL_CONFIG="" fi AC_ARG_WITH(examples, AC_HELP_STRING([--with-examples], [Also build examples.]), [],[with_examples="no"]) if test x_$with_examples != x_no ; then AC_SUBST(EXAMPLES,[examples]) AC_SUBST(INSTALL_EXAMPLES,[install-examples]) AC_SUBST(UNINSTALL_EXAMPLES,[uninstall-examples]) AC_SUBST(CLEAN_EXAMPLES,[clean-examples]) AC_SUBST(LINT_EXAMPLES,[lint-examples]) if test -e $srcdir/examples/config.h -o -e examples/config.h ; then AC_MSG_ERROR([ A config.h was detected in the examples subdirectory. This does not work with the --with-examples option. Please remove the config.h from the examples subdirectory or do not use the --with-examples option.]) fi EXAMPLES_CONFIG=" examples/ldns-dane.1 examples/ldns-verify-zone.1" else AC_SUBST(EXAMPLES,[""]) AC_SUBST(INSTALL_EXAMPLES,[""]) AC_SUBST(UNINSTALL_EXAMPLES,[""]) AC_SUBST(CLEAN_EXAMPLES,[""]) AC_SUBST(LINT_EXAMPLES,[""]) EXAMPLES_CONFIG="" fi # add option to disable installation of ldns-config script AC_ARG_ENABLE(ldns-config, AC_HELP_STRING([--disable-ldns-config], [disable installation of ldns-config (default=enabled)]), enable_ldns_config=$enableval, enable_ldns_config=yes) if test "x$enable_ldns_config" = xyes; then AC_SUBST(INSTALL_CONFIG, [install-config]) AC_SUBST(INSTALL_CONFIG_MANPAGE, [install-config-manpage]) AC_SUBST(UNINSTALL_CONFIG, [uninstall-config]) AC_SUBST(UNINSTALL_CONFIG_MANPAGE, [uninstall-config-manpage]) else AC_SUBST(INSTALL_CONFIG, [""]) AC_SUBST(INSTALL_CONFIG_MANPAGE, [""]) AC_SUBST(UNINSTALL_CONFIG, [""]) AC_SUBST(UNINSTALL_CONFIG_MANPAGE, [""]) fi # add option to disable library printing to stderr AC_ARG_ENABLE(stderr-msgs, AC_HELP_STRING([--enable-stderr-msgs], [Enable printing to stderr (default=disabled)]), enable_stderr_msgs=$enableval, enable_stderr_msgs=no) case "$enable_stderr_msgs" in no) dnl default ;; *) AC_DEFINE_UNQUOTED([STDERR_MSGS], [1], [Define this to enable messages to stderr.]) ;; esac # check for python PYTHON_X_CFLAGS="" ldns_with_pyldns=no ldns_with_pyldnsx=no AC_ARG_WITH(pyldns, AC_HELP_STRING([--with-pyldns], [generate python library, or --without-pyldns to disable Python support.]), [],[ withval="no" ]) ldns_have_python=no if test x_$withval != x_no; then sinclude(ax_python_devel.m4) ac_save_LIBS="$LIBS" dnl otherwise AC_PYTHON_DEVEL thrashes $LIBS AX_PYTHON_DEVEL([>= '2.4.0']) if test ! -z "$ac_python_version"; then ldns_have_python=yes fi # pass additional Python 3 option to SWIG if test `$PYTHON -c "import sys; \ ver = sys.version.split()[[0]]; \ print(ver >= '3')"` = "True"; then AC_SUBST(SWIGPY3, ["-py3 -DPY3"]) fi # check for SWIG if test x_$ldns_have_python != x_no; then sinclude(ax_pkg_swig.m4) # check for >=SWIG-2.0.4 if Python 3.2 used if test `$PYTHON -c "import sys; \ ver = sys.version.split()[[0]]; \ print(ver >= '3.2')"` = "True"; then AX_PKG_SWIG(2.0.4, [], [AC_MSG_ERROR([SWIG-2.0.4 is required to build pyldns for Python 3.2 and greater.])]) else AX_PKG_SWIG fi if test ! -x "$SWIG"; then AC_MSG_ERROR([failed to find SWIG tool, install it, or do not build pyldns]) else AC_DEFINE(HAVE_SWIG,1,[Define if you have SWIG libraries and header files.]) AC_SUBST(PYLDNS, "pyldns") AC_SUBST(swig, "$SWIG") ldns_with_pyldns=yes fi else AC_MSG_RESULT([*** don't have Python, skipping SWIG, no pyldns ***]) # ' fi # xtra cflags for pyldns if test x_$ldns_have_python != x_no; then ACX_CHECK_COMPILER_FLAG(fno-strict-aliasing, [PYTHON_X_CFLAGS="-fno-strict-aliasing"]) ACX_CHECK_COMPILER_FLAG(Wno-missing-field-initializers, [PYTHON_X_CFLAGS="-Wno-missing-field-initializers $PYTHON_X_CFLAGS"]) ACX_CHECK_COMPILER_FLAG(Wno-unused-parameter, [PYTHON_X_CFLAGS="-Wno-unused-parameter $PYTHON_X_CFLAGS"]) ACX_CHECK_COMPILER_FLAG(Wno-unused-variable, [PYTHON_X_CFLAGS="-Wno-unused-variable $PYTHON_X_CFLAGS"]) fi fi AC_SUBST(PYTHON_X_CFLAGS) # Check for pyldnsx AC_ARG_WITH(pyldnsx, AC_HELP_STRING([--without-pyldnsx], [Do not install the ldnsx python module, or --with-pyldnsx to install it.]), [],[ withval="with_pyldns" ]) if test x_$withval != x_no; then if test x_$ldns_with_pyldns != x_no; then AC_SUBST(PYLDNSX, "pyldnsx") ldns_with_pyldnsx=yes else if test x_$withval != x_with_pyldns; then AC_MSG_ERROR([--with-pyldns is needed for the ldnsx python module]) fi fi fi if test x_$ldns_with_pyldns != x_no; then AC_SUBST(PYLDNSINST, "install-pyldns")dnl AC_SUBST(PYLDNSUNINST, "uninstall-pyldns") else AC_SUBST(PYLDNSINST, "")dnl AC_SUBST(PYLDNSUNINST, "") fi if test x_$ldns_with_pyldnsx != x_no; then AC_SUBST(PYLDNSXINST, "install-pyldnsx")dnl AC_SUBST(PYLDNSXUNINST, "uninstall-pyldnsx") else AC_SUBST(PYLDNSXINST, "")dnl AC_SUBST(PYLDNSXUNINST, "") fi # check for perl ldns_with_p5_dns_ldns=no AC_ARG_WITH(p5-dns-ldns, AC_HELP_STRING([--with-p5-dns-ldns], [generate DNS::LDNS perl bindings]), [],[ withval="no" ]) ldns_have_perl=no if test x_$withval != x_no; then AC_PATH_PROG([PERL], [perl]) if test -z "$PERL"; then AC_MSG_ERROR([Cannot find perl in your system path]) fi AC_SUBST(P5_DNS_LDNS, "p5-dns-ldns")dnl AC_SUBST(TEST_P5_DNS_LDNS, "test-p5-dns-ldns")dnl AC_SUBST(INSTALL_P5_DNS_LDNS, "install-p5-dns-ldns")dnl AC_SUBST(UNINSTALL_P5_DNS_LDNS, "uninstall-p5-dns-ldns")dnl AC_SUBST(CLEAN_P5_DNS_LDNS, "clean-p5-dns-ldns") else AC_SUBST(P5_DNS_LDNS, "")dnl AC_SUBST(TEST_P5_DNS_LDNS, "")dnl AC_SUBST(INSTALL_P5_DNS_LDNS, "")dnl AC_SUBST(UNINSTALL_P5_DNS_LDNS, "")dnl AC_SUBST(CLEAN_P5_DNS_LDNS, "") fi # Use libtool ACX_LIBTOOL_C_ONLY tmp_CPPFLAGS=$CPPFLAGS tmp_LDFLAGS=$LDFLAGS tmp_LIBS=$LIBS ACX_WITH_SSL_OPTIONAL AC_CHECK_FUNCS([EVP_sha256]) # for macosx, see if glibtool exists and use that # BSD's need to know the version... #AC_CHECK_PROG(glibtool, glibtool, [glibtool], ) #AC_CHECK_PROGS(libtool, [libtool15 libtool], [./libtool]) AC_ARG_ENABLE(sha2, AC_HELP_STRING([--disable-sha2], [Disable SHA256 and SHA512 RRSIG support])) case "$enable_sha2" in no) ;; yes|*) if test "x$HAVE_SSL" != "xyes"; then AC_MSG_ERROR([SHA2 enabled, but no SSL support]) fi AC_MSG_CHECKING(for SHA256 and SHA512) AC_CHECK_FUNC(SHA256_Init, [], [ AC_MSG_ERROR([No SHA2 functions found in OpenSSL: please upgrade OpenSSL or rerun with --disable-sha2]) ]) AC_DEFINE_UNQUOTED([USE_SHA2], [1], [Define this to enable SHA256 and SHA512 support.]) ;; esac AC_ARG_ENABLE(gost, AC_HELP_STRING([--disable-gost], [Disable GOST support])) case "$enable_gost" in no) ;; *) dnl default if test "x$HAVE_SSL" != "xyes"; then AC_MSG_ERROR([GOST enabled, but no SSL support]) fi AC_MSG_CHECKING(for GOST) AC_CHECK_FUNC(EVP_PKEY_set_type_str, [],[AC_MSG_ERROR([OpenSSL >= 1.0.0 is needed for GOST support or rerun with --disable-gost])]) AC_CHECK_FUNC(EC_KEY_new, [], [AC_MSG_ERROR([No ECC functions found in OpenSSL: please upgrade OpenSSL or rerun with --disable-gost])]) AC_DEFINE_UNQUOTED([USE_GOST], [1], [Define this to enable GOST support.]) ;; esac AC_ARG_ENABLE(ecdsa, AC_HELP_STRING([--disable-ecdsa], [Disable ECDSA support])) case "$enable_ecdsa" in no) ;; *) dnl default if test "x$HAVE_SSL" != "xyes"; then AC_MSG_ERROR([ECDSA enabled, but no SSL support]) fi AC_CHECK_FUNC(ECDSA_sign, [], [AC_MSG_ERROR([OpenSSL does not support ECDSA: please upgrade OpenSSL or rerun with --disable-ecdsa])]) AC_CHECK_FUNC(SHA384_Init, [], [AC_MSG_ERROR([OpenSSL does not support SHA384: please upgrade OpenSSL or rerun with --disable-ecdsa])]) AC_CHECK_DECLS([NID_X9_62_prime256v1, NID_secp384r1], [], [AC_MSG_ERROR([OpenSSL does not support the ECDSA curves: please upgrade OpenSSL or rerun with --disable-ecdsa])], [AC_INCLUDES_DEFAULT #include ]) # we now know we have ECDSA and the required curves. AC_DEFINE_UNQUOTED([USE_ECDSA], [1], [Define this to enable ECDSA support.]) ;; esac AC_ARG_ENABLE(dane, AC_HELP_STRING([--disable-dane], [Disable DANE support])) case "$enable_dane" in no) AC_SUBST(ldns_build_config_use_dane, 0) ;; *) dnl default if test "x$HAVE_SSL" != "xyes"; then AC_MSG_ERROR([DANE enabled, but no SSL support]) fi AC_CHECK_FUNC(X509_check_ca, [], [AC_MSG_ERROR([OpenSSL does not support DANE: please upgrade OpenSSL or rerun with --disable-dane])]) AC_DEFINE_UNQUOTED([USE_DANE], [1], [Define this to enable DANE support.]) AC_SUBST(ldns_build_config_use_dane, 1) ;; esac AC_ARG_ENABLE(rrtype-ninfo, AC_HELP_STRING([--enable-rrtype-ninfo], [Enable draft RR type ninfo.])) case "$enable_rrtype_ninfo" in yes) AC_DEFINE_UNQUOTED([RRTYPE_NINFO], [], [Define this to enable RR type NINFO.]) ;; no|*) ;; esac AC_ARG_ENABLE(rrtype-rkey, AC_HELP_STRING([--enable-rrtype-rkey], [Enable draft RR type rkey.])) case "$enable_rrtype_rkey" in yes) AC_DEFINE_UNQUOTED([RRTYPE_RKEY], [], [Define this to enable RR type RKEY.]) ;; no|*) ;; esac AC_ARG_ENABLE(rrtype-cds, AC_HELP_STRING([--enable-rrtype-cds], [Enable draft RR type cds.])) case "$enable_rrtype_cds" in yes) AC_DEFINE_UNQUOTED([RRTYPE_CDS], [], [Define this to enable RR type CDS.]) ;; no|*) ;; esac AC_ARG_ENABLE(rrtype-uri, AC_HELP_STRING([--enable-rrtype-uri], [Enable draft RR type uri.])) case "$enable_rrtype_uri" in yes) AC_DEFINE_UNQUOTED([RRTYPE_URI], [], [Define this to enable RR type URI.]) ;; no|*) ;; esac AC_ARG_ENABLE(rrtype-ta, AC_HELP_STRING([--enable-rrtype-ta], [Enable draft RR type ta.])) case "$enable_rrtype_ta" in yes) AC_DEFINE_UNQUOTED([RRTYPE_TA], [], [Define this to enable RR type TA.]) ;; no|*) ;; esac AC_SUBST(LIBSSL_CPPFLAGS) AC_SUBST(LIBSSL_LDFLAGS) AC_SUBST(LIBSSL_LIBS) if test "x$HAVE_SSL" = "xyes"; then AC_SUBST(LIBSSL_SSL_LIBS, ["-lssl $LIBSSL_LIBS"]) fi CPPFLAGS=$tmp_CPPFLAGS LDFLAGS=$tmp_LDFLAGS LIBS=$tmp_LIBS # add option to disable the evil rpath ACX_ARG_RPATH #AC_RUN_IFELSE([AC_LANG_SOURCE( #[ #int main() #{ #short one = 1; #char *cp = (char*)&one; #if ( *cp == 0 ) #return(0); #else #return(1); #} #])], [],[ #AC_DEFINE(CONFCHECK_LITTLE_ENDIAN, 1, [system appears to be little-endian]) #],[]) # should define WORDS_BIGENDIAN if the system is big-endian AC_C_BIGENDIAN # Checks for header files. AC_HEADER_STDC AC_HEADER_STDBOOL #AC_HEADER_SYS_WAIT #AC_CHECK_HEADERS([getopt.h fcntl.h stdlib.h string.h strings.h unistd.h]) # do the very minimum - we can always extend this AC_CHECK_HEADERS([getopt.h stdarg.h openssl/ssl.h netinet/in.h time.h arpa/inet.h netdb.h],,, [AC_INCLUDES_DEFAULT]) AC_CHECK_HEADERS(sys/param.h sys/mount.h,,, [AC_INCLUDES_DEFAULT [ #if HAVE_SYS_PARAM_H # include #endif ] ]) AC_CHECK_HEADER(sys/socket.h, [ include_sys_socket_h='#include ' AC_DEFINE(HAVE_SYS_SOCKET_H, 1, [define if you have sys/socket.h]) ],[ include_sys_socket_h='' ],[AC_INCLUDES_DEFAULT [ #if HAVE_SYS_PARAM_H # include #endif ] ]) AC_SUBST(include_sys_socket_h) AC_CHECK_HEADER(inttypes.h, [ include_inttypes_h='#include ' AC_DEFINE(HAVE_INTTYPES_H, 1, [define if you have inttypes.h]) AC_SUBST(ldns_build_config_have_inttypes_h, 1) ],[ include_inttypes_h='' AC_SUBST(ldns_build_config_have_inttypes_h, 0) ],[AC_INCLUDES_DEFAULT ]) AC_SUBST(include_inttypes_h) AC_CHECK_HEADER(sys/types.h, [ include_systypes_h='#include ' AC_DEFINE(HAVE_SYS_TYPES_H, 1, [define if you have sys/types.h]) ],[ include_systypes_h='' ],[AC_INCLUDES_DEFAULT ]) AC_SUBST(include_systypes_h) AC_CHECK_HEADER(unistd.h, [ include_unistd_h='#include ' AC_DEFINE(HAVE_UNISTD_H, 1, [define if you have unistd.h]) ],[ include_unistd_h='' ],[AC_INCLUDES_DEFAULT ]) AC_SUBST(include_unistd_h) AC_CHECK_SIZEOF(time_t,,[ AC_INCLUDES_DEFAULT #ifdef TIME_WITH_SYS_TIME # include # include #else # ifdef HAVE_SYS_TIME_H # include # else # include # endif #endif ]) if test x_$with_examples != x_no; then AC_CHECK_HEADERS([pcap.h],,, [AC_INCLUDES_DEFAULT]) AC_CHECK_LIB(pcap, pcap_open_offline, [ AC_DEFINE([HAVE_LIBPCAP], [1], [Define to 1 if you have the `pcap' library (-lpcap).])dnl` AC_SUBST([LIBPCAP_LIBS], [-lpcap]) ], [ AC_MSG_WARN([Can't find pcap library (needed for ldns-dpa, will not build dpa now.)])dnl' AC_SUBST([LIBPCAP_LIBS], []) ] ) AC_CHECK_HEADERS([netinet/in_systm.h net/if.h netinet/ip.h netinet/udp.h netinet/igmp.h netinet/if_ether.h netinet/ip6.h net/ethernet.h netinet/ip_compat.h],,, [ AC_INCLUDES_DEFAULT #ifdef HAVE_NETINET_IN_SYSTM_H #include #endif #ifdef HAVE_NETINET_IN_H #include #endif #ifdef HAVE_SYS_SOCKET_H #include #endif #ifdef HAVE_NET_IF_H #include #endif]) fi ACX_TYPE_SOCKLEN_T if test "x$ac_cv_type_socklen_t" = xyes; then AC_SUBST(ldns_build_config_have_socklen_t, 1) else AC_SUBST(ldns_build_config_have_socklen_t, 0) fi AC_TYPE_SIZE_T AC_CHECK_TYPE(ssize_t, int) dnl AC_TYPE_INTPTR_T does not work on all platforms (autoconf) AC_CHECK_TYPE(intptr_t, size_t) AC_CHECK_TYPE(in_addr_t, [], [AC_DEFINE([in_addr_t], [uint32_t], [in_addr_t])], [ #if HAVE_SYS_TYPES_H # include #endif #if HAVE_NETINET_IN_H # include #endif]) AC_CHECK_TYPE(in_port_t, [], [AC_DEFINE([in_port_t], [uint16_t], [in_port_t])], [ #if HAVE_SYS_TYPES_H # include #endif #if HAVE_NETINET_IN_H # include #endif]) ACX_CHECK_SS_FAMILY AC_FUNC_MALLOC AC_FUNC_REALLOC AC_REPLACE_FUNCS(b64_pton) AC_REPLACE_FUNCS(b64_ntop) AC_REPLACE_FUNCS(calloc) AC_REPLACE_FUNCS(timegm) AC_REPLACE_FUNCS(gmtime_r) AC_REPLACE_FUNCS(ctime_r) AC_REPLACE_FUNCS(localtime_r) AC_REPLACE_FUNCS(isblank) AC_REPLACE_FUNCS(isascii) AC_REPLACE_FUNCS(inet_aton) AC_REPLACE_FUNCS(inet_pton) AC_REPLACE_FUNCS(inet_ntop) AC_REPLACE_FUNCS(snprintf) AC_REPLACE_FUNCS(strlcpy) AC_REPLACE_FUNCS(memmove) AC_FUNC_FORK AC_CHECK_FUNCS([endprotoent endservent sleep random fcntl strtoul bzero memset b32_ntop b32_pton]) if test "x$HAVE_B32_NTOP" = "xyes"; then AC_SUBST(ldns_build_config_have_b32_ntop, 1) else AC_SUBST(ldns_build_config_have_b32_ntop, 0) fi if test "x$HAVE_B32_PTON" = "xyes"; then AC_SUBST(ldns_build_config_have_b32_pton, 1) else AC_SUBST(ldns_build_config_have_b32_pton, 0) fi ACX_CHECK_GETADDRINFO_WITH_INCLUDES if test $ac_cv_func_getaddrinfo = no; then AC_LIBOBJ([fake-rfc2553]) fi if test "$USE_WINSOCK" = 1; then AC_CHECK_TOOL(WINDRES, windres) fi ACX_FUNC_IOCTLSOCKET #AC_SEARCH_LIBS(RSA_new, [crypto]) ACX_CHECK_FORMAT_ATTRIBUTE ACX_CHECK_UNUSED_ATTRIBUTE # check OSX deployment target which is needed if echo $build_os | grep darwin > /dev/null; then export MACOSX_DEPLOYMENT_TARGET="10.4" fi AC_DEFINE([SYSCONFDIR], [sysconfdir], [System configuration dir]) AC_ARG_WITH(trust-anchor, AC_HELP_STRING([--with-trust-anchor=KEYFILE], [Default location of the trust anchor file for drill and ldns-dane. [default=SYSCONFDIR/unbound/root.key]]), [ LDNS_TRUST_ANCHOR_FILE="$withval" ],[ if test "x$LDNS_TRUST_ANCHOR_FILE" = "x"; then if test "x$sysconfdir" = 'x${prefix}/etc' ; then if test "x$prefix" = 'xNONE' ; then LDNS_TRUST_ANCHOR_FILE="/etc/unbound/root.key" else LDNS_TRUST_ANCHOR_FILE="${prefix}/etc/unbound/root.key" fi else LDNS_TRUST_ANCHOR_FILE="${sysconfdir}/unbound/root.key" fi fi ]) AC_DEFINE_UNQUOTED([LDNS_TRUST_ANCHOR_FILE], ["$LDNS_TRUST_ANCHOR_FILE"], [Default trust anchor file]) AC_SUBST(LDNS_TRUST_ANCHOR_FILE) AC_MSG_NOTICE([Default trust anchor: $LDNS_TRUST_ANCHOR_FILE]) AC_ARG_WITH(ca-file, AC_HELP_STRING([--with-ca-file=CAFILE], [File containing CA certificates for ldns-dane]), [ AC_DEFINE([HAVE_DANE_CA_FILE], [1], [Is a CAFILE given at configure time]) AC_DEFINE_UNQUOTED([LDNS_DANE_CA_FILE], ["$withval"], [Is a CAFILE given at configure time]) AC_MSG_NOTICE([Using CAfile: $withval]) AC_SUBST(DEFAULT_CAFILE, ["Default is $withval"]) ],[ AC_DEFINE([HAVE_DANE_CA_FILE], [0], [Is a CAFILE given at configure time]) AC_SUBST(DEFAULT_CAFILE, []) ]) AC_ARG_WITH(ca-path, AC_HELP_STRING([--with-ca-path=CAPATH], [Directory containing CA certificate files for ldns-dane]), [ AC_DEFINE([HAVE_DANE_CA_PATH], [1], [Is a CAPATH given at configure time]) AC_DEFINE_UNQUOTED([LDNS_DANE_CA_PATH], ["$withval"], [Is a CAPATH given at configure time]) AC_MSG_NOTICE([Using CApath: $withval]) AC_SUBST(DEFAULT_CAPATH, ["Default is $withval"]) ],[ AC_DEFINE([HAVE_DANE_CA_PATH], [0], [Is a CAPATH given at configure time]) AC_SUBST(DEFAULT_CAPATH, []) ]) AH_BOTTOM([ #include #include #include #include #ifndef LITTLE_ENDIAN #define LITTLE_ENDIAN 1234 #endif #ifndef BIG_ENDIAN #define BIG_ENDIAN 4321 #endif #ifndef BYTE_ORDER #ifdef WORDS_BIGENDIAN #define BYTE_ORDER BIG_ENDIAN #else #define BYTE_ORDER LITTLE_ENDIAN #endif /* WORDS_BIGENDIAN */ #endif /* BYTE_ORDER */ #if STDC_HEADERS #include #include #endif #ifdef HAVE_STDINT_H #include #endif #ifdef HAVE_SYS_SOCKET_H #include #endif #ifdef HAVE_NETINET_IN_H #include #endif #ifdef HAVE_ARPA_INET_H #include #endif #ifdef HAVE_WINSOCK2_H #include #endif #ifdef HAVE_WS2TCPIP_H #include #endif ] AHX_CONFIG_W32_FD_SET_T ) AH_BOTTOM([ #ifdef __cplusplus extern "C" { #endif int ldns_b64_ntop(uint8_t const *src, size_t srclength, char *target, size_t targsize); /** * calculates the size needed to store the result of b64_ntop */ /*@unused@*/ static inline size_t ldns_b64_ntop_calculate_size(size_t srcsize) { return ((((srcsize + 2) / 3) * 4) + 1); } int ldns_b64_pton(char const *src, uint8_t *target, size_t targsize); /** * calculates the size needed to store the result of ldns_b64_pton */ /*@unused@*/ static inline size_t ldns_b64_pton_calculate_size(size_t srcsize) { return (((((srcsize + 3) / 4) * 3)) + 1); } /** * Given in dnssec_zone.c, also used in dnssec_sign.c:w */ int ldns_dname_compare_v(const void *a, const void *b); #ifndef HAVE_SLEEP /* use windows sleep, in millisecs, instead */ #define sleep(x) Sleep((x)*1000) #endif #ifndef HAVE_RANDOM #define srandom(x) srand(x) #define random(x) rand(x) #endif #ifndef HAVE_TIMEGM #include time_t timegm (struct tm *tm); #endif /* !TIMEGM */ #ifndef HAVE_GMTIME_R struct tm *gmtime_r(const time_t *timep, struct tm *result); #endif #ifndef HAVE_LOCALTIME_R struct tm *localtime_r(const time_t *timep, struct tm *result); #endif #ifndef HAVE_ISBLANK int isblank(int c); #endif /* !HAVE_ISBLANK */ #ifndef HAVE_ISASCII int isascii(int c); #endif /* !HAVE_ISASCII */ #ifndef HAVE_SNPRINTF #include int snprintf (char *str, size_t count, const char *fmt, ...); int vsnprintf (char *str, size_t count, const char *fmt, va_list arg); #endif /* HAVE_SNPRINTF */ #ifndef HAVE_INET_PTON int inet_pton(int af, const char* src, void* dst); #endif /* HAVE_INET_PTON */ #ifndef HAVE_INET_NTOP const char *inet_ntop(int af, const void *src, char *dst, size_t size); #endif #ifndef HAVE_INET_ATON int inet_aton(const char *cp, struct in_addr *addr); #endif #ifndef HAVE_MEMMOVE void *memmove(void *dest, const void *src, size_t n); #endif #ifndef HAVE_STRLCPY size_t strlcpy(char *dst, const char *src, size_t siz); #endif #ifdef __cplusplus } #endif #ifndef HAVE_GETADDRINFO #include "compat/fake-rfc2553.h" #endif #ifndef HAVE_STRTOUL #define strtoul (unsigned long)strtol #endif ]) if test "x$HAVE_SSL" = "xyes"; then AC_SUBST(ldns_build_config_have_ssl, 1) else AC_SUBST(ldns_build_config_have_ssl, 0) fi if test "x$ac_cv_c_format_attribute" = "xyes"; then AC_SUBST(ldns_build_config_have_attr_format, 1) else AC_SUBST(ldns_build_config_have_attr_format, 0) fi if test "x$ac_cv_c_unused_attribute" = "xyes"; then AC_SUBST(ldns_build_config_have_attr_unused, 1) else AC_SUBST(ldns_build_config_have_attr_unused, 0) fi CONFIG_FILES="Makefile ldns/common.h ldns/net.h ldns/util.h packaging/libldns.pc packaging/ldns-config $DRILL_CONFIG $EXAMPLES_CONFIG" AC_SUBST(CONFIG_FILES) AC_CONFIG_FILES([$CONFIG_FILES]) AC_CONFIG_HEADER([ldns/config.h]) AC_OUTPUT COPY_HEADER_FILES(ldns/, ldns/) dnl AC_CONFIG_SUBDIRS([drill]) ldns-1.6.17/rr.c0000664000175100017510000024601512264060151012712 0ustar willemwillem/* rr.c * * access functions for ldns_rr - * a Net::DNS like library for C * LibDNS Team @ NLnet Labs * * (c) NLnet Labs, 2004-2006 * See the file LICENSE for the license */ #include #include #include #include #include #define LDNS_SYNTAX_DATALEN 16 #define LDNS_TTL_DATALEN 21 #define LDNS_RRLIST_INIT 8 ldns_rr * ldns_rr_new(void) { ldns_rr *rr; rr = LDNS_MALLOC(ldns_rr); if (!rr) { return NULL; } ldns_rr_set_owner(rr, NULL); ldns_rr_set_question(rr, false); ldns_rr_set_rd_count(rr, 0); rr->_rdata_fields = NULL; ldns_rr_set_class(rr, LDNS_RR_CLASS_IN); ldns_rr_set_ttl(rr, LDNS_DEFAULT_TTL); return rr; } ldns_rr * ldns_rr_new_frm_type(ldns_rr_type t) { ldns_rr *rr; const ldns_rr_descriptor *desc; size_t i; rr = LDNS_MALLOC(ldns_rr); if (!rr) { return NULL; } desc = ldns_rr_descript(t); rr->_rdata_fields = LDNS_XMALLOC(ldns_rdf *, ldns_rr_descriptor_minimum(desc)); if(!rr->_rdata_fields) { LDNS_FREE(rr); return NULL; } for (i = 0; i < ldns_rr_descriptor_minimum(desc); i++) { rr->_rdata_fields[i] = NULL; } ldns_rr_set_owner(rr, NULL); ldns_rr_set_question(rr, false); /* set the count to minimum */ ldns_rr_set_rd_count(rr, ldns_rr_descriptor_minimum(desc)); ldns_rr_set_class(rr, LDNS_RR_CLASS_IN); ldns_rr_set_ttl(rr, LDNS_DEFAULT_TTL); ldns_rr_set_type(rr, t); return rr; } void ldns_rr_free(ldns_rr *rr) { size_t i; if (rr) { if (ldns_rr_owner(rr)) { ldns_rdf_deep_free(ldns_rr_owner(rr)); } for (i = 0; i < ldns_rr_rd_count(rr); i++) { ldns_rdf_deep_free(ldns_rr_rdf(rr, i)); } LDNS_FREE(rr->_rdata_fields); LDNS_FREE(rr); } } /* Syntactic sugar for ldns_rr_new_frm_str_internal */ INLINE bool ldns_rdf_type_maybe_quoted(ldns_rdf_type rdf_type) { return rdf_type == LDNS_RDF_TYPE_STR || rdf_type == LDNS_RDF_TYPE_LONG_STR; } /* * trailing spaces are allowed * leading spaces are not allowed * allow ttl to be optional * class is optional too * if ttl is missing, and default_ttl is 0, use DEF_TTL * allow ttl to be written as 1d3h * So the RR should look like. e.g. * miek.nl. 3600 IN MX 10 elektron.atoom.net * or * miek.nl. 1h IN MX 10 elektron.atoom.net * or * miek.nl. IN MX 10 elektron.atoom.net */ static ldns_status ldns_rr_new_frm_str_internal(ldns_rr **newrr, const char *str, uint32_t default_ttl, ldns_rdf *origin, ldns_rdf **prev, bool question) { ldns_rr *new; const ldns_rr_descriptor *desc; ldns_rr_type rr_type; ldns_buffer *rr_buf = NULL; ldns_buffer *rd_buf = NULL; uint32_t ttl_val; char *owner = NULL; char *ttl = NULL; ldns_rr_class clas_val; char *clas = NULL; char *type = NULL; char *rdata = NULL; char *rd = NULL; char *xtok = NULL; /* For RDF types with spaces (i.e. extra tokens) */ size_t rd_strlen; const char *delimiters; ssize_t c; ldns_rdf *owner_dname; const char* endptr; int was_unknown_rr_format = 0; ldns_status status = LDNS_STATUS_OK; /* used for types with unknown number of rdatas */ bool done; bool quoted; ldns_rdf *r = NULL; uint16_t r_cnt; uint16_t r_min; uint16_t r_max; size_t pre_data_pos; uint16_t hex_data_size; char *hex_data_str = NULL; uint16_t cur_hex_data_size; size_t hex_pos = 0; uint8_t *hex_data = NULL; new = ldns_rr_new(); owner = LDNS_XMALLOC(char, LDNS_MAX_DOMAINLEN + 1); ttl = LDNS_XMALLOC(char, LDNS_TTL_DATALEN); clas = LDNS_XMALLOC(char, LDNS_SYNTAX_DATALEN); rdata = LDNS_XMALLOC(char, LDNS_MAX_PACKETLEN + 1); rr_buf = LDNS_MALLOC(ldns_buffer); rd_buf = LDNS_MALLOC(ldns_buffer); rd = LDNS_XMALLOC(char, LDNS_MAX_RDFLEN); xtok = LDNS_XMALLOC(char, LDNS_MAX_RDFLEN); if (rr_buf) { rr_buf->_data = NULL; } if (rd_buf) { rd_buf->_data = NULL; } if (!new || !owner || !ttl || !clas || !rdata || !rr_buf || !rd_buf || !rd || !xtok) { goto memerror; } ldns_buffer_new_frm_data(rr_buf, (char*)str, strlen(str)); /* split the rr in its parts -1 signals trouble */ if (ldns_bget_token(rr_buf, owner, "\t\n ", LDNS_MAX_DOMAINLEN) == -1){ status = LDNS_STATUS_SYNTAX_ERR; goto error; } if (ldns_bget_token(rr_buf, ttl, "\t\n ", LDNS_TTL_DATALEN) == -1) { status = LDNS_STATUS_SYNTAX_TTL_ERR; goto error; } ttl_val = (uint32_t) ldns_str2period(ttl, &endptr); if (strlen(ttl) > 0 && !isdigit((int) ttl[0])) { /* ah, it's not there or something */ if (default_ttl == 0) { ttl_val = LDNS_DEFAULT_TTL; } else { ttl_val = default_ttl; } /* we not ASSUMING the TTL is missing and that * the rest of the RR is still there. That is * CLASS TYPE RDATA * so ttl value we read is actually the class */ clas_val = ldns_get_rr_class_by_name(ttl); /* class can be left out too, assume IN, current * token must be type */ if (clas_val == 0) { clas_val = LDNS_RR_CLASS_IN; type = LDNS_XMALLOC(char, strlen(ttl) + 1); if (!type) { goto memerror; } strncpy(type, ttl, strlen(ttl) + 1); } } else { if (-1 == ldns_bget_token( rr_buf, clas, "\t\n ", LDNS_SYNTAX_DATALEN)) { status = LDNS_STATUS_SYNTAX_CLASS_ERR; goto error; } clas_val = ldns_get_rr_class_by_name(clas); /* class can be left out too, assume IN, current * token must be type */ if (clas_val == 0) { clas_val = LDNS_RR_CLASS_IN; type = LDNS_XMALLOC(char, strlen(clas) + 1); if (!type) { goto memerror; } strncpy(type, clas, strlen(clas) + 1); } } /* the rest should still be waiting for us */ if (!type) { type = LDNS_XMALLOC(char, LDNS_SYNTAX_DATALEN); if (!type) { goto memerror; } if (-1 == ldns_bget_token( rr_buf, type, "\t\n ", LDNS_SYNTAX_DATALEN)) { status = LDNS_STATUS_SYNTAX_TYPE_ERR; goto error; } } if (ldns_bget_token(rr_buf, rdata, "\0", LDNS_MAX_PACKETLEN) == -1) { /* apparently we are done, and it's only a question RR * so do not set status and go to ldnserror here */ } ldns_buffer_new_frm_data(rd_buf, rdata, strlen(rdata)); if (strlen(owner) <= 1 && strncmp(owner, "@", 1) == 0) { if (origin) { ldns_rr_set_owner(new, ldns_rdf_clone(origin)); } else if (prev && *prev) { ldns_rr_set_owner(new, ldns_rdf_clone(*prev)); } else { /* default to root */ ldns_rr_set_owner(new, ldns_dname_new_frm_str(".")); } /* @ also overrides prev */ if (prev) { ldns_rdf_deep_free(*prev); *prev = ldns_rdf_clone(ldns_rr_owner(new)); if (!*prev) { goto memerror; } } } else { if (strlen(owner) == 0) { /* no ownername was given, try prev, if that fails * origin, else default to root */ if (prev && *prev) { ldns_rr_set_owner(new, ldns_rdf_clone(*prev)); } else if (origin) { ldns_rr_set_owner(new, ldns_rdf_clone(origin)); } else { ldns_rr_set_owner(new, ldns_dname_new_frm_str(".")); } if(!ldns_rr_owner(new)) { goto memerror; } } else { owner_dname = ldns_dname_new_frm_str(owner); if (!owner_dname) { status = LDNS_STATUS_SYNTAX_ERR; goto error; } ldns_rr_set_owner(new, owner_dname); if (!ldns_dname_str_absolute(owner) && origin) { if(ldns_dname_cat(ldns_rr_owner(new), origin) != LDNS_STATUS_OK) { status = LDNS_STATUS_SYNTAX_ERR; goto error; } } if (prev) { ldns_rdf_deep_free(*prev); *prev = ldns_rdf_clone(ldns_rr_owner(new)); if (!*prev) { goto error; } } } } LDNS_FREE(owner); ldns_rr_set_question(new, question); ldns_rr_set_ttl(new, ttl_val); LDNS_FREE(ttl); ldns_rr_set_class(new, clas_val); LDNS_FREE(clas); rr_type = ldns_get_rr_type_by_name(type); LDNS_FREE(type); desc = ldns_rr_descript((uint16_t)rr_type); ldns_rr_set_type(new, rr_type); if (desc) { /* only the rdata remains */ r_max = ldns_rr_descriptor_maximum(desc); r_min = ldns_rr_descriptor_minimum(desc); } else { r_min = 0; r_max = 1; } for (done = false, r_cnt = 0; !done && r_cnt < r_max; r_cnt++) { quoted = false; switch (ldns_rr_descriptor_field_type(desc, r_cnt)) { case LDNS_RDF_TYPE_B64 : case LDNS_RDF_TYPE_HEX : /* These rdf types may con- */ case LDNS_RDF_TYPE_LOC : /* tain whitespace, only if */ case LDNS_RDF_TYPE_WKS : /* it is the last rd field. */ case LDNS_RDF_TYPE_IPSECKEY : case LDNS_RDF_TYPE_NSEC : if (r_cnt == r_max - 1) { delimiters = "\n\t"; break; } default : delimiters = "\n\t "; } if (ldns_rdf_type_maybe_quoted( ldns_rr_descriptor_field_type( desc, r_cnt)) && ldns_buffer_remaining(rd_buf) > 0){ /* skip spaces */ while (*(ldns_buffer_current(rd_buf)) == ' ') { ldns_buffer_skip(rd_buf, 1); } if (*(ldns_buffer_current(rd_buf)) == '\"') { delimiters = "\"\0"; ldns_buffer_skip(rd_buf, 1); quoted = true; } } /* because number of fields can be variable, we can't rely on * _maximum() only */ /* skip spaces */ while (ldns_buffer_position(rd_buf) < ldns_buffer_limit(rd_buf) && *(ldns_buffer_current(rd_buf)) == ' ' && !quoted) { ldns_buffer_skip(rd_buf, 1); } pre_data_pos = ldns_buffer_position(rd_buf); if (-1 == (c = ldns_bget_token( rd_buf, rd, delimiters, LDNS_MAX_RDFLEN))) { done = true; break; } /* hmmz, rfc3597 specifies that any type can be represented * with \# method, which can contain spaces... * it does specify size though... */ rd_strlen = strlen(rd); /* unknown RR data */ if (strncmp(rd, "\\#", 2) == 0 && !quoted && (rd_strlen == 2 || rd[2]==' ')) { was_unknown_rr_format = 1; /* go back to before \# * and skip it while setting delimiters better */ ldns_buffer_set_position(rd_buf, pre_data_pos); delimiters = "\n\t "; (void)ldns_bget_token(rd_buf, rd, delimiters, LDNS_MAX_RDFLEN); /* read rdata octet length */ c = ldns_bget_token(rd_buf, rd, delimiters, LDNS_MAX_RDFLEN); if (c == -1) { /* something goes very wrong here */ status = LDNS_STATUS_SYNTAX_RDATA_ERR; goto error; } hex_data_size = (uint16_t) atoi(rd); /* copy hex chars into hex str (2 chars per byte) */ hex_data_str = LDNS_XMALLOC(char, 2*hex_data_size + 1); if (!hex_data_str) { /* malloc error */ goto memerror; } cur_hex_data_size = 0; while(cur_hex_data_size < 2 * hex_data_size) { c = ldns_bget_token(rd_buf, rd, delimiters, LDNS_MAX_RDFLEN); if (c != -1) { rd_strlen = strlen(rd); } if (c == -1 || (size_t)cur_hex_data_size + rd_strlen > 2 * (size_t)hex_data_size) { status = LDNS_STATUS_SYNTAX_RDATA_ERR; goto error; } strncpy(hex_data_str + cur_hex_data_size, rd, rd_strlen); cur_hex_data_size += rd_strlen; } hex_data_str[cur_hex_data_size] = '\0'; /* correct the rdf type */ /* if *we* know the type, interpret it as wireformat */ if (desc) { hex_pos = 0; hex_data = LDNS_XMALLOC(uint8_t, hex_data_size+2); if (!hex_data) { goto memerror; } ldns_write_uint16(hex_data, hex_data_size); ldns_hexstring_to_data( hex_data + 2, hex_data_str); status = ldns_wire2rdf(new, hex_data, hex_data_size + 2, &hex_pos); if (status != LDNS_STATUS_OK) { goto error; } LDNS_FREE(hex_data); } else { r = ldns_rdf_new_frm_str(LDNS_RDF_TYPE_HEX, hex_data_str); if (!r) { goto memerror; } ldns_rdf_set_type(r, LDNS_RDF_TYPE_UNKNOWN); if (!ldns_rr_push_rdf(new, r)) { goto memerror; } } LDNS_FREE(hex_data_str); } else { /* Normal RR */ switch(ldns_rr_descriptor_field_type(desc, r_cnt)) { case LDNS_RDF_TYPE_HEX: case LDNS_RDF_TYPE_B64: /* When this is the last rdata field, then the * rest should be read in (cause then these * rdf types may contain spaces). */ if (r_cnt == r_max - 1) { c = ldns_bget_token(rd_buf, xtok, "\n", LDNS_MAX_RDFLEN); if (c != -1) { (void) strncat(rd, xtok, LDNS_MAX_RDFLEN - strlen(rd) - 1); } } r = ldns_rdf_new_frm_str( ldns_rr_descriptor_field_type( desc, r_cnt), rd); break; case LDNS_RDF_TYPE_HIP: /* * In presentation format this RDATA type has * three tokens: An algorithm byte, then a * variable length HIT (in hexbytes) and then * a variable length Public Key (in base64). * * We have just read the algorithm, so we need * two more tokens: HIT and Public Key. */ do { /* Read and append HIT */ if (ldns_bget_token(rd_buf, xtok, delimiters, LDNS_MAX_RDFLEN) == -1) break; (void) strncat(rd, " ", LDNS_MAX_RDFLEN - strlen(rd) - 1); (void) strncat(rd, xtok, LDNS_MAX_RDFLEN - strlen(rd) - 1); /* Read and append Public Key*/ if (ldns_bget_token(rd_buf, xtok, delimiters, LDNS_MAX_RDFLEN) == -1) break; (void) strncat(rd, " ", LDNS_MAX_RDFLEN - strlen(rd) - 1); (void) strncat(rd, xtok, LDNS_MAX_RDFLEN - strlen(rd) - 1); } while (false); r = ldns_rdf_new_frm_str( ldns_rr_descriptor_field_type( desc, r_cnt), rd); break; case LDNS_RDF_TYPE_DNAME: r = ldns_rdf_new_frm_str( ldns_rr_descriptor_field_type( desc, r_cnt), rd); /* check if the origin should be used * or concatenated */ if (r && ldns_rdf_size(r) > 1 && ldns_rdf_data(r)[0] == 1 && ldns_rdf_data(r)[1] == '@') { ldns_rdf_deep_free(r); r = origin ? ldns_rdf_clone(origin) : ( rr_type == LDNS_RR_TYPE_SOA ? ldns_rdf_clone( ldns_rr_owner(new)) : ldns_rdf_new_frm_str( LDNS_RDF_TYPE_DNAME, ".") ); } else if (r && rd_strlen >= 1 && origin && !ldns_dname_str_absolute(rd)) { status = ldns_dname_cat(r, origin); if (status != LDNS_STATUS_OK) { goto error; } } break; default: r = ldns_rdf_new_frm_str( ldns_rr_descriptor_field_type( desc, r_cnt), rd); break; } if (!r) { status = LDNS_STATUS_SYNTAX_RDATA_ERR; goto error; } ldns_rr_push_rdf(new, r); } if (quoted) { if (ldns_buffer_available(rd_buf, 1)) { ldns_buffer_skip(rd_buf, 1); } else { done = true; } } } /* for (done = false, r_cnt = 0; !done && r_cnt < r_max; r_cnt++) */ LDNS_FREE(rd); LDNS_FREE(xtok); ldns_buffer_free(rd_buf); ldns_buffer_free(rr_buf); LDNS_FREE(rdata); if (!question && desc && !was_unknown_rr_format && ldns_rr_rd_count(new) < r_min) { ldns_rr_free(new); return LDNS_STATUS_SYNTAX_MISSING_VALUE_ERR; } if (newrr) { *newrr = new; } else { /* Maybe the caller just wanted to see if it would parse? */ ldns_rr_free(new); } return LDNS_STATUS_OK; memerror: status = LDNS_STATUS_MEM_ERR; error: if (rd_buf && rd_buf->_data) { ldns_buffer_free(rd_buf); } else { LDNS_FREE(rd_buf); } if (rr_buf && rr_buf->_data) { ldns_buffer_free(rr_buf); } else { LDNS_FREE(rr_buf); } LDNS_FREE(type); LDNS_FREE(owner); LDNS_FREE(ttl); LDNS_FREE(clas); LDNS_FREE(hex_data); LDNS_FREE(hex_data_str); LDNS_FREE(xtok); LDNS_FREE(rd); LDNS_FREE(rdata); ldns_rr_free(new); return status; } ldns_status ldns_rr_new_frm_str(ldns_rr **newrr, const char *str, uint32_t default_ttl, ldns_rdf *origin, ldns_rdf **prev) { return ldns_rr_new_frm_str_internal(newrr, str, default_ttl, origin, prev, false); } ldns_status ldns_rr_new_question_frm_str(ldns_rr **newrr, const char *str, ldns_rdf *origin, ldns_rdf **prev) { return ldns_rr_new_frm_str_internal(newrr, str, 0, origin, prev, true); } ldns_status ldns_rr_new_frm_fp(ldns_rr **newrr, FILE *fp, uint32_t *ttl, ldns_rdf **origin, ldns_rdf **prev) { return ldns_rr_new_frm_fp_l(newrr, fp, ttl, origin, prev, NULL); } ldns_status ldns_rr_new_frm_fp_l(ldns_rr **newrr, FILE *fp, uint32_t *default_ttl, ldns_rdf **origin, ldns_rdf **prev, int *line_nr) { char *line; const char *endptr; /* unused */ ldns_rr *rr; uint32_t ttl; ldns_rdf *tmp; ldns_status s; ssize_t size; int offset = 0; if (default_ttl) { ttl = *default_ttl; } else { ttl = 0; } line = LDNS_XMALLOC(char, LDNS_MAX_LINELEN + 1); if (!line) { return LDNS_STATUS_MEM_ERR; } /* read an entire line in from the file */ if ((size = ldns_fget_token_l(fp, line, LDNS_PARSE_SKIP_SPACE, LDNS_MAX_LINELEN, line_nr)) == -1) { LDNS_FREE(line); /* if last line was empty, we are now at feof, which is not * always a parse error (happens when for instance last line * was a comment) */ return LDNS_STATUS_SYNTAX_ERR; } /* we can have the situation, where we've read ok, but still got * no bytes to play with, in this case size is 0 */ if (size == 0) { LDNS_FREE(line); return LDNS_STATUS_SYNTAX_EMPTY; } if (strncmp(line, "$ORIGIN", 7) == 0 && isspace(line[7])) { if (*origin) { ldns_rdf_deep_free(*origin); *origin = NULL; } offset = 8; while (isspace(line[offset])) { offset++; } tmp = ldns_rdf_new_frm_str(LDNS_RDF_TYPE_DNAME, line + offset); if (!tmp) { /* could not parse what next to $ORIGIN */ LDNS_FREE(line); return LDNS_STATUS_SYNTAX_DNAME_ERR; } *origin = tmp; s = LDNS_STATUS_SYNTAX_ORIGIN; } else if (strncmp(line, "$TTL", 4) == 0 && isspace(line[4])) { offset = 5; while (isspace(line[offset])) { offset++; } if (default_ttl) { *default_ttl = ldns_str2period(line + offset, &endptr); } s = LDNS_STATUS_SYNTAX_TTL; } else if (strncmp(line, "$INCLUDE", 8) == 0) { s = LDNS_STATUS_SYNTAX_INCLUDE; } else { if (origin && *origin) { s = ldns_rr_new_frm_str(&rr, (const char*) line, ttl, *origin, prev); } else { s = ldns_rr_new_frm_str(&rr, (const char*) line, ttl, NULL, prev); } } LDNS_FREE(line); if (s == LDNS_STATUS_OK) { if (newrr) { *newrr = rr; } else { /* Just testing if it would parse? */ ldns_rr_free(rr); } } return s; } void ldns_rr_set_owner(ldns_rr *rr, ldns_rdf *owner) { rr->_owner = owner; } void ldns_rr_set_question(ldns_rr *rr, bool question) { rr->_rr_question = question; } void ldns_rr_set_ttl(ldns_rr *rr, uint32_t ttl) { rr->_ttl = ttl; } void ldns_rr_set_rd_count(ldns_rr *rr, size_t count) { rr->_rd_count = count; } void ldns_rr_set_type(ldns_rr *rr, ldns_rr_type rr_type) { rr->_rr_type = rr_type; } void ldns_rr_set_class(ldns_rr *rr, ldns_rr_class rr_class) { rr->_rr_class = rr_class; } ldns_rdf * ldns_rr_set_rdf(ldns_rr *rr, const ldns_rdf *f, size_t position) { size_t rd_count; ldns_rdf *pop; rd_count = ldns_rr_rd_count(rr); if (position < rd_count) { /* dicard the old one */ pop = rr->_rdata_fields[position]; rr->_rdata_fields[position] = (ldns_rdf*)f; return pop; } else { return NULL; } } bool ldns_rr_push_rdf(ldns_rr *rr, const ldns_rdf *f) { size_t rd_count; ldns_rdf **rdata_fields; rd_count = ldns_rr_rd_count(rr); /* grow the array */ rdata_fields = LDNS_XREALLOC( rr->_rdata_fields, ldns_rdf *, rd_count + 1); if (!rdata_fields) { return false; } /* add the new member */ rr->_rdata_fields = rdata_fields; rr->_rdata_fields[rd_count] = (ldns_rdf*)f; ldns_rr_set_rd_count(rr, rd_count + 1); return true; } ldns_rdf * ldns_rr_pop_rdf(ldns_rr *rr) { size_t rd_count; ldns_rdf *pop; ldns_rdf** newrd; rd_count = ldns_rr_rd_count(rr); if (rd_count == 0) { return NULL; } pop = rr->_rdata_fields[rd_count - 1]; /* try to shrink the array */ if(rd_count > 1) { newrd = LDNS_XREALLOC( rr->_rdata_fields, ldns_rdf *, rd_count - 1); if(newrd) rr->_rdata_fields = newrd; } else { LDNS_FREE(rr->_rdata_fields); } ldns_rr_set_rd_count(rr, rd_count - 1); return pop; } ldns_rdf * ldns_rr_rdf(const ldns_rr *rr, size_t nr) { if (rr && nr < ldns_rr_rd_count(rr)) { return rr->_rdata_fields[nr]; } else { return NULL; } } ldns_rdf * ldns_rr_owner(const ldns_rr *rr) { return rr->_owner; } bool ldns_rr_is_question(const ldns_rr *rr) { return rr->_rr_question; } uint32_t ldns_rr_ttl(const ldns_rr *rr) { return rr->_ttl; } size_t ldns_rr_rd_count(const ldns_rr *rr) { return rr->_rd_count; } ldns_rr_type ldns_rr_get_type(const ldns_rr *rr) { return rr->_rr_type; } ldns_rr_class ldns_rr_get_class(const ldns_rr *rr) { return rr->_rr_class; } /* rr_lists */ size_t ldns_rr_list_rr_count(const ldns_rr_list *rr_list) { if (rr_list) { return rr_list->_rr_count; } else { return 0; } } ldns_rr * ldns_rr_list_set_rr(ldns_rr_list *rr_list, const ldns_rr *r, size_t count) { ldns_rr *old; if (count > ldns_rr_list_rr_count(rr_list)) { return NULL; } old = ldns_rr_list_rr(rr_list, count); /* overwrite old's pointer */ rr_list->_rrs[count] = (ldns_rr*)r; return old; } void ldns_rr_list_set_rr_count(ldns_rr_list *rr_list, size_t count) { assert(count <= rr_list->_rr_capacity); rr_list->_rr_count = count; } ldns_rr * ldns_rr_list_rr(const ldns_rr_list *rr_list, size_t nr) { if (nr < ldns_rr_list_rr_count(rr_list)) { return rr_list->_rrs[nr]; } else { return NULL; } } ldns_rr_list * ldns_rr_list_new(void) { ldns_rr_list *rr_list = LDNS_MALLOC(ldns_rr_list); if(!rr_list) return NULL; rr_list->_rr_count = 0; rr_list->_rr_capacity = 0; rr_list->_rrs = NULL; return rr_list; } void ldns_rr_list_free(ldns_rr_list *rr_list) { if (rr_list) { LDNS_FREE(rr_list->_rrs); LDNS_FREE(rr_list); } } void ldns_rr_list_deep_free(ldns_rr_list *rr_list) { size_t i; if (rr_list) { for (i=0; i < ldns_rr_list_rr_count(rr_list); i++) { ldns_rr_free(ldns_rr_list_rr(rr_list, i)); } LDNS_FREE(rr_list->_rrs); LDNS_FREE(rr_list); } } /* add right to left. So we modify *left! */ bool ldns_rr_list_cat(ldns_rr_list *left, ldns_rr_list *right) { size_t r_rr_count; size_t i; if (!left) { return false; } if (right) { r_rr_count = ldns_rr_list_rr_count(right); } else { r_rr_count = 0; } /* push right to left */ for(i = 0; i < r_rr_count; i++) { ldns_rr_list_push_rr(left, ldns_rr_list_rr(right, i)); } return true; } ldns_rr_list * ldns_rr_list_cat_clone(ldns_rr_list *left, ldns_rr_list *right) { size_t l_rr_count; size_t r_rr_count; size_t i; ldns_rr_list *cat; if (left) { l_rr_count = ldns_rr_list_rr_count(left); } else { return ldns_rr_list_clone(right); } if (right) { r_rr_count = ldns_rr_list_rr_count(right); } else { r_rr_count = 0; } cat = ldns_rr_list_new(); if (!cat) { return NULL; } /* left */ for(i = 0; i < l_rr_count; i++) { ldns_rr_list_push_rr(cat, ldns_rr_clone(ldns_rr_list_rr(left, i))); } /* right */ for(i = 0; i < r_rr_count; i++) { ldns_rr_list_push_rr(cat, ldns_rr_clone(ldns_rr_list_rr(right, i))); } return cat; } ldns_rr_list * ldns_rr_list_subtype_by_rdf(ldns_rr_list *l, ldns_rdf *r, size_t pos) { size_t i; ldns_rr_list *subtyped; ldns_rdf *list_rdf; subtyped = ldns_rr_list_new(); for(i = 0; i < ldns_rr_list_rr_count(l); i++) { list_rdf = ldns_rr_rdf( ldns_rr_list_rr(l, i), pos); if (!list_rdf) { /* pos is too large or any other error */ ldns_rr_list_deep_free(subtyped); return NULL; } if (ldns_rdf_compare(list_rdf, r) == 0) { /* a match */ ldns_rr_list_push_rr(subtyped, ldns_rr_clone(ldns_rr_list_rr(l, i))); } } if (ldns_rr_list_rr_count(subtyped) > 0) { return subtyped; } else { ldns_rr_list_free(subtyped); return NULL; } } bool ldns_rr_list_push_rr(ldns_rr_list *rr_list, const ldns_rr *rr) { size_t rr_count; size_t cap; rr_count = ldns_rr_list_rr_count(rr_list); cap = rr_list->_rr_capacity; /* grow the array */ if(rr_count+1 > cap) { ldns_rr **rrs; if(cap == 0) cap = LDNS_RRLIST_INIT; /* initial list size */ else cap *= 2; rrs = LDNS_XREALLOC(rr_list->_rrs, ldns_rr *, cap); if (!rrs) { return false; } rr_list->_rrs = rrs; rr_list->_rr_capacity = cap; } /* add the new member */ rr_list->_rrs[rr_count] = (ldns_rr*)rr; ldns_rr_list_set_rr_count(rr_list, rr_count + 1); return true; } bool ldns_rr_list_push_rr_list(ldns_rr_list *rr_list, const ldns_rr_list *push_list) { size_t i; for(i = 0; i < ldns_rr_list_rr_count(push_list); i++) { if (!ldns_rr_list_push_rr(rr_list, ldns_rr_list_rr(push_list, i))) { return false; } } return true; } ldns_rr * ldns_rr_list_pop_rr(ldns_rr_list *rr_list) { size_t rr_count; size_t cap; ldns_rr *pop; rr_count = ldns_rr_list_rr_count(rr_list); if (rr_count == 0) { return NULL; } cap = rr_list->_rr_capacity; pop = ldns_rr_list_rr(rr_list, rr_count - 1); /* shrink the array */ if(cap > LDNS_RRLIST_INIT && rr_count-1 <= cap/2) { ldns_rr** a; cap /= 2; a = LDNS_XREALLOC(rr_list->_rrs, ldns_rr *, cap); if(a) { rr_list->_rrs = a; rr_list->_rr_capacity = cap; } } ldns_rr_list_set_rr_count(rr_list, rr_count - 1); return pop; } ldns_rr_list * ldns_rr_list_pop_rr_list(ldns_rr_list *rr_list, size_t howmany) { /* pop a number of rr's and put them in a rr_list */ ldns_rr_list *popped; ldns_rr *p; size_t i = howmany; popped = ldns_rr_list_new(); if (!popped) { return NULL; } while(i > 0 && (p = ldns_rr_list_pop_rr(rr_list)) != NULL) { ldns_rr_list_push_rr(popped, p); i--; } if (i == howmany) { /* so i <= 0 */ ldns_rr_list_free(popped); return NULL; } else { return popped; } } bool ldns_rr_list_contains_rr(const ldns_rr_list *rr_list, ldns_rr *rr) { size_t i; if (!rr_list || !rr || ldns_rr_list_rr_count(rr_list) == 0) { return false; } for (i = 0; i < ldns_rr_list_rr_count(rr_list); i++) { if (rr == ldns_rr_list_rr(rr_list, i)) { return true; } else if (ldns_rr_compare(rr, ldns_rr_list_rr(rr_list, i)) == 0) { return true; } } return false; } bool ldns_is_rrset(ldns_rr_list *rr_list) { ldns_rr_type t; ldns_rr_class c; ldns_rdf *o; ldns_rr *tmp; size_t i; if (!rr_list || ldns_rr_list_rr_count(rr_list) == 0) { return false; } tmp = ldns_rr_list_rr(rr_list, 0); t = ldns_rr_get_type(tmp); c = ldns_rr_get_class(tmp); o = ldns_rr_owner(tmp); /* compare these with the rest of the rr_list, start with 1 */ for (i = 1; i < ldns_rr_list_rr_count(rr_list); i++) { tmp = ldns_rr_list_rr(rr_list, i); if (t != ldns_rr_get_type(tmp)) { return false; } if (c != ldns_rr_get_class(tmp)) { return false; } if (ldns_rdf_compare(o, ldns_rr_owner(tmp)) != 0) { return false; } } return true; } bool ldns_rr_set_push_rr(ldns_rr_list *rr_list, ldns_rr *rr) { size_t rr_count; size_t i; ldns_rr *last; assert(rr != NULL); rr_count = ldns_rr_list_rr_count(rr_list); if (rr_count == 0) { /* nothing there, so checking it is * not needed */ return ldns_rr_list_push_rr(rr_list, rr); } else { /* check with the final rr in the rr_list */ last = ldns_rr_list_rr(rr_list, rr_count - 1); if (ldns_rr_get_class(last) != ldns_rr_get_class(rr)) { return false; } if (ldns_rr_get_type(last) != ldns_rr_get_type(rr)) { return false; } /* only check if not equal to RRSIG */ if (ldns_rr_get_type(rr) != LDNS_RR_TYPE_RRSIG) { if (ldns_rr_ttl(last) != ldns_rr_ttl(rr)) { return false; } } if (ldns_rdf_compare(ldns_rr_owner(last), ldns_rr_owner(rr)) != 0) { return false; } /* ok, still alive - check if the rr already * exists - if so, dont' add it */ for(i = 0; i < rr_count; i++) { if(ldns_rr_compare( ldns_rr_list_rr(rr_list, i), rr) == 0) { return false; } } /* it's safe, push it */ return ldns_rr_list_push_rr(rr_list, rr); } } ldns_rr * ldns_rr_set_pop_rr(ldns_rr_list *rr_list) { return ldns_rr_list_pop_rr(rr_list); } ldns_rr_list * ldns_rr_list_pop_rrset(ldns_rr_list *rr_list) { ldns_rr_list *rrset; ldns_rr *last_rr = NULL; ldns_rr *next_rr; if (!rr_list) { return NULL; } rrset = ldns_rr_list_new(); if (!last_rr) { last_rr = ldns_rr_list_pop_rr(rr_list); if (!last_rr) { ldns_rr_list_free(rrset); return NULL; } else { ldns_rr_list_push_rr(rrset, last_rr); } } if (ldns_rr_list_rr_count(rr_list) > 0) { next_rr = ldns_rr_list_rr(rr_list, ldns_rr_list_rr_count(rr_list) - 1); } else { next_rr = NULL; } while (next_rr) { if ( ldns_rdf_compare(ldns_rr_owner(next_rr), ldns_rr_owner(last_rr)) == 0 && ldns_rr_get_type(next_rr) == ldns_rr_get_type(last_rr) && ldns_rr_get_class(next_rr) == ldns_rr_get_class(last_rr) ) { ldns_rr_list_push_rr(rrset, ldns_rr_list_pop_rr(rr_list)); if (ldns_rr_list_rr_count(rr_list) > 0) { last_rr = next_rr; next_rr = ldns_rr_list_rr(rr_list, ldns_rr_list_rr_count(rr_list) - 1); } else { next_rr = NULL; } } else { next_rr = NULL; } } return rrset; } ldns_rr * ldns_rr_clone(const ldns_rr *rr) { size_t i; ldns_rr *new_rr; if (!rr) { return NULL; } new_rr = ldns_rr_new(); if (!new_rr) { return NULL; } if (ldns_rr_owner(rr)) { ldns_rr_set_owner(new_rr, ldns_rdf_clone(ldns_rr_owner(rr))); } ldns_rr_set_ttl(new_rr, ldns_rr_ttl(rr)); ldns_rr_set_type(new_rr, ldns_rr_get_type(rr)); ldns_rr_set_class(new_rr, ldns_rr_get_class(rr)); ldns_rr_set_question(new_rr, ldns_rr_is_question(rr)); for (i = 0; i < ldns_rr_rd_count(rr); i++) { if (ldns_rr_rdf(rr,i)) { ldns_rr_push_rdf(new_rr, ldns_rdf_clone(ldns_rr_rdf(rr, i))); } } return new_rr; } ldns_rr_list * ldns_rr_list_clone(const ldns_rr_list *rrlist) { size_t i; ldns_rr_list *new_list; ldns_rr *r; if (!rrlist) { return NULL; } new_list = ldns_rr_list_new(); if (!new_list) { return NULL; } for (i = 0; i < ldns_rr_list_rr_count(rrlist); i++) { r = ldns_rr_clone( ldns_rr_list_rr(rrlist, i) ); if (!r) { /* huh, failure in cloning */ ldns_rr_list_deep_free(new_list); return NULL; } ldns_rr_list_push_rr(new_list, r); } return new_list; } static int qsort_schwartz_rr_compare(const void *a, const void *b) { int result = 0; ldns_rr *rr1, *rr2; ldns_buffer *rr1_buf, *rr2_buf; struct ldns_schwartzian_compare_struct *sa = *(struct ldns_schwartzian_compare_struct **) a; struct ldns_schwartzian_compare_struct *sb = *(struct ldns_schwartzian_compare_struct **) b; /* if we are doing 2wire, we need to do lowercasing on the dname (and maybe on the rdata) * this must be done for comparison only, so we need to have a temp var for both buffers, * which is only used when the transformed object value isn't there yet */ ldns_rr *canonical_a, *canonical_b; rr1 = (ldns_rr *) sa->original_object; rr2 = (ldns_rr *) sb->original_object; result = ldns_rr_compare_no_rdata(rr1, rr2); if (result == 0) { if (!sa->transformed_object) { canonical_a = ldns_rr_clone(sa->original_object); ldns_rr2canonical(canonical_a); sa->transformed_object = ldns_buffer_new(ldns_rr_uncompressed_size(canonical_a)); if (ldns_rr2buffer_wire(sa->transformed_object, canonical_a, LDNS_SECTION_ANY) != LDNS_STATUS_OK) { ldns_buffer_free((ldns_buffer *)sa->transformed_object); sa->transformed_object = NULL; ldns_rr_free(canonical_a); return 0; } ldns_rr_free(canonical_a); } if (!sb->transformed_object) { canonical_b = ldns_rr_clone(sb->original_object); ldns_rr2canonical(canonical_b); sb->transformed_object = ldns_buffer_new(ldns_rr_uncompressed_size(canonical_b)); if (ldns_rr2buffer_wire(sb->transformed_object, canonical_b, LDNS_SECTION_ANY) != LDNS_STATUS_OK) { ldns_buffer_free((ldns_buffer *)sa->transformed_object); ldns_buffer_free((ldns_buffer *)sb->transformed_object); sa->transformed_object = NULL; sb->transformed_object = NULL; ldns_rr_free(canonical_b); return 0; } ldns_rr_free(canonical_b); } rr1_buf = (ldns_buffer *) sa->transformed_object; rr2_buf = (ldns_buffer *) sb->transformed_object; result = ldns_rr_compare_wire(rr1_buf, rr2_buf); } return result; } void ldns_rr_list_sort(ldns_rr_list *unsorted) { struct ldns_schwartzian_compare_struct **sortables; size_t item_count; size_t i; if (unsorted) { item_count = ldns_rr_list_rr_count(unsorted); sortables = LDNS_XMALLOC(struct ldns_schwartzian_compare_struct *, item_count); if(!sortables) return; /* no way to return error */ for (i = 0; i < item_count; i++) { sortables[i] = LDNS_XMALLOC(struct ldns_schwartzian_compare_struct, 1); if(!sortables[i]) { /* free the allocated parts */ while(i>0) { i--; LDNS_FREE(sortables[i]); } /* no way to return error */ LDNS_FREE(sortables); return; } sortables[i]->original_object = ldns_rr_list_rr(unsorted, i); sortables[i]->transformed_object = NULL; } qsort(sortables, item_count, sizeof(struct ldns_schwartzian_compare_struct *), qsort_schwartz_rr_compare); for (i = 0; i < item_count; i++) { unsorted->_rrs[i] = sortables[i]->original_object; if (sortables[i]->transformed_object) { ldns_buffer_free(sortables[i]->transformed_object); } LDNS_FREE(sortables[i]); } LDNS_FREE(sortables); } } int ldns_rr_compare_no_rdata(const ldns_rr *rr1, const ldns_rr *rr2) { size_t rr1_len; size_t rr2_len; size_t offset; assert(rr1 != NULL); assert(rr2 != NULL); rr1_len = ldns_rr_uncompressed_size(rr1); rr2_len = ldns_rr_uncompressed_size(rr2); if (ldns_dname_compare(ldns_rr_owner(rr1), ldns_rr_owner(rr2)) < 0) { return -1; } else if (ldns_dname_compare(ldns_rr_owner(rr1), ldns_rr_owner(rr2)) > 0) { return 1; } /* should return -1 if rr1 comes before rr2, so need to do rr1 - rr2, not rr2 - rr1 */ if (ldns_rr_get_class(rr1) != ldns_rr_get_class(rr2)) { return ldns_rr_get_class(rr1) - ldns_rr_get_class(rr2); } /* should return -1 if rr1 comes before rr2, so need to do rr1 - rr2, not rr2 - rr1 */ if (ldns_rr_get_type(rr1) != ldns_rr_get_type(rr2)) { return ldns_rr_get_type(rr1) - ldns_rr_get_type(rr2); } /* offset is the owername length + ttl + type + class + rdlen == start of wire format rdata */ offset = ldns_rdf_size(ldns_rr_owner(rr1)) + 4 + 2 + 2 + 2; /* if either record doesn't have any RDATA... */ if (offset > rr1_len || offset > rr2_len) { if (rr1_len == rr2_len) { return 0; } return ((int) rr2_len - (int) rr1_len); } return 0; } int ldns_rr_compare_wire(ldns_buffer *rr1_buf, ldns_buffer *rr2_buf) { size_t rr1_len, rr2_len, min_len, i, offset; rr1_len = ldns_buffer_capacity(rr1_buf); rr2_len = ldns_buffer_capacity(rr2_buf); /* jump past dname (checked in earlier part) * and especially past TTL */ offset = 0; while (offset < rr1_len && *ldns_buffer_at(rr1_buf, offset) != 0) { offset += *ldns_buffer_at(rr1_buf, offset) + 1; } /* jump to rdata section (PAST the rdata length field, otherwise rrs with different lengths might be sorted erroneously */ offset += 11; min_len = (rr1_len < rr2_len) ? rr1_len : rr2_len; /* Compare RRs RDATA byte for byte. */ for(i = offset; i < min_len; i++) { if (*ldns_buffer_at(rr1_buf,i) < *ldns_buffer_at(rr2_buf,i)) { return -1; } else if (*ldns_buffer_at(rr1_buf,i) > *ldns_buffer_at(rr2_buf,i)) { return +1; } } /* If both RDATAs are the same up to min_len, then the shorter one sorts first. */ if (rr1_len < rr2_len) { return -1; } else if (rr1_len > rr2_len) { return +1; } /* The RDATAs are equal. */ return 0; } int ldns_rr_compare(const ldns_rr *rr1, const ldns_rr *rr2) { int result; size_t rr1_len, rr2_len; ldns_buffer *rr1_buf; ldns_buffer *rr2_buf; result = ldns_rr_compare_no_rdata(rr1, rr2); if (result == 0) { rr1_len = ldns_rr_uncompressed_size(rr1); rr2_len = ldns_rr_uncompressed_size(rr2); rr1_buf = ldns_buffer_new(rr1_len); rr2_buf = ldns_buffer_new(rr2_len); if (ldns_rr2buffer_wire_canonical(rr1_buf, rr1, LDNS_SECTION_ANY) != LDNS_STATUS_OK) { ldns_buffer_free(rr1_buf); ldns_buffer_free(rr2_buf); return 0; } if (ldns_rr2buffer_wire_canonical(rr2_buf, rr2, LDNS_SECTION_ANY) != LDNS_STATUS_OK) { ldns_buffer_free(rr1_buf); ldns_buffer_free(rr2_buf); return 0; } result = ldns_rr_compare_wire(rr1_buf, rr2_buf); ldns_buffer_free(rr1_buf); ldns_buffer_free(rr2_buf); } return result; } /* convert dnskey to a ds with the given algorithm, * then compare the result with the given ds */ static int ldns_rr_compare_ds_dnskey(ldns_rr *ds, ldns_rr *dnskey) { ldns_rr *ds_gen; bool result = false; ldns_hash algo; if (!dnskey || !ds || ldns_rr_get_type(ds) != LDNS_RR_TYPE_DS || ldns_rr_get_type(dnskey) != LDNS_RR_TYPE_DNSKEY) { return false; } if (ldns_rr_rdf(ds, 2) == NULL) { return false; } algo = ldns_rdf2native_int8(ldns_rr_rdf(ds, 2)); ds_gen = ldns_key_rr2ds(dnskey, algo); if (ds_gen) { result = ldns_rr_compare(ds, ds_gen) == 0; ldns_rr_free(ds_gen); } return result; } bool ldns_rr_compare_ds(const ldns_rr *orr1, const ldns_rr *orr2) { bool result; ldns_rr *rr1 = ldns_rr_clone(orr1); ldns_rr *rr2 = ldns_rr_clone(orr2); /* set ttls to zero */ ldns_rr_set_ttl(rr1, 0); ldns_rr_set_ttl(rr2, 0); if (ldns_rr_get_type(rr1) == LDNS_RR_TYPE_DS && ldns_rr_get_type(rr2) == LDNS_RR_TYPE_DNSKEY) { result = ldns_rr_compare_ds_dnskey(rr1, rr2); } else if (ldns_rr_get_type(rr1) == LDNS_RR_TYPE_DNSKEY && ldns_rr_get_type(rr2) == LDNS_RR_TYPE_DS) { result = ldns_rr_compare_ds_dnskey(rr2, rr1); } else { result = (ldns_rr_compare(rr1, rr2) == 0); } ldns_rr_free(rr1); ldns_rr_free(rr2); return result; } int ldns_rr_list_compare(const ldns_rr_list *rrl1, const ldns_rr_list *rrl2) { size_t i = 0; int rr_cmp; assert(rrl1 != NULL); assert(rrl2 != NULL); for (i = 0; i < ldns_rr_list_rr_count(rrl1) && i < ldns_rr_list_rr_count(rrl2); i++) { rr_cmp = ldns_rr_compare(ldns_rr_list_rr(rrl1, i), ldns_rr_list_rr(rrl2, i)); if (rr_cmp != 0) { return rr_cmp; } } if (i == ldns_rr_list_rr_count(rrl1) && i != ldns_rr_list_rr_count(rrl2)) { return 1; } else if (i == ldns_rr_list_rr_count(rrl2) && i != ldns_rr_list_rr_count(rrl1)) { return -1; } else { return 0; } } size_t ldns_rr_uncompressed_size(const ldns_rr *r) { size_t rrsize; size_t i; rrsize = 0; /* add all the rdf sizes */ for(i = 0; i < ldns_rr_rd_count(r); i++) { rrsize += ldns_rdf_size(ldns_rr_rdf(r, i)); } /* ownername */ rrsize += ldns_rdf_size(ldns_rr_owner(r)); rrsize += LDNS_RR_OVERHEAD; return rrsize; } void ldns_rr2canonical(ldns_rr *rr) { uint16_t i; if (!rr) { return; } ldns_dname2canonical(ldns_rr_owner(rr)); /* * lowercase the rdata dnames if the rr type is one * of the list in chapter 7 of RFC3597 * Also added RRSIG, because a "Signer's Name" should be canonicalized * too. See dnssec-bis-updates-16. We can add it to this list because * the "Signer's Name" is the only dname type rdata field in a RRSIG. */ switch(ldns_rr_get_type(rr)) { case LDNS_RR_TYPE_NS: case LDNS_RR_TYPE_MD: case LDNS_RR_TYPE_MF: case LDNS_RR_TYPE_CNAME: case LDNS_RR_TYPE_SOA: case LDNS_RR_TYPE_MB: case LDNS_RR_TYPE_MG: case LDNS_RR_TYPE_MR: case LDNS_RR_TYPE_PTR: case LDNS_RR_TYPE_MINFO: case LDNS_RR_TYPE_MX: case LDNS_RR_TYPE_RP: case LDNS_RR_TYPE_AFSDB: case LDNS_RR_TYPE_RT: case LDNS_RR_TYPE_SIG: case LDNS_RR_TYPE_PX: case LDNS_RR_TYPE_NXT: case LDNS_RR_TYPE_NAPTR: case LDNS_RR_TYPE_KX: case LDNS_RR_TYPE_SRV: case LDNS_RR_TYPE_DNAME: case LDNS_RR_TYPE_A6: case LDNS_RR_TYPE_RRSIG: for (i = 0; i < ldns_rr_rd_count(rr); i++) { ldns_dname2canonical(ldns_rr_rdf(rr, i)); } return; default: /* do nothing */ return; } } void ldns_rr_list2canonical(ldns_rr_list *rr_list) { size_t i; for (i = 0; i < ldns_rr_list_rr_count(rr_list); i++) { ldns_rr2canonical(ldns_rr_list_rr(rr_list, i)); } } uint8_t ldns_rr_label_count(ldns_rr *rr) { if (!rr) { return 0; } return ldns_dname_label_count( ldns_rr_owner(rr)); } /** \cond */ static const ldns_rdf_type type_0_wireformat[] = { LDNS_RDF_TYPE_UNKNOWN }; static const ldns_rdf_type type_a_wireformat[] = { LDNS_RDF_TYPE_A }; static const ldns_rdf_type type_ns_wireformat[] = { LDNS_RDF_TYPE_DNAME }; static const ldns_rdf_type type_md_wireformat[] = { LDNS_RDF_TYPE_DNAME }; static const ldns_rdf_type type_mf_wireformat[] = { LDNS_RDF_TYPE_DNAME }; static const ldns_rdf_type type_cname_wireformat[] = { LDNS_RDF_TYPE_DNAME }; static const ldns_rdf_type type_soa_wireformat[] = { LDNS_RDF_TYPE_DNAME, LDNS_RDF_TYPE_DNAME, LDNS_RDF_TYPE_INT32, LDNS_RDF_TYPE_PERIOD, LDNS_RDF_TYPE_PERIOD, LDNS_RDF_TYPE_PERIOD, LDNS_RDF_TYPE_PERIOD }; static const ldns_rdf_type type_mb_wireformat[] = { LDNS_RDF_TYPE_DNAME }; static const ldns_rdf_type type_mg_wireformat[] = { LDNS_RDF_TYPE_DNAME }; static const ldns_rdf_type type_mr_wireformat[] = { LDNS_RDF_TYPE_DNAME }; static const ldns_rdf_type type_wks_wireformat[] = { LDNS_RDF_TYPE_A, LDNS_RDF_TYPE_WKS }; static const ldns_rdf_type type_ptr_wireformat[] = { LDNS_RDF_TYPE_DNAME }; static const ldns_rdf_type type_hinfo_wireformat[] = { LDNS_RDF_TYPE_STR, LDNS_RDF_TYPE_STR }; static const ldns_rdf_type type_minfo_wireformat[] = { LDNS_RDF_TYPE_DNAME, LDNS_RDF_TYPE_DNAME }; static const ldns_rdf_type type_mx_wireformat[] = { LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_DNAME }; static const ldns_rdf_type type_rp_wireformat[] = { LDNS_RDF_TYPE_DNAME, LDNS_RDF_TYPE_DNAME }; static const ldns_rdf_type type_afsdb_wireformat[] = { LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_DNAME }; static const ldns_rdf_type type_x25_wireformat[] = { LDNS_RDF_TYPE_STR }; static const ldns_rdf_type type_isdn_wireformat[] = { LDNS_RDF_TYPE_STR, LDNS_RDF_TYPE_STR }; static const ldns_rdf_type type_rt_wireformat[] = { LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_DNAME }; static const ldns_rdf_type type_nsap_wireformat[] = { LDNS_RDF_TYPE_NSAP }; static const ldns_rdf_type type_nsap_ptr_wireformat[] = { LDNS_RDF_TYPE_STR }; static const ldns_rdf_type type_sig_wireformat[] = { LDNS_RDF_TYPE_TYPE, LDNS_RDF_TYPE_ALG, LDNS_RDF_TYPE_INT8, LDNS_RDF_TYPE_INT32, LDNS_RDF_TYPE_TIME, LDNS_RDF_TYPE_TIME, LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_DNAME, LDNS_RDF_TYPE_B64 }; static const ldns_rdf_type type_key_wireformat[] = { LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_INT8, LDNS_RDF_TYPE_INT8, LDNS_RDF_TYPE_B64 }; static const ldns_rdf_type type_px_wireformat[] = { LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_DNAME, LDNS_RDF_TYPE_DNAME }; static const ldns_rdf_type type_gpos_wireformat[] = { LDNS_RDF_TYPE_STR, LDNS_RDF_TYPE_STR, LDNS_RDF_TYPE_STR }; static const ldns_rdf_type type_aaaa_wireformat[] = { LDNS_RDF_TYPE_AAAA }; static const ldns_rdf_type type_loc_wireformat[] = { LDNS_RDF_TYPE_LOC }; static const ldns_rdf_type type_nxt_wireformat[] = { LDNS_RDF_TYPE_DNAME, LDNS_RDF_TYPE_UNKNOWN }; static const ldns_rdf_type type_eid_wireformat[] = { LDNS_RDF_TYPE_HEX }; static const ldns_rdf_type type_nimloc_wireformat[] = { LDNS_RDF_TYPE_HEX }; static const ldns_rdf_type type_srv_wireformat[] = { LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_DNAME }; static const ldns_rdf_type type_atma_wireformat[] = { LDNS_RDF_TYPE_ATMA }; static const ldns_rdf_type type_naptr_wireformat[] = { LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_STR, LDNS_RDF_TYPE_STR, LDNS_RDF_TYPE_STR, LDNS_RDF_TYPE_DNAME }; static const ldns_rdf_type type_kx_wireformat[] = { LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_DNAME }; static const ldns_rdf_type type_cert_wireformat[] = { LDNS_RDF_TYPE_CERT_ALG, LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_ALG, LDNS_RDF_TYPE_B64 }; static const ldns_rdf_type type_a6_wireformat[] = { LDNS_RDF_TYPE_UNKNOWN }; static const ldns_rdf_type type_dname_wireformat[] = { LDNS_RDF_TYPE_DNAME }; static const ldns_rdf_type type_sink_wireformat[] = { LDNS_RDF_TYPE_INT8, LDNS_RDF_TYPE_INT8, LDNS_RDF_TYPE_INT8, LDNS_RDF_TYPE_B64 }; static const ldns_rdf_type type_apl_wireformat[] = { LDNS_RDF_TYPE_APL }; static const ldns_rdf_type type_ds_wireformat[] = { LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_ALG, LDNS_RDF_TYPE_INT8, LDNS_RDF_TYPE_HEX }; static const ldns_rdf_type type_sshfp_wireformat[] = { LDNS_RDF_TYPE_INT8, LDNS_RDF_TYPE_INT8, LDNS_RDF_TYPE_HEX }; static const ldns_rdf_type type_ipseckey_wireformat[] = { LDNS_RDF_TYPE_IPSECKEY }; static const ldns_rdf_type type_rrsig_wireformat[] = { LDNS_RDF_TYPE_TYPE, LDNS_RDF_TYPE_ALG, LDNS_RDF_TYPE_INT8, LDNS_RDF_TYPE_INT32, LDNS_RDF_TYPE_TIME, LDNS_RDF_TYPE_TIME, LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_DNAME, LDNS_RDF_TYPE_B64 }; static const ldns_rdf_type type_nsec_wireformat[] = { LDNS_RDF_TYPE_DNAME, LDNS_RDF_TYPE_NSEC }; static const ldns_rdf_type type_dhcid_wireformat[] = { LDNS_RDF_TYPE_B64 }; static const ldns_rdf_type type_talink_wireformat[] = { LDNS_RDF_TYPE_DNAME, LDNS_RDF_TYPE_DNAME }; /* nsec3 is some vars, followed by same type of data of nsec */ static const ldns_rdf_type type_nsec3_wireformat[] = { /* LDNS_RDF_TYPE_NSEC3_VARS, LDNS_RDF_TYPE_NSEC3_NEXT_OWNER, LDNS_RDF_TYPE_NSEC*/ LDNS_RDF_TYPE_INT8, LDNS_RDF_TYPE_INT8, LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_NSEC3_SALT, LDNS_RDF_TYPE_NSEC3_NEXT_OWNER, LDNS_RDF_TYPE_NSEC }; static const ldns_rdf_type type_nsec3param_wireformat[] = { /* LDNS_RDF_TYPE_NSEC3_PARAMS_VARS*/ LDNS_RDF_TYPE_INT8, LDNS_RDF_TYPE_INT8, LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_NSEC3_SALT }; static const ldns_rdf_type type_dnskey_wireformat[] = { LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_INT8, LDNS_RDF_TYPE_ALG, LDNS_RDF_TYPE_B64 }; static const ldns_rdf_type type_tkey_wireformat[] = { LDNS_RDF_TYPE_DNAME, LDNS_RDF_TYPE_TIME, LDNS_RDF_TYPE_TIME, LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_INT16_DATA, LDNS_RDF_TYPE_INT16_DATA, }; static const ldns_rdf_type type_tsig_wireformat[] = { LDNS_RDF_TYPE_DNAME, LDNS_RDF_TYPE_TSIGTIME, LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_INT16_DATA, LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_INT16_DATA }; static const ldns_rdf_type type_tlsa_wireformat[] = { LDNS_RDF_TYPE_INT8, LDNS_RDF_TYPE_INT8, LDNS_RDF_TYPE_INT8, LDNS_RDF_TYPE_HEX }; static const ldns_rdf_type type_hip_wireformat[] = { LDNS_RDF_TYPE_HIP }; static const ldns_rdf_type type_nid_wireformat[] = { LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_ILNP64 }; static const ldns_rdf_type type_l32_wireformat[] = { LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_A }; static const ldns_rdf_type type_l64_wireformat[] = { LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_ILNP64 }; static const ldns_rdf_type type_lp_wireformat[] = { LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_DNAME }; static const ldns_rdf_type type_eui48_wireformat[] = { LDNS_RDF_TYPE_EUI48 }; static const ldns_rdf_type type_eui64_wireformat[] = { LDNS_RDF_TYPE_EUI64 }; #ifdef RRTYPE_URI static const ldns_rdf_type type_uri_wireformat[] = { LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_LONG_STR }; #endif static const ldns_rdf_type type_caa_wireformat[] = { LDNS_RDF_TYPE_INT8, LDNS_RDF_TYPE_TAG, LDNS_RDF_TYPE_LONG_STR }; /** \endcond */ /** \cond */ /* All RR's defined in 1035 are well known and can thus * be compressed. See RFC3597. These RR's are: * CNAME HINFO MB MD MF MG MINFO MR MX NULL NS PTR SOA TXT */ static ldns_rr_descriptor rdata_field_descriptors[] = { /* 0 */ { 0, NULL, 0, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, /* 1 */ {LDNS_RR_TYPE_A, "A", 1, 1, type_a_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, /* 2 */ {LDNS_RR_TYPE_NS, "NS", 1, 1, type_ns_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_COMPRESS, 1 }, /* 3 */ {LDNS_RR_TYPE_MD, "MD", 1, 1, type_md_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_COMPRESS, 1 }, /* 4 */ {LDNS_RR_TYPE_MF, "MF", 1, 1, type_mf_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_COMPRESS, 1 }, /* 5 */ {LDNS_RR_TYPE_CNAME, "CNAME", 1, 1, type_cname_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_COMPRESS, 1 }, /* 6 */ {LDNS_RR_TYPE_SOA, "SOA", 7, 7, type_soa_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_COMPRESS, 2 }, /* 7 */ {LDNS_RR_TYPE_MB, "MB", 1, 1, type_mb_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_COMPRESS, 1 }, /* 8 */ {LDNS_RR_TYPE_MG, "MG", 1, 1, type_mg_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_COMPRESS, 1 }, /* 9 */ {LDNS_RR_TYPE_MR, "MR", 1, 1, type_mr_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_COMPRESS, 1 }, /* 10 */ {LDNS_RR_TYPE_NULL, "NULL", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, /* 11 */ {LDNS_RR_TYPE_WKS, "WKS", 2, 2, type_wks_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, /* 12 */ {LDNS_RR_TYPE_PTR, "PTR", 1, 1, type_ptr_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_COMPRESS, 1 }, /* 13 */ {LDNS_RR_TYPE_HINFO, "HINFO", 2, 2, type_hinfo_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, /* 14 */ {LDNS_RR_TYPE_MINFO, "MINFO", 2, 2, type_minfo_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_COMPRESS, 2 }, /* 15 */ {LDNS_RR_TYPE_MX, "MX", 2, 2, type_mx_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_COMPRESS, 1 }, /* 16 */ {LDNS_RR_TYPE_TXT, "TXT", 1, 0, NULL, LDNS_RDF_TYPE_STR, LDNS_RR_NO_COMPRESS, 0 }, /* 17 */ {LDNS_RR_TYPE_RP, "RP", 2, 2, type_rp_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 2 }, /* 18 */ {LDNS_RR_TYPE_AFSDB, "AFSDB", 2, 2, type_afsdb_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 1 }, /* 19 */ {LDNS_RR_TYPE_X25, "X25", 1, 1, type_x25_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, /* 20 */ {LDNS_RR_TYPE_ISDN, "ISDN", 1, 2, type_isdn_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, /* 21 */ {LDNS_RR_TYPE_RT, "RT", 2, 2, type_rt_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 1 }, /* 22 */ {LDNS_RR_TYPE_NSAP, "NSAP", 1, 1, type_nsap_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, /* 23 */ {LDNS_RR_TYPE_NSAP_PTR, "NSAP-PTR", 1, 1, type_nsap_ptr_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, /* 24 */ {LDNS_RR_TYPE_SIG, "SIG", 9, 9, type_sig_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 1 }, /* 25 */ {LDNS_RR_TYPE_KEY, "KEY", 4, 4, type_key_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, /* 26 */ {LDNS_RR_TYPE_PX, "PX", 3, 3, type_px_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 2 }, /* 27 */ {LDNS_RR_TYPE_GPOS, "GPOS", 3, 3, type_gpos_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, /* 28 */ {LDNS_RR_TYPE_AAAA, "AAAA", 1, 1, type_aaaa_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, /* 29 */ {LDNS_RR_TYPE_LOC, "LOC", 1, 1, type_loc_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, /* 30 */ {LDNS_RR_TYPE_NXT, "NXT", 2, 2, type_nxt_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 1 }, /* 31 */ {LDNS_RR_TYPE_EID, "EID", 1, 1, type_eid_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, /* 32 */ {LDNS_RR_TYPE_NIMLOC, "NIMLOC", 1, 1, type_nimloc_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, /* 33 */ {LDNS_RR_TYPE_SRV, "SRV", 4, 4, type_srv_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 1 }, /* 34 */ {LDNS_RR_TYPE_ATMA, "ATMA", 1, 1, type_atma_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, /* 35 */ {LDNS_RR_TYPE_NAPTR, "NAPTR", 6, 6, type_naptr_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 1 }, /* 36 */ {LDNS_RR_TYPE_KX, "KX", 2, 2, type_kx_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 1 }, /* 37 */ {LDNS_RR_TYPE_CERT, "CERT", 4, 4, type_cert_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, /* 38 */ {LDNS_RR_TYPE_A6, "A6", 1, 1, type_a6_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, /* 39 */ {LDNS_RR_TYPE_DNAME, "DNAME", 1, 1, type_dname_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 1 }, /* 40 */ {LDNS_RR_TYPE_SINK, "SINK", 1, 1, type_sink_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, /* 41 */ {LDNS_RR_TYPE_OPT, "OPT", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, /* 42 */ {LDNS_RR_TYPE_APL, "APL", 0, 0, type_apl_wireformat, LDNS_RDF_TYPE_APL, LDNS_RR_NO_COMPRESS, 0 }, /* 43 */ {LDNS_RR_TYPE_DS, "DS", 4, 4, type_ds_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, /* 44 */ {LDNS_RR_TYPE_SSHFP, "SSHFP", 3, 3, type_sshfp_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, /* 45 */ {LDNS_RR_TYPE_IPSECKEY, "IPSECKEY", 1, 1, type_ipseckey_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, /* 46 */ {LDNS_RR_TYPE_RRSIG, "RRSIG", 9, 9, type_rrsig_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 1 }, /* 47 */ {LDNS_RR_TYPE_NSEC, "NSEC", 1, 2, type_nsec_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 1 }, /* 48 */ {LDNS_RR_TYPE_DNSKEY, "DNSKEY", 4, 4, type_dnskey_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, /* 49 */ {LDNS_RR_TYPE_DHCID, "DHCID", 1, 1, type_dhcid_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, /* 50 */ {LDNS_RR_TYPE_NSEC3, "NSEC3", 5, 6, type_nsec3_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, /* 51 */ {LDNS_RR_TYPE_NSEC3PARAM, "NSEC3PARAM", 4, 4, type_nsec3param_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, /* 52 */ {LDNS_RR_TYPE_TLSA, "TLSA", 4, 4, type_tlsa_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE53", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE54", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, /* 55 * Hip ends with 0 or more Rendezvous Servers represented as dname's. * Hence the LDNS_RDF_TYPE_DNAME _variable field and the _maximum field * set to 0. */ {LDNS_RR_TYPE_HIP, "HIP", 1, 1, type_hip_wireformat, LDNS_RDF_TYPE_DNAME, LDNS_RR_NO_COMPRESS, 0 }, #ifdef RRTYPE_NINFO /* 56 */ {LDNS_RR_TYPE_NINFO, "NINFO", 1, 0, NULL, LDNS_RDF_TYPE_STR, LDNS_RR_NO_COMPRESS, 0 }, #else {LDNS_RR_TYPE_NULL, "TYPE56", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, #endif #ifdef RRTYPE_RKEY /* 57 */ {LDNS_RR_TYPE_RKEY, "RKEY", 4, 4, type_key_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, #else {LDNS_RR_TYPE_NULL, "TYPE57", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, #endif /* 58 */ {LDNS_RR_TYPE_TALINK, "TALINK", 2, 2, type_talink_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 2 }, #ifdef RRTYPE_CDS /* 59 */ {LDNS_RR_TYPE_CDS, "CDS", 4, 4, type_ds_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, #else {LDNS_RR_TYPE_NULL, "TYPE59", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, #endif {LDNS_RR_TYPE_NULL, "TYPE60", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE61", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE62", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE63", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE64", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE65", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE66", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE67", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE68", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE69", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE70", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE71", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE72", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE73", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE74", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE75", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE76", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE77", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE78", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE79", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE80", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE81", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE82", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE83", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE84", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE85", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE86", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE87", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE88", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE89", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE90", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE91", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE92", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE93", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE94", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE95", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE96", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE97", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE98", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, /* 99 */ {LDNS_RR_TYPE_SPF, "SPF", 1, 0, NULL, LDNS_RDF_TYPE_STR, LDNS_RR_NO_COMPRESS, 0 }, /* UINFO [IANA-Reserved] */ {LDNS_RR_TYPE_NULL, "TYPE100", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, /* UID [IANA-Reserved] */ {LDNS_RR_TYPE_NULL, "TYPE101", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, /* GID [IANA-Reserved] */ {LDNS_RR_TYPE_NULL, "TYPE102", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, /* UNSPEC [IANA-Reserved] */ {LDNS_RR_TYPE_NULL, "TYPE103", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, /* 104 */ {LDNS_RR_TYPE_NID, "NID", 2, 2, type_nid_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, /* 105 */ {LDNS_RR_TYPE_L32, "L32", 2, 2, type_l32_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, /* 106 */ {LDNS_RR_TYPE_L64, "L64", 2, 2, type_l64_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, /* 107 */ {LDNS_RR_TYPE_LP, "LP", 2, 2, type_lp_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 1 }, /* 108 */ {LDNS_RR_TYPE_EUI48, "EUI48", 1, 1, type_eui48_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, /* 109 */ {LDNS_RR_TYPE_EUI64, "EUI64", 1, 1, type_eui64_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE110", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE111", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE112", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE113", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE114", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE115", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE116", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE117", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE118", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE119", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE120", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE121", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE122", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE123", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE124", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE125", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE126", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE127", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE128", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE129", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE130", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE131", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE132", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE133", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE134", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE135", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE136", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE137", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE138", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE139", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE140", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE141", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE142", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE143", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE144", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE145", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE146", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE147", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE148", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE149", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE150", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE151", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE152", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE153", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE154", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE155", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE156", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE157", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE158", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE159", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE160", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE161", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE162", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE163", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE164", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE165", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE166", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE167", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE168", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE169", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE170", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE171", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE172", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE173", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE174", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE175", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE176", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE177", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE178", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE179", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE180", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE181", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE182", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE183", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE184", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE185", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE186", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE187", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE188", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE189", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE190", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE191", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE192", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE193", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE194", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE195", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE196", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE197", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE198", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE199", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE200", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE201", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE202", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE203", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE204", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE205", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE206", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE207", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE208", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE209", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE210", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE211", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE212", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE213", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE214", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE215", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE216", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE217", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE218", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE219", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE220", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE221", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE222", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE223", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE224", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE225", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE226", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE227", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE228", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE229", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE230", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE231", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE232", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE233", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE234", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE235", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE236", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE237", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE238", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE239", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE240", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE241", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE242", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE243", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE244", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE245", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE246", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE247", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, {LDNS_RR_TYPE_NULL, "TYPE248", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, /* LDNS_RDF_TYPE_INT16_DATA takes two fields (length and data) as one. * So, unlike RFC 2930 spec, we have 7 min/max rdf's i.s.o. 8/9. */ /* 249 */ {LDNS_RR_TYPE_TKEY, "TKEY", 7, 7, type_tkey_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 1 }, /* LDNS_RDF_TYPE_INT16_DATA takes two fields (length and data) as one. * So, unlike RFC 2930 spec, we have 7 min/max rdf's i.s.o. 8/9. */ /* 250 */ {LDNS_RR_TYPE_TSIG, "TSIG", 7, 7, type_tsig_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 1 }, /* IXFR: A request for a transfer of an incremental zone transfer */ {LDNS_RR_TYPE_NULL, "TYPE251", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, /* AXFR: A request for a transfer of an entire zone */ {LDNS_RR_TYPE_NULL, "TYPE252", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, /* MAILB: A request for mailbox-related records (MB, MG or MR) */ {LDNS_RR_TYPE_NULL, "TYPE253", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, /* MAILA: A request for mail agent RRs (Obsolete - see MX) */ {LDNS_RR_TYPE_NULL, "TYPE254", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, /* ANY: A request for all (available) records */ {LDNS_RR_TYPE_NULL, "TYPE255", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, #ifdef RRTYPE_URI /* 256 */ {LDNS_RR_TYPE_URI, "URI", 3, 3, type_uri_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, #else {LDNS_RR_TYPE_NULL, "TYPE256", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, #endif /* 257 */ {LDNS_RR_TYPE_CAA, "CAA", 3, 3, type_caa_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, /* split in array, no longer contiguous */ #ifdef RRTYPE_TA /* 32768 */ {LDNS_RR_TYPE_TA, "TA", 4, 4, type_ds_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, #else {LDNS_RR_TYPE_NULL, "TYPE32768", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, #endif /* 32769 */ {LDNS_RR_TYPE_DLV, "DLV", 4, 4, type_ds_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 } }; /** \endcond */ /** * \def LDNS_RDATA_FIELD_DESCRIPTORS_COUNT * computes the number of rdata fields */ #define LDNS_RDATA_FIELD_DESCRIPTORS_COUNT \ (sizeof(rdata_field_descriptors)/sizeof(rdata_field_descriptors[0])) /*---------------------------------------------------------------------------* * The functions below return an bitmap RDF with the space required to set * or unset all known RR types. Arguably these functions are better situated * in rdata.c, however for the space calculation it is necesarry to walk * through rdata_field_descriptors which is not easily possible from anywhere * other than rr.c where it is declared static. * * Alternatively rr.c could have provided an iterator for rr_type or * rdf_descriptors, but this seemed overkill for internal use only. */ static ldns_rr_descriptor* rdata_field_descriptors_end = &rdata_field_descriptors[LDNS_RDATA_FIELD_DESCRIPTORS_COUNT]; /* From RFC3845: * * 2.1.2. The List of Type Bit Map(s) Field * * The RR type space is split into 256 window blocks, each representing * the low-order 8 bits of the 16-bit RR type space. Each block that * has at least one active RR type is encoded using a single octet * window number (from 0 to 255), a single octet bitmap length (from 1 * to 32) indicating the number of octets used for the window block's * bitmap, and up to 32 octets (256 bits) of bitmap. * * Window blocks are present in the NSEC RR RDATA in increasing * numerical order. * * "|" denotes concatenation * * Type Bit Map(s) Field = ( Window Block # | Bitmap Length | Bitmap ) + * * * * Blocks with no types present MUST NOT be included. Trailing zero * octets in the bitmap MUST be omitted. The length of each block's * bitmap is determined by the type code with the largest numerical * value within that block, among the set of RR types present at the * NSEC RR's owner name. Trailing zero octets not specified MUST be * interpreted as zero octets. */ static ldns_status ldns_rdf_bitmap_known_rr_types_set(ldns_rdf** rdf, int value) { uint8_t window; /* most significant octet of type */ uint8_t subtype; /* least significant octet of type */ uint16_t windows[256] /* Max subtype per window */ #ifndef S_SPLINT_S = { 0 } #endif ; ldns_rr_descriptor* d; /* used to traverse rdata_field_descriptors */ size_t i; /* used to traverse windows array */ size_t sz; /* size needed for type bitmap rdf */ uint8_t* data = NULL; /* rdf data */ uint8_t* dptr; /* used to itraverse rdf data */ assert(rdf != NULL); /* Which windows need to be in the bitmap rdf? */ for (d=rdata_field_descriptors; d < rdata_field_descriptors_end; d++) { window = d->_type >> 8; subtype = d->_type & 0xff; if (windows[window] < subtype) { windows[window] = subtype; } } /* How much space do we need in the rdf for those windows? */ sz = 0; for (i = 0; i < 256; i++) { if (windows[i]) { sz += windows[i] / 8 + 3; } } if (sz > 0) { /* Format rdf data according RFC3845 Section 2.1.2 (see above) */ dptr = data = LDNS_XMALLOC(uint8_t, sz); memset(data, value, sz); if (!data) { return LDNS_STATUS_MEM_ERR; } for (i = 0; i < 256; i++) { if (windows[i]) { *dptr++ = (uint8_t)i; *dptr++ = (uint8_t)(windows[i] / 8 + 1); dptr += dptr[-1]; } } } /* Allocate and return rdf structure for the data */ *rdf = ldns_rdf_new(LDNS_RDF_TYPE_BITMAP, sz, data); if (!*rdf) { LDNS_FREE(data); return LDNS_STATUS_MEM_ERR; } return LDNS_STATUS_OK; } ldns_status ldns_rdf_bitmap_known_rr_types_space(ldns_rdf** rdf) { return ldns_rdf_bitmap_known_rr_types_set(rdf, 0); } ldns_status ldns_rdf_bitmap_known_rr_types(ldns_rdf** rdf) { return ldns_rdf_bitmap_known_rr_types_set(rdf, 255); } /* End of RDF bitmap functions *---------------------------------------------------------------------------*/ const ldns_rr_descriptor * ldns_rr_descript(uint16_t type) { size_t i; if (type < LDNS_RDATA_FIELD_DESCRIPTORS_COMMON) { return &rdata_field_descriptors[type]; } else { /* because not all array index equals type code */ for (i = LDNS_RDATA_FIELD_DESCRIPTORS_COMMON; i < LDNS_RDATA_FIELD_DESCRIPTORS_COUNT; i++) { if (rdata_field_descriptors[i]._type == type) { return &rdata_field_descriptors[i]; } } return &rdata_field_descriptors[0]; } } size_t ldns_rr_descriptor_minimum(const ldns_rr_descriptor *descriptor) { if (descriptor) { return descriptor->_minimum; } else { return 0; } } size_t ldns_rr_descriptor_maximum(const ldns_rr_descriptor *descriptor) { if (descriptor) { if (descriptor->_variable != LDNS_RDF_TYPE_NONE) { /* Should really be SIZE_MAX... bad FreeBSD. */ return UINT_MAX; } else { return descriptor->_maximum; } } else { return 0; } } ldns_rdf_type ldns_rr_descriptor_field_type(const ldns_rr_descriptor *descriptor, size_t index) { assert(descriptor != NULL); assert(index < descriptor->_maximum || descriptor->_variable != LDNS_RDF_TYPE_NONE); if (index < descriptor->_maximum) { return descriptor->_wireformat[index]; } else { return descriptor->_variable; } } ldns_rr_type ldns_get_rr_type_by_name(const char *name) { unsigned int i; const char *desc_name; const ldns_rr_descriptor *desc; /* TYPEXX representation */ if (strlen(name) > 4 && strncasecmp(name, "TYPE", 4) == 0) { return atoi(name + 4); } /* Normal types */ for (i = 0; i < (unsigned int) LDNS_RDATA_FIELD_DESCRIPTORS_COUNT; i++) { desc = &rdata_field_descriptors[i]; desc_name = desc->_name; if(desc_name && strlen(name) == strlen(desc_name) && strncasecmp(name, desc_name, strlen(desc_name)) == 0) { /* because not all array index equals type code */ return desc->_type; } } /* special cases for query types */ if (strlen(name) == 4 && strncasecmp(name, "IXFR", 4) == 0) { return 251; } else if (strlen(name) == 4 && strncasecmp(name, "AXFR", 4) == 0) { return 252; } else if (strlen(name) == 5 && strncasecmp(name, "MAILB", 5) == 0) { return 253; } else if (strlen(name) == 5 && strncasecmp(name, "MAILA", 5) == 0) { return 254; } else if (strlen(name) == 3 && strncasecmp(name, "ANY", 3) == 0) { return 255; } return 0; } ldns_rr_class ldns_get_rr_class_by_name(const char *name) { ldns_lookup_table *lt; /* CLASSXX representation */ if (strlen(name) > 5 && strncasecmp(name, "CLASS", 5) == 0) { return atoi(name + 5); } /* Normal types */ lt = ldns_lookup_by_name(ldns_rr_classes, name); if (lt) { return lt->id; } return 0; } ldns_rr_type ldns_rdf2rr_type(const ldns_rdf *rd) { ldns_rr_type r; if (!rd) { return 0; } if (ldns_rdf_get_type(rd) != LDNS_RDF_TYPE_TYPE) { return 0; } r = (ldns_rr_type) ldns_rdf2native_int16(rd); return r; } ldns_rr_type ldns_rr_list_type(const ldns_rr_list *rr_list) { if (rr_list && ldns_rr_list_rr_count(rr_list) > 0) { return ldns_rr_get_type(ldns_rr_list_rr(rr_list, 0)); } else { return 0; } } ldns_rdf * ldns_rr_list_owner(const ldns_rr_list *rr_list) { if (rr_list && ldns_rr_list_rr_count(rr_list) > 0) { return ldns_rr_owner(ldns_rr_list_rr(rr_list, 0)); } else { return NULL; } } ldns-1.6.17/sha2.c0000664000175100017510000007356412264060151013133 0ustar willemwillem/* * FILE: sha2.c * AUTHOR: Aaron D. Gifford - http://www.aarongifford.com/ * * Copyright (c) 2000-2001, Aaron D. Gifford * All rights reserved. * * Modified by Jelte Jansen to fit in ldns, and not clash with any * system-defined SHA code. * Changes: * - Renamed (external) functions and constants to fit ldns style * - Removed _End and _Data functions * - Added ldns_shaX(data, len, digest) convenience functions * - Removed prototypes of _Transform functions and made those static * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. Neither the name of the copyright holder nor the names of contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTOR(S) ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTOR(S) BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * $Id: sha2.c,v 1.1 2001/11/08 00:01:51 adg Exp adg $ */ #include #include /* memcpy()/memset() or bcopy()/bzero() */ #include /* assert() */ #include /* * ASSERT NOTE: * Some sanity checking code is included using assert(). On my FreeBSD * system, this additional code can be removed by compiling with NDEBUG * defined. Check your own systems manpage on assert() to see how to * compile WITHOUT the sanity checking code on your system. * * UNROLLED TRANSFORM LOOP NOTE: * You can define SHA2_UNROLL_TRANSFORM to use the unrolled transform * loop version for the hash transform rounds (defined using macros * later in this file). Either define on the command line, for example: * * cc -DSHA2_UNROLL_TRANSFORM -o sha2 sha2.c sha2prog.c * * or define below: * * #define SHA2_UNROLL_TRANSFORM * */ /*** SHA-256/384/512 Machine Architecture Definitions *****************/ /* * BYTE_ORDER NOTE: * * Please make sure that your system defines BYTE_ORDER. If your * architecture is little-endian, make sure it also defines * LITTLE_ENDIAN and that the two (BYTE_ORDER and LITTLE_ENDIAN) are * equivilent. * * If your system does not define the above, then you can do so by * hand like this: * * #define LITTLE_ENDIAN 1234 * #define BIG_ENDIAN 4321 * * And for little-endian machines, add: * * #define BYTE_ORDER LITTLE_ENDIAN * * Or for big-endian machines: * * #define BYTE_ORDER BIG_ENDIAN * * The FreeBSD machine this was written on defines BYTE_ORDER * appropriately by including (which in turn includes * where the appropriate definitions are actually * made). */ #if !defined(BYTE_ORDER) || (BYTE_ORDER != LITTLE_ENDIAN && BYTE_ORDER != BIG_ENDIAN) #error Define BYTE_ORDER to be equal to either LITTLE_ENDIAN or BIG_ENDIAN #endif typedef uint8_t sha2_byte; /* Exactly 1 byte */ typedef uint32_t sha2_word32; /* Exactly 4 bytes */ #ifdef S_SPLINT_S typedef unsigned long long sha2_word64; /* lint 8 bytes */ #else typedef uint64_t sha2_word64; /* Exactly 8 bytes */ #endif /*** SHA-256/384/512 Various Length Definitions ***********************/ /* NOTE: Most of these are in sha2.h */ #define ldns_sha256_SHORT_BLOCK_LENGTH (LDNS_SHA256_BLOCK_LENGTH - 8) #define ldns_sha384_SHORT_BLOCK_LENGTH (LDNS_SHA384_BLOCK_LENGTH - 16) #define ldns_sha512_SHORT_BLOCK_LENGTH (LDNS_SHA512_BLOCK_LENGTH - 16) /*** ENDIAN REVERSAL MACROS *******************************************/ #if BYTE_ORDER == LITTLE_ENDIAN #define REVERSE32(w,x) { \ sha2_word32 tmp = (w); \ tmp = (tmp >> 16) | (tmp << 16); \ (x) = ((tmp & 0xff00ff00UL) >> 8) | ((tmp & 0x00ff00ffUL) << 8); \ } #ifndef S_SPLINT_S #define REVERSE64(w,x) { \ sha2_word64 tmp = (w); \ tmp = (tmp >> 32) | (tmp << 32); \ tmp = ((tmp & 0xff00ff00ff00ff00ULL) >> 8) | \ ((tmp & 0x00ff00ff00ff00ffULL) << 8); \ (x) = ((tmp & 0xffff0000ffff0000ULL) >> 16) | \ ((tmp & 0x0000ffff0000ffffULL) << 16); \ } #else /* splint */ #define REVERSE64(w,x) /* splint */ #endif /* splint */ #endif /* BYTE_ORDER == LITTLE_ENDIAN */ /* * Macro for incrementally adding the unsigned 64-bit integer n to the * unsigned 128-bit integer (represented using a two-element array of * 64-bit words): */ #define ADDINC128(w,n) { \ (w)[0] += (sha2_word64)(n); \ if ((w)[0] < (n)) { \ (w)[1]++; \ } \ } #ifdef S_SPLINT_S #undef ADDINC128 #define ADDINC128(w,n) /* splint */ #endif /* * Macros for copying blocks of memory and for zeroing out ranges * of memory. Using these macros makes it easy to switch from * using memset()/memcpy() and using bzero()/bcopy(). * * Please define either SHA2_USE_MEMSET_MEMCPY or define * SHA2_USE_BZERO_BCOPY depending on which function set you * choose to use: */ #if !defined(SHA2_USE_MEMSET_MEMCPY) && !defined(SHA2_USE_BZERO_BCOPY) /* Default to memset()/memcpy() if no option is specified */ #define SHA2_USE_MEMSET_MEMCPY 1 #endif #if defined(SHA2_USE_MEMSET_MEMCPY) && defined(SHA2_USE_BZERO_BCOPY) /* Abort with an error if BOTH options are defined */ #error Define either SHA2_USE_MEMSET_MEMCPY or SHA2_USE_BZERO_BCOPY, not both! #endif #ifdef SHA2_USE_MEMSET_MEMCPY #define MEMSET_BZERO(p,l) memset((p), 0, (l)) #define MEMCPY_BCOPY(d,s,l) memcpy((d), (s), (l)) #endif #ifdef SHA2_USE_BZERO_BCOPY #define MEMSET_BZERO(p,l) bzero((p), (l)) #define MEMCPY_BCOPY(d,s,l) bcopy((s), (d), (l)) #endif /*** THE SIX LOGICAL FUNCTIONS ****************************************/ /* * Bit shifting and rotation (used by the six SHA-XYZ logical functions: * * NOTE: The naming of R and S appears backwards here (R is a SHIFT and * S is a ROTATION) because the SHA-256/384/512 description document * (see http://csrc.nist.gov/cryptval/shs/sha256-384-512.pdf) uses this * same "backwards" definition. */ /* Shift-right (used in SHA-256, SHA-384, and SHA-512): */ #define R(b,x) ((x) >> (b)) /* 32-bit Rotate-right (used in SHA-256): */ #define S32(b,x) (((x) >> (b)) | ((x) << (32 - (b)))) /* 64-bit Rotate-right (used in SHA-384 and SHA-512): */ #define S64(b,x) (((x) >> (b)) | ((x) << (64 - (b)))) /* Two of six logical functions used in SHA-256, SHA-384, and SHA-512: */ #define Ch(x,y,z) (((x) & (y)) ^ ((~(x)) & (z))) #define Maj(x,y,z) (((x) & (y)) ^ ((x) & (z)) ^ ((y) & (z))) /* Four of six logical functions used in SHA-256: */ #define Sigma0_256(x) (S32(2, (x)) ^ S32(13, (x)) ^ S32(22, (x))) #define Sigma1_256(x) (S32(6, (x)) ^ S32(11, (x)) ^ S32(25, (x))) #define sigma0_256(x) (S32(7, (x)) ^ S32(18, (x)) ^ R(3 , (x))) #define sigma1_256(x) (S32(17, (x)) ^ S32(19, (x)) ^ R(10, (x))) /* Four of six logical functions used in SHA-384 and SHA-512: */ #define Sigma0_512(x) (S64(28, (x)) ^ S64(34, (x)) ^ S64(39, (x))) #define Sigma1_512(x) (S64(14, (x)) ^ S64(18, (x)) ^ S64(41, (x))) #define sigma0_512(x) (S64( 1, (x)) ^ S64( 8, (x)) ^ R( 7, (x))) #define sigma1_512(x) (S64(19, (x)) ^ S64(61, (x)) ^ R( 6, (x))) /*** SHA-XYZ INITIAL HASH VALUES AND CONSTANTS ************************/ /* Hash constant words K for SHA-256: */ static const sha2_word32 K256[64] = { 0x428a2f98UL, 0x71374491UL, 0xb5c0fbcfUL, 0xe9b5dba5UL, 0x3956c25bUL, 0x59f111f1UL, 0x923f82a4UL, 0xab1c5ed5UL, 0xd807aa98UL, 0x12835b01UL, 0x243185beUL, 0x550c7dc3UL, 0x72be5d74UL, 0x80deb1feUL, 0x9bdc06a7UL, 0xc19bf174UL, 0xe49b69c1UL, 0xefbe4786UL, 0x0fc19dc6UL, 0x240ca1ccUL, 0x2de92c6fUL, 0x4a7484aaUL, 0x5cb0a9dcUL, 0x76f988daUL, 0x983e5152UL, 0xa831c66dUL, 0xb00327c8UL, 0xbf597fc7UL, 0xc6e00bf3UL, 0xd5a79147UL, 0x06ca6351UL, 0x14292967UL, 0x27b70a85UL, 0x2e1b2138UL, 0x4d2c6dfcUL, 0x53380d13UL, 0x650a7354UL, 0x766a0abbUL, 0x81c2c92eUL, 0x92722c85UL, 0xa2bfe8a1UL, 0xa81a664bUL, 0xc24b8b70UL, 0xc76c51a3UL, 0xd192e819UL, 0xd6990624UL, 0xf40e3585UL, 0x106aa070UL, 0x19a4c116UL, 0x1e376c08UL, 0x2748774cUL, 0x34b0bcb5UL, 0x391c0cb3UL, 0x4ed8aa4aUL, 0x5b9cca4fUL, 0x682e6ff3UL, 0x748f82eeUL, 0x78a5636fUL, 0x84c87814UL, 0x8cc70208UL, 0x90befffaUL, 0xa4506cebUL, 0xbef9a3f7UL, 0xc67178f2UL }; /* initial hash value H for SHA-256: */ static const sha2_word32 ldns_sha256_initial_hash_value[8] = { 0x6a09e667UL, 0xbb67ae85UL, 0x3c6ef372UL, 0xa54ff53aUL, 0x510e527fUL, 0x9b05688cUL, 0x1f83d9abUL, 0x5be0cd19UL }; /* Hash constant words K for SHA-384 and SHA-512: */ static const sha2_word64 K512[80] = { 0x428a2f98d728ae22ULL, 0x7137449123ef65cdULL, 0xb5c0fbcfec4d3b2fULL, 0xe9b5dba58189dbbcULL, 0x3956c25bf348b538ULL, 0x59f111f1b605d019ULL, 0x923f82a4af194f9bULL, 0xab1c5ed5da6d8118ULL, 0xd807aa98a3030242ULL, 0x12835b0145706fbeULL, 0x243185be4ee4b28cULL, 0x550c7dc3d5ffb4e2ULL, 0x72be5d74f27b896fULL, 0x80deb1fe3b1696b1ULL, 0x9bdc06a725c71235ULL, 0xc19bf174cf692694ULL, 0xe49b69c19ef14ad2ULL, 0xefbe4786384f25e3ULL, 0x0fc19dc68b8cd5b5ULL, 0x240ca1cc77ac9c65ULL, 0x2de92c6f592b0275ULL, 0x4a7484aa6ea6e483ULL, 0x5cb0a9dcbd41fbd4ULL, 0x76f988da831153b5ULL, 0x983e5152ee66dfabULL, 0xa831c66d2db43210ULL, 0xb00327c898fb213fULL, 0xbf597fc7beef0ee4ULL, 0xc6e00bf33da88fc2ULL, 0xd5a79147930aa725ULL, 0x06ca6351e003826fULL, 0x142929670a0e6e70ULL, 0x27b70a8546d22ffcULL, 0x2e1b21385c26c926ULL, 0x4d2c6dfc5ac42aedULL, 0x53380d139d95b3dfULL, 0x650a73548baf63deULL, 0x766a0abb3c77b2a8ULL, 0x81c2c92e47edaee6ULL, 0x92722c851482353bULL, 0xa2bfe8a14cf10364ULL, 0xa81a664bbc423001ULL, 0xc24b8b70d0f89791ULL, 0xc76c51a30654be30ULL, 0xd192e819d6ef5218ULL, 0xd69906245565a910ULL, 0xf40e35855771202aULL, 0x106aa07032bbd1b8ULL, 0x19a4c116b8d2d0c8ULL, 0x1e376c085141ab53ULL, 0x2748774cdf8eeb99ULL, 0x34b0bcb5e19b48a8ULL, 0x391c0cb3c5c95a63ULL, 0x4ed8aa4ae3418acbULL, 0x5b9cca4f7763e373ULL, 0x682e6ff3d6b2b8a3ULL, 0x748f82ee5defb2fcULL, 0x78a5636f43172f60ULL, 0x84c87814a1f0ab72ULL, 0x8cc702081a6439ecULL, 0x90befffa23631e28ULL, 0xa4506cebde82bde9ULL, 0xbef9a3f7b2c67915ULL, 0xc67178f2e372532bULL, 0xca273eceea26619cULL, 0xd186b8c721c0c207ULL, 0xeada7dd6cde0eb1eULL, 0xf57d4f7fee6ed178ULL, 0x06f067aa72176fbaULL, 0x0a637dc5a2c898a6ULL, 0x113f9804bef90daeULL, 0x1b710b35131c471bULL, 0x28db77f523047d84ULL, 0x32caab7b40c72493ULL, 0x3c9ebe0a15c9bebcULL, 0x431d67c49c100d4cULL, 0x4cc5d4becb3e42b6ULL, 0x597f299cfc657e2aULL, 0x5fcb6fab3ad6faecULL, 0x6c44198c4a475817ULL }; /* initial hash value H for SHA-384 */ static const sha2_word64 sha384_initial_hash_value[8] = { 0xcbbb9d5dc1059ed8ULL, 0x629a292a367cd507ULL, 0x9159015a3070dd17ULL, 0x152fecd8f70e5939ULL, 0x67332667ffc00b31ULL, 0x8eb44a8768581511ULL, 0xdb0c2e0d64f98fa7ULL, 0x47b5481dbefa4fa4ULL }; /* initial hash value H for SHA-512 */ static const sha2_word64 sha512_initial_hash_value[8] = { 0x6a09e667f3bcc908ULL, 0xbb67ae8584caa73bULL, 0x3c6ef372fe94f82bULL, 0xa54ff53a5f1d36f1ULL, 0x510e527fade682d1ULL, 0x9b05688c2b3e6c1fULL, 0x1f83d9abfb41bd6bULL, 0x5be0cd19137e2179ULL }; /*** SHA-256: *********************************************************/ void ldns_sha256_init(ldns_sha256_CTX* context) { if (context == (ldns_sha256_CTX*)0) { return; } MEMCPY_BCOPY(context->state, ldns_sha256_initial_hash_value, LDNS_SHA256_DIGEST_LENGTH); MEMSET_BZERO(context->buffer, LDNS_SHA256_BLOCK_LENGTH); context->bitcount = 0; } #ifdef SHA2_UNROLL_TRANSFORM /* Unrolled SHA-256 round macros: */ #if BYTE_ORDER == LITTLE_ENDIAN #define ROUND256_0_TO_15(a,b,c,d,e,f,g,h) \ REVERSE32(*data++, W256[j]); \ T1 = (h) + Sigma1_256(e) + Ch((e), (f), (g)) + \ K256[j] + W256[j]; \ (d) += T1; \ (h) = T1 + Sigma0_256(a) + Maj((a), (b), (c)); \ j++ #else /* BYTE_ORDER == LITTLE_ENDIAN */ #define ROUND256_0_TO_15(a,b,c,d,e,f,g,h) \ T1 = (h) + Sigma1_256(e) + Ch((e), (f), (g)) + \ K256[j] + (W256[j] = *data++); \ (d) += T1; \ (h) = T1 + Sigma0_256(a) + Maj((a), (b), (c)); \ j++ #endif /* BYTE_ORDER == LITTLE_ENDIAN */ #define ROUND256(a,b,c,d,e,f,g,h) \ s0 = W256[(j+1)&0x0f]; \ s0 = sigma0_256(s0); \ s1 = W256[(j+14)&0x0f]; \ s1 = sigma1_256(s1); \ T1 = (h) + Sigma1_256(e) + Ch((e), (f), (g)) + K256[j] + \ (W256[j&0x0f] += s1 + W256[(j+9)&0x0f] + s0); \ (d) += T1; \ (h) = T1 + Sigma0_256(a) + Maj((a), (b), (c)); \ j++ static void ldns_sha256_Transform(ldns_sha256_CTX* context, const sha2_word32* data) { sha2_word32 a, b, c, d, e, f, g, h, s0, s1; sha2_word32 T1, *W256; int j; W256 = (sha2_word32*)context->buffer; /* initialize registers with the prev. intermediate value */ a = context->state[0]; b = context->state[1]; c = context->state[2]; d = context->state[3]; e = context->state[4]; f = context->state[5]; g = context->state[6]; h = context->state[7]; j = 0; do { /* Rounds 0 to 15 (unrolled): */ ROUND256_0_TO_15(a,b,c,d,e,f,g,h); ROUND256_0_TO_15(h,a,b,c,d,e,f,g); ROUND256_0_TO_15(g,h,a,b,c,d,e,f); ROUND256_0_TO_15(f,g,h,a,b,c,d,e); ROUND256_0_TO_15(e,f,g,h,a,b,c,d); ROUND256_0_TO_15(d,e,f,g,h,a,b,c); ROUND256_0_TO_15(c,d,e,f,g,h,a,b); ROUND256_0_TO_15(b,c,d,e,f,g,h,a); } while (j < 16); /* Now for the remaining rounds to 64: */ do { ROUND256(a,b,c,d,e,f,g,h); ROUND256(h,a,b,c,d,e,f,g); ROUND256(g,h,a,b,c,d,e,f); ROUND256(f,g,h,a,b,c,d,e); ROUND256(e,f,g,h,a,b,c,d); ROUND256(d,e,f,g,h,a,b,c); ROUND256(c,d,e,f,g,h,a,b); ROUND256(b,c,d,e,f,g,h,a); } while (j < 64); /* Compute the current intermediate hash value */ context->state[0] += a; context->state[1] += b; context->state[2] += c; context->state[3] += d; context->state[4] += e; context->state[5] += f; context->state[6] += g; context->state[7] += h; /* Clean up */ a = b = c = d = e = f = g = h = T1 = 0; } #else /* SHA2_UNROLL_TRANSFORM */ static void ldns_sha256_Transform(ldns_sha256_CTX* context, const sha2_word32* data) { sha2_word32 a, b, c, d, e, f, g, h, s0, s1; sha2_word32 T1, T2, *W256; int j; W256 = (sha2_word32*)context->buffer; /* initialize registers with the prev. intermediate value */ a = context->state[0]; b = context->state[1]; c = context->state[2]; d = context->state[3]; e = context->state[4]; f = context->state[5]; g = context->state[6]; h = context->state[7]; j = 0; do { #if BYTE_ORDER == LITTLE_ENDIAN /* Copy data while converting to host byte order */ REVERSE32(*data++,W256[j]); /* Apply the SHA-256 compression function to update a..h */ T1 = h + Sigma1_256(e) + Ch(e, f, g) + K256[j] + W256[j]; #else /* BYTE_ORDER == LITTLE_ENDIAN */ /* Apply the SHA-256 compression function to update a..h with copy */ T1 = h + Sigma1_256(e) + Ch(e, f, g) + K256[j] + (W256[j] = *data++); #endif /* BYTE_ORDER == LITTLE_ENDIAN */ T2 = Sigma0_256(a) + Maj(a, b, c); h = g; g = f; f = e; e = d + T1; d = c; c = b; b = a; a = T1 + T2; j++; } while (j < 16); do { /* Part of the message block expansion: */ s0 = W256[(j+1)&0x0f]; s0 = sigma0_256(s0); s1 = W256[(j+14)&0x0f]; s1 = sigma1_256(s1); /* Apply the SHA-256 compression function to update a..h */ T1 = h + Sigma1_256(e) + Ch(e, f, g) + K256[j] + (W256[j&0x0f] += s1 + W256[(j+9)&0x0f] + s0); T2 = Sigma0_256(a) + Maj(a, b, c); h = g; g = f; f = e; e = d + T1; d = c; c = b; b = a; a = T1 + T2; j++; } while (j < 64); /* Compute the current intermediate hash value */ context->state[0] += a; context->state[1] += b; context->state[2] += c; context->state[3] += d; context->state[4] += e; context->state[5] += f; context->state[6] += g; context->state[7] += h; /* Clean up */ a = b = c = d = e = f = g = h = T1 = T2 = 0; } #endif /* SHA2_UNROLL_TRANSFORM */ void ldns_sha256_update(ldns_sha256_CTX* context, const sha2_byte *data, size_t len) { size_t freespace, usedspace; if (len == 0) { /* Calling with no data is valid - we do nothing */ return; } /* Sanity check: */ assert(context != (ldns_sha256_CTX*)0 && data != (sha2_byte*)0); usedspace = (context->bitcount >> 3) % LDNS_SHA256_BLOCK_LENGTH; if (usedspace > 0) { /* Calculate how much free space is available in the buffer */ freespace = LDNS_SHA256_BLOCK_LENGTH - usedspace; if (len >= freespace) { /* Fill the buffer completely and process it */ MEMCPY_BCOPY(&context->buffer[usedspace], data, freespace); context->bitcount += freespace << 3; len -= freespace; data += freespace; ldns_sha256_Transform(context, (sha2_word32*)context->buffer); } else { /* The buffer is not yet full */ MEMCPY_BCOPY(&context->buffer[usedspace], data, len); context->bitcount += len << 3; /* Clean up: */ usedspace = freespace = 0; return; } } while (len >= LDNS_SHA256_BLOCK_LENGTH) { /* Process as many complete blocks as we can */ ldns_sha256_Transform(context, (sha2_word32*)data); context->bitcount += LDNS_SHA256_BLOCK_LENGTH << 3; len -= LDNS_SHA256_BLOCK_LENGTH; data += LDNS_SHA256_BLOCK_LENGTH; } if (len > 0) { /* There's left-overs, so save 'em */ MEMCPY_BCOPY(context->buffer, data, len); context->bitcount += len << 3; } /* Clean up: */ usedspace = freespace = 0; } typedef union _ldns_sha2_buffer_union { uint8_t* theChars; uint64_t* theLongs; } ldns_sha2_buffer_union; void ldns_sha256_final(sha2_byte digest[], ldns_sha256_CTX* context) { sha2_word32 *d = (sha2_word32*)digest; size_t usedspace; ldns_sha2_buffer_union cast_var; /* Sanity check: */ assert(context != (ldns_sha256_CTX*)0); /* If no digest buffer is passed, we don't bother doing this: */ if (digest != (sha2_byte*)0) { usedspace = (context->bitcount >> 3) % LDNS_SHA256_BLOCK_LENGTH; #if BYTE_ORDER == LITTLE_ENDIAN /* Convert FROM host byte order */ REVERSE64(context->bitcount,context->bitcount); #endif if (usedspace > 0) { /* Begin padding with a 1 bit: */ context->buffer[usedspace++] = 0x80; if (usedspace <= ldns_sha256_SHORT_BLOCK_LENGTH) { /* Set-up for the last transform: */ MEMSET_BZERO(&context->buffer[usedspace], ldns_sha256_SHORT_BLOCK_LENGTH - usedspace); } else { if (usedspace < LDNS_SHA256_BLOCK_LENGTH) { MEMSET_BZERO(&context->buffer[usedspace], LDNS_SHA256_BLOCK_LENGTH - usedspace); } /* Do second-to-last transform: */ ldns_sha256_Transform(context, (sha2_word32*)context->buffer); /* And set-up for the last transform: */ MEMSET_BZERO(context->buffer, ldns_sha256_SHORT_BLOCK_LENGTH); } } else { /* Set-up for the last transform: */ MEMSET_BZERO(context->buffer, ldns_sha256_SHORT_BLOCK_LENGTH); /* Begin padding with a 1 bit: */ *context->buffer = 0x80; } /* Set the bit count: */ cast_var.theChars = context->buffer; cast_var.theLongs[ldns_sha256_SHORT_BLOCK_LENGTH / 8] = context->bitcount; /* final transform: */ ldns_sha256_Transform(context, (sha2_word32*)context->buffer); #if BYTE_ORDER == LITTLE_ENDIAN { /* Convert TO host byte order */ int j; for (j = 0; j < 8; j++) { REVERSE32(context->state[j],context->state[j]); *d++ = context->state[j]; } } #else MEMCPY_BCOPY(d, context->state, LDNS_SHA256_DIGEST_LENGTH); #endif } /* Clean up state data: */ MEMSET_BZERO(context, sizeof(ldns_sha256_CTX)); usedspace = 0; } unsigned char * ldns_sha256(unsigned char *data, unsigned int data_len, unsigned char *digest) { ldns_sha256_CTX ctx; ldns_sha256_init(&ctx); ldns_sha256_update(&ctx, data, data_len); ldns_sha256_final(digest, &ctx); return digest; } /*** SHA-512: *********************************************************/ void ldns_sha512_init(ldns_sha512_CTX* context) { if (context == (ldns_sha512_CTX*)0) { return; } MEMCPY_BCOPY(context->state, sha512_initial_hash_value, LDNS_SHA512_DIGEST_LENGTH); MEMSET_BZERO(context->buffer, LDNS_SHA512_BLOCK_LENGTH); context->bitcount[0] = context->bitcount[1] = 0; } #ifdef SHA2_UNROLL_TRANSFORM /* Unrolled SHA-512 round macros: */ #if BYTE_ORDER == LITTLE_ENDIAN #define ROUND512_0_TO_15(a,b,c,d,e,f,g,h) \ REVERSE64(*data++, W512[j]); \ T1 = (h) + Sigma1_512(e) + Ch((e), (f), (g)) + \ K512[j] + W512[j]; \ (d) += T1, \ (h) = T1 + Sigma0_512(a) + Maj((a), (b), (c)), \ j++ #else /* BYTE_ORDER == LITTLE_ENDIAN */ #define ROUND512_0_TO_15(a,b,c,d,e,f,g,h) \ T1 = (h) + Sigma1_512(e) + Ch((e), (f), (g)) + \ K512[j] + (W512[j] = *data++); \ (d) += T1; \ (h) = T1 + Sigma0_512(a) + Maj((a), (b), (c)); \ j++ #endif /* BYTE_ORDER == LITTLE_ENDIAN */ #define ROUND512(a,b,c,d,e,f,g,h) \ s0 = W512[(j+1)&0x0f]; \ s0 = sigma0_512(s0); \ s1 = W512[(j+14)&0x0f]; \ s1 = sigma1_512(s1); \ T1 = (h) + Sigma1_512(e) + Ch((e), (f), (g)) + K512[j] + \ (W512[j&0x0f] += s1 + W512[(j+9)&0x0f] + s0); \ (d) += T1; \ (h) = T1 + Sigma0_512(a) + Maj((a), (b), (c)); \ j++ static void ldns_sha512_Transform(ldns_sha512_CTX* context, const sha2_word64* data) { sha2_word64 a, b, c, d, e, f, g, h, s0, s1; sha2_word64 T1, *W512 = (sha2_word64*)context->buffer; int j; /* initialize registers with the prev. intermediate value */ a = context->state[0]; b = context->state[1]; c = context->state[2]; d = context->state[3]; e = context->state[4]; f = context->state[5]; g = context->state[6]; h = context->state[7]; j = 0; do { ROUND512_0_TO_15(a,b,c,d,e,f,g,h); ROUND512_0_TO_15(h,a,b,c,d,e,f,g); ROUND512_0_TO_15(g,h,a,b,c,d,e,f); ROUND512_0_TO_15(f,g,h,a,b,c,d,e); ROUND512_0_TO_15(e,f,g,h,a,b,c,d); ROUND512_0_TO_15(d,e,f,g,h,a,b,c); ROUND512_0_TO_15(c,d,e,f,g,h,a,b); ROUND512_0_TO_15(b,c,d,e,f,g,h,a); } while (j < 16); /* Now for the remaining rounds up to 79: */ do { ROUND512(a,b,c,d,e,f,g,h); ROUND512(h,a,b,c,d,e,f,g); ROUND512(g,h,a,b,c,d,e,f); ROUND512(f,g,h,a,b,c,d,e); ROUND512(e,f,g,h,a,b,c,d); ROUND512(d,e,f,g,h,a,b,c); ROUND512(c,d,e,f,g,h,a,b); ROUND512(b,c,d,e,f,g,h,a); } while (j < 80); /* Compute the current intermediate hash value */ context->state[0] += a; context->state[1] += b; context->state[2] += c; context->state[3] += d; context->state[4] += e; context->state[5] += f; context->state[6] += g; context->state[7] += h; /* Clean up */ a = b = c = d = e = f = g = h = T1 = 0; } #else /* SHA2_UNROLL_TRANSFORM */ static void ldns_sha512_Transform(ldns_sha512_CTX* context, const sha2_word64* data) { sha2_word64 a, b, c, d, e, f, g, h, s0, s1; sha2_word64 T1, T2, *W512 = (sha2_word64*)context->buffer; int j; /* initialize registers with the prev. intermediate value */ a = context->state[0]; b = context->state[1]; c = context->state[2]; d = context->state[3]; e = context->state[4]; f = context->state[5]; g = context->state[6]; h = context->state[7]; j = 0; do { #if BYTE_ORDER == LITTLE_ENDIAN /* Convert TO host byte order */ REVERSE64(*data++, W512[j]); /* Apply the SHA-512 compression function to update a..h */ T1 = h + Sigma1_512(e) + Ch(e, f, g) + K512[j] + W512[j]; #else /* BYTE_ORDER == LITTLE_ENDIAN */ /* Apply the SHA-512 compression function to update a..h with copy */ T1 = h + Sigma1_512(e) + Ch(e, f, g) + K512[j] + (W512[j] = *data++); #endif /* BYTE_ORDER == LITTLE_ENDIAN */ T2 = Sigma0_512(a) + Maj(a, b, c); h = g; g = f; f = e; e = d + T1; d = c; c = b; b = a; a = T1 + T2; j++; } while (j < 16); do { /* Part of the message block expansion: */ s0 = W512[(j+1)&0x0f]; s0 = sigma0_512(s0); s1 = W512[(j+14)&0x0f]; s1 = sigma1_512(s1); /* Apply the SHA-512 compression function to update a..h */ T1 = h + Sigma1_512(e) + Ch(e, f, g) + K512[j] + (W512[j&0x0f] += s1 + W512[(j+9)&0x0f] + s0); T2 = Sigma0_512(a) + Maj(a, b, c); h = g; g = f; f = e; e = d + T1; d = c; c = b; b = a; a = T1 + T2; j++; } while (j < 80); /* Compute the current intermediate hash value */ context->state[0] += a; context->state[1] += b; context->state[2] += c; context->state[3] += d; context->state[4] += e; context->state[5] += f; context->state[6] += g; context->state[7] += h; /* Clean up */ a = b = c = d = e = f = g = h = T1 = T2 = 0; } #endif /* SHA2_UNROLL_TRANSFORM */ void ldns_sha512_update(ldns_sha512_CTX* context, const sha2_byte *data, size_t len) { size_t freespace, usedspace; if (len == 0) { /* Calling with no data is valid - we do nothing */ return; } /* Sanity check: */ assert(context != (ldns_sha512_CTX*)0 && data != (sha2_byte*)0); usedspace = (context->bitcount[0] >> 3) % LDNS_SHA512_BLOCK_LENGTH; if (usedspace > 0) { /* Calculate how much free space is available in the buffer */ freespace = LDNS_SHA512_BLOCK_LENGTH - usedspace; if (len >= freespace) { /* Fill the buffer completely and process it */ MEMCPY_BCOPY(&context->buffer[usedspace], data, freespace); ADDINC128(context->bitcount, freespace << 3); len -= freespace; data += freespace; ldns_sha512_Transform(context, (sha2_word64*)context->buffer); } else { /* The buffer is not yet full */ MEMCPY_BCOPY(&context->buffer[usedspace], data, len); ADDINC128(context->bitcount, len << 3); /* Clean up: */ usedspace = freespace = 0; return; } } while (len >= LDNS_SHA512_BLOCK_LENGTH) { /* Process as many complete blocks as we can */ ldns_sha512_Transform(context, (sha2_word64*)data); ADDINC128(context->bitcount, LDNS_SHA512_BLOCK_LENGTH << 3); len -= LDNS_SHA512_BLOCK_LENGTH; data += LDNS_SHA512_BLOCK_LENGTH; } if (len > 0) { /* There's left-overs, so save 'em */ MEMCPY_BCOPY(context->buffer, data, len); ADDINC128(context->bitcount, len << 3); } /* Clean up: */ usedspace = freespace = 0; } static void ldns_sha512_Last(ldns_sha512_CTX* context) { size_t usedspace; ldns_sha2_buffer_union cast_var; usedspace = (context->bitcount[0] >> 3) % LDNS_SHA512_BLOCK_LENGTH; #if BYTE_ORDER == LITTLE_ENDIAN /* Convert FROM host byte order */ REVERSE64(context->bitcount[0],context->bitcount[0]); REVERSE64(context->bitcount[1],context->bitcount[1]); #endif if (usedspace > 0) { /* Begin padding with a 1 bit: */ context->buffer[usedspace++] = 0x80; if (usedspace <= ldns_sha512_SHORT_BLOCK_LENGTH) { /* Set-up for the last transform: */ MEMSET_BZERO(&context->buffer[usedspace], ldns_sha512_SHORT_BLOCK_LENGTH - usedspace); } else { if (usedspace < LDNS_SHA512_BLOCK_LENGTH) { MEMSET_BZERO(&context->buffer[usedspace], LDNS_SHA512_BLOCK_LENGTH - usedspace); } /* Do second-to-last transform: */ ldns_sha512_Transform(context, (sha2_word64*)context->buffer); /* And set-up for the last transform: */ MEMSET_BZERO(context->buffer, LDNS_SHA512_BLOCK_LENGTH - 2); } } else { /* Prepare for final transform: */ MEMSET_BZERO(context->buffer, ldns_sha512_SHORT_BLOCK_LENGTH); /* Begin padding with a 1 bit: */ *context->buffer = 0x80; } /* Store the length of input data (in bits): */ cast_var.theChars = context->buffer; cast_var.theLongs[ldns_sha512_SHORT_BLOCK_LENGTH / 8] = context->bitcount[1]; cast_var.theLongs[ldns_sha512_SHORT_BLOCK_LENGTH / 8 + 1] = context->bitcount[0]; /* final transform: */ ldns_sha512_Transform(context, (sha2_word64*)context->buffer); } void ldns_sha512_final(sha2_byte digest[], ldns_sha512_CTX* context) { sha2_word64 *d = (sha2_word64*)digest; /* Sanity check: */ assert(context != (ldns_sha512_CTX*)0); /* If no digest buffer is passed, we don't bother doing this: */ if (digest != (sha2_byte*)0) { ldns_sha512_Last(context); /* Save the hash data for output: */ #if BYTE_ORDER == LITTLE_ENDIAN { /* Convert TO host byte order */ int j; for (j = 0; j < 8; j++) { REVERSE64(context->state[j],context->state[j]); *d++ = context->state[j]; } } #else MEMCPY_BCOPY(d, context->state, LDNS_SHA512_DIGEST_LENGTH); #endif } /* Zero out state data */ MEMSET_BZERO(context, sizeof(ldns_sha512_CTX)); } unsigned char * ldns_sha512(unsigned char *data, unsigned int data_len, unsigned char *digest) { ldns_sha512_CTX ctx; ldns_sha512_init(&ctx); ldns_sha512_update(&ctx, data, data_len); ldns_sha512_final(digest, &ctx); return digest; } /*** SHA-384: *********************************************************/ void ldns_sha384_init(ldns_sha384_CTX* context) { if (context == (ldns_sha384_CTX*)0) { return; } MEMCPY_BCOPY(context->state, sha384_initial_hash_value, LDNS_SHA512_DIGEST_LENGTH); MEMSET_BZERO(context->buffer, LDNS_SHA384_BLOCK_LENGTH); context->bitcount[0] = context->bitcount[1] = 0; } void ldns_sha384_update(ldns_sha384_CTX* context, const sha2_byte* data, size_t len) { ldns_sha512_update((ldns_sha512_CTX*)context, data, len); } void ldns_sha384_final(sha2_byte digest[], ldns_sha384_CTX* context) { sha2_word64 *d = (sha2_word64*)digest; /* Sanity check: */ assert(context != (ldns_sha384_CTX*)0); /* If no digest buffer is passed, we don't bother doing this: */ if (digest != (sha2_byte*)0) { ldns_sha512_Last((ldns_sha512_CTX*)context); /* Save the hash data for output: */ #if BYTE_ORDER == LITTLE_ENDIAN { /* Convert TO host byte order */ int j; for (j = 0; j < 6; j++) { REVERSE64(context->state[j],context->state[j]); *d++ = context->state[j]; } } #else MEMCPY_BCOPY(d, context->state, LDNS_SHA384_DIGEST_LENGTH); #endif } /* Zero out state data */ MEMSET_BZERO(context, sizeof(ldns_sha384_CTX)); } unsigned char * ldns_sha384(unsigned char *data, unsigned int data_len, unsigned char *digest) { ldns_sha384_CTX ctx; ldns_sha384_init(&ctx); ldns_sha384_update(&ctx, data, data_len); ldns_sha384_final(digest, &ctx); return digest; } ldns-1.6.17/sha1.c0000664000175100017510000001412312264060151013114 0ustar willemwillem/* * modified for ldns by Jelte Jansen, original taken from OpenBSD: * * SHA-1 in C * By Steve Reid * 100% Public Domain * * Test Vectors (from FIPS PUB 180-1) * "abc" * A9993E36 4706816A BA3E2571 7850C26C 9CD0D89D * "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq" * 84983E44 1C3BD26E BAAE4AA1 F95129E5 E54670F1 * A million repetitions of "a" * 34AA973C D4C4DAA4 F61EEB2B DBAD2731 6534016F */ /* #define LITTLE_ENDIAN * This should be #define'd already, if true. */ #include #include #include #define SHA1HANDSOFF 1 /* Copies data before messing with it. */ #define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) /* blk0() and blk() perform the initial expand. */ /* I got the idea of expanding during the round function from SSLeay */ #if BYTE_ORDER == LITTLE_ENDIAN #define blk0(i) (block->l[i] = (rol(block->l[i],24)&0xFF00FF00) \ |(rol(block->l[i],8)&0x00FF00FF)) #else #define blk0(i) block->l[i] #endif #define blk(i) (block->l[i&15] = rol(block->l[(i+13)&15]^block->l[(i+8)&15] \ ^block->l[(i+2)&15]^block->l[i&15],1)) /* (R0+R1), R2, R3, R4 are the different operations used in SHA1 */ #define R0(v,w,x,y,z,i) z+=((w&(x^y))^y)+blk0(i)+0x5A827999+rol(v,5);w=rol(w,30); #define R1(v,w,x,y,z,i) z+=((w&(x^y))^y)+blk(i)+0x5A827999+rol(v,5);w=rol(w,30); #define R2(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0x6ED9EBA1+rol(v,5);w=rol(w,30); #define R3(v,w,x,y,z,i) z+=(((w|x)&y)|(w&x))+blk(i)+0x8F1BBCDC+rol(v,5);w=rol(w,30); #define R4(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0xCA62C1D6+rol(v,5);w=rol(w,30); /* Hash a single 512-bit block. This is the core of the algorithm. */ void ldns_sha1_transform(uint32_t state[5], const unsigned char buffer[LDNS_SHA1_BLOCK_LENGTH]) { uint32_t a, b, c, d, e; typedef union { unsigned char c[64]; unsigned int l[16]; } CHAR64LONG16; CHAR64LONG16* block; #ifdef SHA1HANDSOFF unsigned char workspace[LDNS_SHA1_BLOCK_LENGTH]; block = (CHAR64LONG16 *)workspace; memmove(block, buffer, LDNS_SHA1_BLOCK_LENGTH); #else block = (CHAR64LONG16 *)buffer; #endif /* Copy context->state[] to working vars */ a = state[0]; b = state[1]; c = state[2]; d = state[3]; e = state[4]; /* 4 rounds of 20 operations each. Loop unrolled. */ R0(a,b,c,d,e, 0); R0(e,a,b,c,d, 1); R0(d,e,a,b,c, 2); R0(c,d,e,a,b, 3); R0(b,c,d,e,a, 4); R0(a,b,c,d,e, 5); R0(e,a,b,c,d, 6); R0(d,e,a,b,c, 7); R0(c,d,e,a,b, 8); R0(b,c,d,e,a, 9); R0(a,b,c,d,e,10); R0(e,a,b,c,d,11); R0(d,e,a,b,c,12); R0(c,d,e,a,b,13); R0(b,c,d,e,a,14); R0(a,b,c,d,e,15); R1(e,a,b,c,d,16); R1(d,e,a,b,c,17); R1(c,d,e,a,b,18); R1(b,c,d,e,a,19); R2(a,b,c,d,e,20); R2(e,a,b,c,d,21); R2(d,e,a,b,c,22); R2(c,d,e,a,b,23); R2(b,c,d,e,a,24); R2(a,b,c,d,e,25); R2(e,a,b,c,d,26); R2(d,e,a,b,c,27); R2(c,d,e,a,b,28); R2(b,c,d,e,a,29); R2(a,b,c,d,e,30); R2(e,a,b,c,d,31); R2(d,e,a,b,c,32); R2(c,d,e,a,b,33); R2(b,c,d,e,a,34); R2(a,b,c,d,e,35); R2(e,a,b,c,d,36); R2(d,e,a,b,c,37); R2(c,d,e,a,b,38); R2(b,c,d,e,a,39); R3(a,b,c,d,e,40); R3(e,a,b,c,d,41); R3(d,e,a,b,c,42); R3(c,d,e,a,b,43); R3(b,c,d,e,a,44); R3(a,b,c,d,e,45); R3(e,a,b,c,d,46); R3(d,e,a,b,c,47); R3(c,d,e,a,b,48); R3(b,c,d,e,a,49); R3(a,b,c,d,e,50); R3(e,a,b,c,d,51); R3(d,e,a,b,c,52); R3(c,d,e,a,b,53); R3(b,c,d,e,a,54); R3(a,b,c,d,e,55); R3(e,a,b,c,d,56); R3(d,e,a,b,c,57); R3(c,d,e,a,b,58); R3(b,c,d,e,a,59); R4(a,b,c,d,e,60); R4(e,a,b,c,d,61); R4(d,e,a,b,c,62); R4(c,d,e,a,b,63); R4(b,c,d,e,a,64); R4(a,b,c,d,e,65); R4(e,a,b,c,d,66); R4(d,e,a,b,c,67); R4(c,d,e,a,b,68); R4(b,c,d,e,a,69); R4(a,b,c,d,e,70); R4(e,a,b,c,d,71); R4(d,e,a,b,c,72); R4(c,d,e,a,b,73); R4(b,c,d,e,a,74); R4(a,b,c,d,e,75); R4(e,a,b,c,d,76); R4(d,e,a,b,c,77); R4(c,d,e,a,b,78); R4(b,c,d,e,a,79); /* Add the working vars back into context.state[] */ state[0] += a; state[1] += b; state[2] += c; state[3] += d; state[4] += e; /* Wipe variables */ a = b = c = d = e = 0; } /* SHA1Init - Initialize new context */ void ldns_sha1_init(ldns_sha1_ctx *context) { /* SHA1 initialization constants */ context->count = 0; context->state[0] = 0x67452301; context->state[1] = 0xEFCDAB89; context->state[2] = 0x98BADCFE; context->state[3] = 0x10325476; context->state[4] = 0xC3D2E1F0; } /* Run your data through this. */ void ldns_sha1_update(ldns_sha1_ctx *context, const unsigned char *data, unsigned int len) { unsigned int i; unsigned int j; j = (unsigned)(uint32_t)((context->count >> 3) & 63); context->count += (len << 3); if ((j + len) > 63) { memmove(&context->buffer[j], data, (i = 64 - j)); ldns_sha1_transform(context->state, context->buffer); for ( ; i + 63 < len; i += 64) { ldns_sha1_transform(context->state, &data[i]); } j = 0; } else i = 0; memmove(&context->buffer[j], &data[i], len - i); } /* Add padding and return the message digest. */ void ldns_sha1_final(unsigned char digest[LDNS_SHA1_DIGEST_LENGTH], ldns_sha1_ctx *context) { unsigned int i; unsigned char finalcount[8]; for (i = 0; i < 8; i++) { finalcount[i] = (unsigned char)((context->count >> ((7 - (i & 7)) * 8)) & 255); /* Endian independent */ } ldns_sha1_update(context, (unsigned char *)"\200", 1); while ((context->count & 504) != 448) { ldns_sha1_update(context, (unsigned char *)"\0", 1); } ldns_sha1_update(context, finalcount, 8); /* Should cause a SHA1Transform() */ if (digest != NULL) for (i = 0; i < LDNS_SHA1_DIGEST_LENGTH; i++) { digest[i] = (unsigned char)((context->state[i >> 2] >> ((3 - (i & 3)) * 8)) & 255); } #ifdef SHA1HANDSOFF /* make SHA1Transform overwrite its own static vars */ ldns_sha1_transform(context->state, context->buffer); #endif } unsigned char * ldns_sha1(unsigned char *data, unsigned int data_len, unsigned char *digest) { ldns_sha1_ctx ctx; ldns_sha1_init(&ctx); ldns_sha1_update(&ctx, data, data_len); ldns_sha1_final(digest, &ctx); return digest; } ldns-1.6.17/zone.c0000664000175100017510000001423312264060151013235 0ustar willemwillem/* zone.c * * Functions for ldns_zone structure * a Net::DNS like library for C * * (c) NLnet Labs, 2005-2006 * See the file LICENSE for the license */ #include #include #include #include ldns_rr * ldns_zone_soa(const ldns_zone *z) { return z->_soa; } size_t ldns_zone_rr_count(const ldns_zone *z) { return ldns_rr_list_rr_count(z->_rrs); } void ldns_zone_set_soa(ldns_zone *z, ldns_rr *soa) { z->_soa = soa; } ldns_rr_list * ldns_zone_rrs(const ldns_zone *z) { return z->_rrs; } void ldns_zone_set_rrs(ldns_zone *z, ldns_rr_list *rrlist) { z->_rrs = rrlist; } bool ldns_zone_push_rr_list(ldns_zone *z, ldns_rr_list *list) { return ldns_rr_list_cat(ldns_zone_rrs(z), list); } bool ldns_zone_push_rr(ldns_zone *z, ldns_rr *rr) { return ldns_rr_list_push_rr( ldns_zone_rrs(z), rr); } /* * Get the list of glue records in a zone * XXX: there should be a way for this to return error, other than NULL, * since NULL is a valid return */ ldns_rr_list * ldns_zone_glue_rr_list(const ldns_zone *z) { /* when do we find glue? It means we find an IP address * (AAAA/A) for a nameserver listed in the zone * * Alg used here: * first find all the zonecuts (NS records) * find all the AAAA or A records (can be done it the * above loop). * * Check if the aaaa/a list are subdomains under the * NS domains. * If yes -> glue, if no -> not glue */ ldns_rr_list *zone_cuts; ldns_rr_list *addr; ldns_rr_list *glue; ldns_rr *r, *ns, *a; ldns_rdf *dname_a, *ns_owner; size_t i,j; zone_cuts = NULL; addr = NULL; glue = NULL; /* we cannot determine glue in a 'zone' without a SOA */ if (!ldns_zone_soa(z)) { return NULL; } zone_cuts = ldns_rr_list_new(); if (!zone_cuts) goto memory_error; addr = ldns_rr_list_new(); if (!addr) goto memory_error; glue = ldns_rr_list_new(); if (!glue) goto memory_error; for(i = 0; i < ldns_zone_rr_count(z); i++) { r = ldns_rr_list_rr(ldns_zone_rrs(z), i); if (ldns_rr_get_type(r) == LDNS_RR_TYPE_A || ldns_rr_get_type(r) == LDNS_RR_TYPE_AAAA) { /* possibly glue */ if (!ldns_rr_list_push_rr(addr, r)) goto memory_error; continue; } if (ldns_rr_get_type(r) == LDNS_RR_TYPE_NS) { /* multiple zones will end up here - * for now; not a problem */ /* don't add NS records for the current zone itself */ if (ldns_rdf_compare(ldns_rr_owner(r), ldns_rr_owner(ldns_zone_soa(z))) != 0) { if (!ldns_rr_list_push_rr(zone_cuts, r)) goto memory_error; } continue; } } /* will sorting make it quicker ?? */ for(i = 0; i < ldns_rr_list_rr_count(zone_cuts); i++) { ns = ldns_rr_list_rr(zone_cuts, i); ns_owner = ldns_rr_owner(ns); for(j = 0; j < ldns_rr_list_rr_count(addr); j++) { a = ldns_rr_list_rr(addr, j); dname_a = ldns_rr_owner(a); if (ldns_dname_is_subdomain(dname_a, ns_owner) || ldns_dname_compare(dname_a, ns_owner) == 0) { /* GLUE! */ if (!ldns_rr_list_push_rr(glue, a)) goto memory_error; } } } ldns_rr_list_free(addr); ldns_rr_list_free(zone_cuts); if (ldns_rr_list_rr_count(glue) == 0) { ldns_rr_list_free(glue); return NULL; } else { return glue; } memory_error: if (zone_cuts) { LDNS_FREE(zone_cuts); } if (addr) { ldns_rr_list_free(addr); } if (glue) { ldns_rr_list_free(glue); } return NULL; } ldns_zone * ldns_zone_new(void) { ldns_zone *z; z = LDNS_MALLOC(ldns_zone); if (!z) { return NULL; } z->_rrs = ldns_rr_list_new(); if (!z->_rrs) { LDNS_FREE(z); return NULL; } ldns_zone_set_soa(z, NULL); return z; } /* we regocnize: * $TTL, $ORIGIN */ ldns_status ldns_zone_new_frm_fp(ldns_zone **z, FILE *fp, ldns_rdf *origin, uint32_t ttl, ldns_rr_class c) { return ldns_zone_new_frm_fp_l(z, fp, origin, ttl, c, NULL); } /* XXX: class is never used */ ldns_status ldns_zone_new_frm_fp_l(ldns_zone **z, FILE *fp, ldns_rdf *origin, uint32_t ttl, ldns_rr_class ATTR_UNUSED(c), int *line_nr) { ldns_zone *newzone; ldns_rr *rr; uint32_t my_ttl; ldns_rdf *my_origin; ldns_rdf *my_prev; bool soa_seen = false; /* 2 soa are an error */ ldns_status s; ldns_status ret; /* most cases of error are memory problems */ ret = LDNS_STATUS_MEM_ERR; newzone = NULL; my_origin = NULL; my_prev = NULL; my_ttl = ttl; if (origin) { my_origin = ldns_rdf_clone(origin); if (!my_origin) goto error; /* also set the prev */ my_prev = ldns_rdf_clone(origin); if (!my_prev) goto error; } newzone = ldns_zone_new(); if (!newzone) goto error; while(!feof(fp)) { s = ldns_rr_new_frm_fp_l(&rr, fp, &my_ttl, &my_origin, &my_prev, line_nr); switch (s) { case LDNS_STATUS_OK: if (ldns_rr_get_type(rr) == LDNS_RR_TYPE_SOA) { if (soa_seen) { /* second SOA * just skip, maybe we want to say * something??? */ ldns_rr_free(rr); continue; } soa_seen = true; ldns_zone_set_soa(newzone, rr); /* set origin to soa if not specified */ if (!my_origin) { my_origin = ldns_rdf_clone(ldns_rr_owner(rr)); } continue; } /* a normal RR - as sofar the DNS is normal */ if (!ldns_zone_push_rr(newzone, rr)) goto error; case LDNS_STATUS_SYNTAX_EMPTY: /* empty line was seen */ case LDNS_STATUS_SYNTAX_TTL: /* the function set the ttl */ break; case LDNS_STATUS_SYNTAX_ORIGIN: /* the function set the origin */ break; case LDNS_STATUS_SYNTAX_INCLUDE: ret = LDNS_STATUS_SYNTAX_INCLUDE_ERR_NOTIMPL; break; default: ret = s; goto error; } } if (my_origin) { ldns_rdf_deep_free(my_origin); } if (my_prev) { ldns_rdf_deep_free(my_prev); } if (z) { *z = newzone; } else { ldns_zone_free(newzone); } return LDNS_STATUS_OK; error: if (my_origin) { ldns_rdf_deep_free(my_origin); } if (my_prev) { ldns_rdf_deep_free(my_prev); } if (newzone) { ldns_zone_free(newzone); } return ret; } void ldns_zone_sort(ldns_zone *zone) { ldns_rr_list *zrr; assert(zone != NULL); zrr = ldns_zone_rrs(zone); ldns_rr_list_sort(zrr); } void ldns_zone_free(ldns_zone *zone) { ldns_rr_list_free(zone->_rrs); LDNS_FREE(zone); } void ldns_zone_deep_free(ldns_zone *zone) { ldns_rr_free(zone->_soa); ldns_rr_list_deep_free(zone->_rrs); LDNS_FREE(zone); } ldns-1.6.17/host2wire.c0000664000175100017510000002427312264060151014215 0ustar willemwillem/* * host2wire.c * * conversion routines from the host to the wire format. * This will usually just a re-ordering of the * data (as we store it in network format) * * a Net::DNS like library for C * * (c) NLnet Labs, 2004-2006 * * See the file LICENSE for the license */ #include #include /* TODO Jelte add a pointer to a 'possiblecompression' structure to all the needed functions? something like an array of name, pointer values? every dname part could be added to it */ ldns_status ldns_dname2buffer_wire(ldns_buffer *buffer, const ldns_rdf *name) { if (ldns_buffer_reserve(buffer, ldns_rdf_size(name))) { ldns_buffer_write(buffer, ldns_rdf_data(name), ldns_rdf_size(name)); } return ldns_buffer_status(buffer); } ldns_status ldns_rdf2buffer_wire(ldns_buffer *buffer, const ldns_rdf *rdf) { if (ldns_buffer_reserve(buffer, ldns_rdf_size(rdf))) { ldns_buffer_write(buffer, ldns_rdf_data(rdf), ldns_rdf_size(rdf)); } return ldns_buffer_status(buffer); } ldns_status ldns_rdf2buffer_wire_canonical(ldns_buffer *buffer, const ldns_rdf *rdf) { size_t i; uint8_t *rdf_data; if (ldns_rdf_get_type(rdf) == LDNS_RDF_TYPE_DNAME) { if (ldns_buffer_reserve(buffer, ldns_rdf_size(rdf))) { rdf_data = ldns_rdf_data(rdf); for (i = 0; i < ldns_rdf_size(rdf); i++) { ldns_buffer_write_u8(buffer, (uint8_t) LDNS_DNAME_NORMALIZE((int)rdf_data[i])); } } } else { /* direct copy for all other types */ if (ldns_buffer_reserve(buffer, ldns_rdf_size(rdf))) { ldns_buffer_write(buffer, ldns_rdf_data(rdf), ldns_rdf_size(rdf)); } } return ldns_buffer_status(buffer); } /* convert a rr list to wireformat */ ldns_status ldns_rr_list2buffer_wire(ldns_buffer *buffer,const ldns_rr_list *rr_list) { uint16_t rr_count; uint16_t i; rr_count = ldns_rr_list_rr_count(rr_list); for(i = 0; i < rr_count; i++) { (void)ldns_rr2buffer_wire(buffer, ldns_rr_list_rr(rr_list, i), LDNS_SECTION_ANY); } return ldns_buffer_status(buffer); } ldns_status ldns_rr2buffer_wire_canonical(ldns_buffer *buffer, const ldns_rr *rr, int section) { uint16_t i; uint16_t rdl_pos = 0; bool pre_rfc3597 = false; switch (ldns_rr_get_type(rr)) { case LDNS_RR_TYPE_NS: case LDNS_RR_TYPE_MD: case LDNS_RR_TYPE_MF: case LDNS_RR_TYPE_CNAME: case LDNS_RR_TYPE_SOA: case LDNS_RR_TYPE_MB: case LDNS_RR_TYPE_MG: case LDNS_RR_TYPE_MR: case LDNS_RR_TYPE_PTR: case LDNS_RR_TYPE_HINFO: case LDNS_RR_TYPE_MINFO: case LDNS_RR_TYPE_MX: case LDNS_RR_TYPE_RP: case LDNS_RR_TYPE_AFSDB: case LDNS_RR_TYPE_RT: case LDNS_RR_TYPE_SIG: case LDNS_RR_TYPE_PX: case LDNS_RR_TYPE_NXT: case LDNS_RR_TYPE_NAPTR: case LDNS_RR_TYPE_KX: case LDNS_RR_TYPE_SRV: case LDNS_RR_TYPE_DNAME: case LDNS_RR_TYPE_A6: case LDNS_RR_TYPE_RRSIG: pre_rfc3597 = true; break; default: break; } if (ldns_rr_owner(rr)) { (void) ldns_rdf2buffer_wire_canonical(buffer, ldns_rr_owner(rr)); } if (ldns_buffer_reserve(buffer, 4)) { (void) ldns_buffer_write_u16(buffer, ldns_rr_get_type(rr)); (void) ldns_buffer_write_u16(buffer, ldns_rr_get_class(rr)); } if (section != LDNS_SECTION_QUESTION) { if (ldns_buffer_reserve(buffer, 6)) { ldns_buffer_write_u32(buffer, ldns_rr_ttl(rr)); /* remember pos for later */ rdl_pos = ldns_buffer_position(buffer); ldns_buffer_write_u16(buffer, 0); } for (i = 0; i < ldns_rr_rd_count(rr); i++) { if (pre_rfc3597) { (void) ldns_rdf2buffer_wire_canonical( buffer, ldns_rr_rdf(rr, i)); } else { (void) ldns_rdf2buffer_wire( buffer, ldns_rr_rdf(rr, i)); } } if (rdl_pos != 0) { ldns_buffer_write_u16_at(buffer, rdl_pos, ldns_buffer_position(buffer) - rdl_pos - 2); } } return ldns_buffer_status(buffer); } ldns_status ldns_rr2buffer_wire(ldns_buffer *buffer, const ldns_rr *rr, int section) { uint16_t i; uint16_t rdl_pos = 0; if (ldns_rr_owner(rr)) { (void) ldns_dname2buffer_wire(buffer, ldns_rr_owner(rr)); } if (ldns_buffer_reserve(buffer, 4)) { (void) ldns_buffer_write_u16(buffer, ldns_rr_get_type(rr)); (void) ldns_buffer_write_u16(buffer, ldns_rr_get_class(rr)); } if (section != LDNS_SECTION_QUESTION) { if (ldns_buffer_reserve(buffer, 6)) { ldns_buffer_write_u32(buffer, ldns_rr_ttl(rr)); /* remember pos for later */ rdl_pos = ldns_buffer_position(buffer); ldns_buffer_write_u16(buffer, 0); } for (i = 0; i < ldns_rr_rd_count(rr); i++) { (void) ldns_rdf2buffer_wire( buffer, ldns_rr_rdf(rr, i)); } if (rdl_pos != 0) { ldns_buffer_write_u16_at(buffer, rdl_pos, ldns_buffer_position(buffer) - rdl_pos - 2); } } return ldns_buffer_status(buffer); } ldns_status ldns_rrsig2buffer_wire(ldns_buffer *buffer, const ldns_rr *rr) { uint16_t i; /* it must be a sig RR */ if (ldns_rr_get_type(rr) != LDNS_RR_TYPE_RRSIG) { return LDNS_STATUS_ERR; } /* Convert all the rdfs, except the actual signature data * rdf number 8 - the last, hence: -1 */ for (i = 0; i < ldns_rr_rd_count(rr) - 1; i++) { (void) ldns_rdf2buffer_wire_canonical(buffer, ldns_rr_rdf(rr, i)); } return ldns_buffer_status(buffer); } ldns_status ldns_rr_rdata2buffer_wire(ldns_buffer *buffer, const ldns_rr *rr) { uint16_t i; /* convert all the rdf's */ for (i = 0; i < ldns_rr_rd_count(rr); i++) { (void) ldns_rdf2buffer_wire(buffer, ldns_rr_rdf(rr,i)); } return ldns_buffer_status(buffer); } /* * Copies the packet header data to the buffer in wire format */ static ldns_status ldns_hdr2buffer_wire(ldns_buffer *buffer, const ldns_pkt *packet) { uint8_t flags; uint16_t arcount; if (ldns_buffer_reserve(buffer, 12)) { ldns_buffer_write_u16(buffer, ldns_pkt_id(packet)); flags = ldns_pkt_qr(packet) << 7 | ldns_pkt_get_opcode(packet) << 3 | ldns_pkt_aa(packet) << 2 | ldns_pkt_tc(packet) << 1 | ldns_pkt_rd(packet); ldns_buffer_write_u8(buffer, flags); flags = ldns_pkt_ra(packet) << 7 /*| ldns_pkt_z(packet) << 6*/ | ldns_pkt_ad(packet) << 5 | ldns_pkt_cd(packet) << 4 | ldns_pkt_get_rcode(packet); ldns_buffer_write_u8(buffer, flags); ldns_buffer_write_u16(buffer, ldns_pkt_qdcount(packet)); ldns_buffer_write_u16(buffer, ldns_pkt_ancount(packet)); ldns_buffer_write_u16(buffer, ldns_pkt_nscount(packet)); /* add EDNS0 and TSIG to additional if they are there */ arcount = ldns_pkt_arcount(packet); if (ldns_pkt_tsig(packet)) { arcount++; } if (ldns_pkt_edns(packet)) { arcount++; } ldns_buffer_write_u16(buffer, arcount); } return ldns_buffer_status(buffer); } ldns_status ldns_pkt2buffer_wire(ldns_buffer *buffer, const ldns_pkt *packet) { ldns_rr_list *rr_list; uint16_t i; /* edns tmp vars */ ldns_rr *edns_rr; uint8_t edata[4]; (void) ldns_hdr2buffer_wire(buffer, packet); rr_list = ldns_pkt_question(packet); if (rr_list) { for (i = 0; i < ldns_rr_list_rr_count(rr_list); i++) { (void) ldns_rr2buffer_wire(buffer, ldns_rr_list_rr(rr_list, i), LDNS_SECTION_QUESTION); } } rr_list = ldns_pkt_answer(packet); if (rr_list) { for (i = 0; i < ldns_rr_list_rr_count(rr_list); i++) { (void) ldns_rr2buffer_wire(buffer, ldns_rr_list_rr(rr_list, i), LDNS_SECTION_ANSWER); } } rr_list = ldns_pkt_authority(packet); if (rr_list) { for (i = 0; i < ldns_rr_list_rr_count(rr_list); i++) { (void) ldns_rr2buffer_wire(buffer, ldns_rr_list_rr(rr_list, i), LDNS_SECTION_AUTHORITY); } } rr_list = ldns_pkt_additional(packet); if (rr_list) { for (i = 0; i < ldns_rr_list_rr_count(rr_list); i++) { (void) ldns_rr2buffer_wire(buffer, ldns_rr_list_rr(rr_list, i), LDNS_SECTION_ADDITIONAL); } } /* add EDNS to additional if it is needed */ if (ldns_pkt_edns(packet)) { edns_rr = ldns_rr_new(); if(!edns_rr) return LDNS_STATUS_MEM_ERR; ldns_rr_set_owner(edns_rr, ldns_rdf_new_frm_str(LDNS_RDF_TYPE_DNAME, ".")); ldns_rr_set_type(edns_rr, LDNS_RR_TYPE_OPT); ldns_rr_set_class(edns_rr, ldns_pkt_edns_udp_size(packet)); edata[0] = ldns_pkt_edns_extended_rcode(packet); edata[1] = ldns_pkt_edns_version(packet); ldns_write_uint16(&edata[2], ldns_pkt_edns_z(packet)); ldns_rr_set_ttl(edns_rr, ldns_read_uint32(edata)); /* don't forget to add the edns rdata (if any) */ if (packet->_edns_data) ldns_rr_push_rdf (edns_rr, packet->_edns_data); (void)ldns_rr2buffer_wire(buffer, edns_rr, LDNS_SECTION_ADDITIONAL); /* take the edns rdata back out of the rr before we free rr */ if (packet->_edns_data) (void)ldns_rr_pop_rdf (edns_rr); ldns_rr_free(edns_rr); } /* add TSIG to additional if it is there */ if (ldns_pkt_tsig(packet)) { (void) ldns_rr2buffer_wire(buffer, ldns_pkt_tsig(packet), LDNS_SECTION_ADDITIONAL); } return LDNS_STATUS_OK; } ldns_status ldns_rdf2wire(uint8_t **dest, const ldns_rdf *rdf, size_t *result_size) { ldns_buffer *buffer = ldns_buffer_new(LDNS_MAX_PACKETLEN); ldns_status status; *result_size = 0; *dest = NULL; if(!buffer) return LDNS_STATUS_MEM_ERR; status = ldns_rdf2buffer_wire(buffer, rdf); if (status == LDNS_STATUS_OK) { *result_size = ldns_buffer_position(buffer); *dest = (uint8_t *) ldns_buffer_export(buffer); } ldns_buffer_free(buffer); return status; } ldns_status ldns_rr2wire(uint8_t **dest, const ldns_rr *rr, int section, size_t *result_size) { ldns_buffer *buffer = ldns_buffer_new(LDNS_MAX_PACKETLEN); ldns_status status; *result_size = 0; *dest = NULL; if(!buffer) return LDNS_STATUS_MEM_ERR; status = ldns_rr2buffer_wire(buffer, rr, section); if (status == LDNS_STATUS_OK) { *result_size = ldns_buffer_position(buffer); *dest = (uint8_t *) ldns_buffer_export(buffer); } ldns_buffer_free(buffer); return status; } ldns_status ldns_pkt2wire(uint8_t **dest, const ldns_pkt *packet, size_t *result_size) { ldns_buffer *buffer = ldns_buffer_new(LDNS_MAX_PACKETLEN); ldns_status status; *result_size = 0; *dest = NULL; if(!buffer) return LDNS_STATUS_MEM_ERR; status = ldns_pkt2buffer_wire(buffer, packet); if (status == LDNS_STATUS_OK) { *result_size = ldns_buffer_position(buffer); *dest = (uint8_t *) ldns_buffer_export(buffer); } ldns_buffer_free(buffer); return status; } ldns-1.6.17/config.sub0000755000175100017510000010517612264060154014111 0ustar willemwillem#! /bin/sh # Configuration validation subroutine script. # Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, # 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, # 2011, 2012 Free Software Foundation, Inc. timestamp='2012-02-10' # This file is (in principle) common to ALL GNU software. # The presence of a machine in this file suggests that SOME GNU software # can handle that machine. It does not imply ALL GNU software can. # # This file is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, see . # # As a special exception to the GNU General Public License, if you # distribute this file as part of a program that contains a # configuration script generated by Autoconf, you may include it under # the same distribution terms that you use for the rest of that program. # Please send patches to . Submit a context # diff and a properly formatted GNU ChangeLog entry. # # Configuration subroutine to validate and canonicalize a configuration type. # Supply the specified configuration type as an argument. # If it is invalid, we print an error message on stderr and exit with code 1. # Otherwise, we print the canonical config type on stdout and succeed. # You can get the latest version of this script from: # http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.sub;hb=HEAD # This file is supposed to be the same for all GNU packages # and recognize all the CPU types, system types and aliases # that are meaningful with *any* GNU software. # Each package is responsible for reporting which valid configurations # it does not support. The user should be able to distinguish # a failure to support a valid configuration from a meaningless # configuration. # The goal of this file is to map all the various variations of a given # machine specification into a single specification in the form: # CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM # or in some cases, the newer four-part form: # CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM # It is wrong to echo any other type of specification. me=`echo "$0" | sed -e 's,.*/,,'` usage="\ Usage: $0 [OPTION] CPU-MFR-OPSYS $0 [OPTION] ALIAS Canonicalize a configuration name. Operation modes: -h, --help print this help, then exit -t, --time-stamp print date of last modification, then exit -v, --version print version number, then exit Report bugs and patches to ." version="\ GNU config.sub ($timestamp) Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012 Free Software Foundation, Inc. This is free software; see the source for copying conditions. There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE." help=" Try \`$me --help' for more information." # Parse command line while test $# -gt 0 ; do case $1 in --time-stamp | --time* | -t ) echo "$timestamp" ; exit ;; --version | -v ) echo "$version" ; exit ;; --help | --h* | -h ) echo "$usage"; exit ;; -- ) # Stop option processing shift; break ;; - ) # Use stdin as input. break ;; -* ) echo "$me: invalid option $1$help" exit 1 ;; *local*) # First pass through any local machine types. echo $1 exit ;; * ) break ;; esac done case $# in 0) echo "$me: missing argument$help" >&2 exit 1;; 1) ;; *) echo "$me: too many arguments$help" >&2 exit 1;; esac # Separate what the user gave into CPU-COMPANY and OS or KERNEL-OS (if any). # Here we must recognize all the valid KERNEL-OS combinations. maybe_os=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\2/'` case $maybe_os in nto-qnx* | linux-gnu* | linux-android* | linux-dietlibc | linux-newlib* | \ linux-uclibc* | uclinux-uclibc* | uclinux-gnu* | kfreebsd*-gnu* | \ knetbsd*-gnu* | netbsd*-gnu* | \ kopensolaris*-gnu* | \ storm-chaos* | os2-emx* | rtmk-nova*) os=-$maybe_os basic_machine=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\1/'` ;; android-linux) os=-linux-android basic_machine=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\1/'`-unknown ;; *) basic_machine=`echo $1 | sed 's/-[^-]*$//'` if [ $basic_machine != $1 ] then os=`echo $1 | sed 's/.*-/-/'` else os=; fi ;; esac ### Let's recognize common machines as not being operating systems so ### that things like config.sub decstation-3100 work. We also ### recognize some manufacturers as not being operating systems, so we ### can provide default operating systems below. case $os in -sun*os*) # Prevent following clause from handling this invalid input. ;; -dec* | -mips* | -sequent* | -encore* | -pc532* | -sgi* | -sony* | \ -att* | -7300* | -3300* | -delta* | -motorola* | -sun[234]* | \ -unicom* | -ibm* | -next | -hp | -isi* | -apollo | -altos* | \ -convergent* | -ncr* | -news | -32* | -3600* | -3100* | -hitachi* |\ -c[123]* | -convex* | -sun | -crds | -omron* | -dg | -ultra | -tti* | \ -harris | -dolphin | -highlevel | -gould | -cbm | -ns | -masscomp | \ -apple | -axis | -knuth | -cray | -microblaze) os= basic_machine=$1 ;; -bluegene*) os=-cnk ;; -sim | -cisco | -oki | -wec | -winbond) os= basic_machine=$1 ;; -scout) ;; -wrs) os=-vxworks basic_machine=$1 ;; -chorusos*) os=-chorusos basic_machine=$1 ;; -chorusrdb) os=-chorusrdb basic_machine=$1 ;; -hiux*) os=-hiuxwe2 ;; -sco6) os=-sco5v6 basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` ;; -sco5) os=-sco3.2v5 basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` ;; -sco4) os=-sco3.2v4 basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` ;; -sco3.2.[4-9]*) os=`echo $os | sed -e 's/sco3.2./sco3.2v/'` basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` ;; -sco3.2v[4-9]*) # Don't forget version if it is 3.2v4 or newer. basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` ;; -sco5v6*) # Don't forget version if it is 3.2v4 or newer. basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` ;; -sco*) os=-sco3.2v2 basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` ;; -udk*) basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` ;; -isc) os=-isc2.2 basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` ;; -clix*) basic_machine=clipper-intergraph ;; -isc*) basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` ;; -lynx*) os=-lynxos ;; -ptx*) basic_machine=`echo $1 | sed -e 's/86-.*/86-sequent/'` ;; -windowsnt*) os=`echo $os | sed -e 's/windowsnt/winnt/'` ;; -psos*) os=-psos ;; -mint | -mint[0-9]*) basic_machine=m68k-atari os=-mint ;; esac # Decode aliases for certain CPU-COMPANY combinations. case $basic_machine in # Recognize the basic CPU types without company name. # Some are omitted here because they have special meanings below. 1750a | 580 \ | a29k \ | aarch64 | aarch64_be \ | alpha | alphaev[4-8] | alphaev56 | alphaev6[78] | alphapca5[67] \ | alpha64 | alpha64ev[4-8] | alpha64ev56 | alpha64ev6[78] | alpha64pca5[67] \ | am33_2.0 \ | arc | arm | arm[bl]e | arme[lb] | armv[2345] | armv[345][lb] | avr | avr32 \ | be32 | be64 \ | bfin \ | c4x | clipper \ | d10v | d30v | dlx | dsp16xx \ | epiphany \ | fido | fr30 | frv \ | h8300 | h8500 | hppa | hppa1.[01] | hppa2.0 | hppa2.0[nw] | hppa64 \ | hexagon \ | i370 | i860 | i960 | ia64 \ | ip2k | iq2000 \ | le32 | le64 \ | lm32 \ | m32c | m32r | m32rle | m68000 | m68k | m88k \ | maxq | mb | microblaze | mcore | mep | metag \ | mips | mipsbe | mipseb | mipsel | mipsle \ | mips16 \ | mips64 | mips64el \ | mips64octeon | mips64octeonel \ | mips64orion | mips64orionel \ | mips64r5900 | mips64r5900el \ | mips64vr | mips64vrel \ | mips64vr4100 | mips64vr4100el \ | mips64vr4300 | mips64vr4300el \ | mips64vr5000 | mips64vr5000el \ | mips64vr5900 | mips64vr5900el \ | mipsisa32 | mipsisa32el \ | mipsisa32r2 | mipsisa32r2el \ | mipsisa64 | mipsisa64el \ | mipsisa64r2 | mipsisa64r2el \ | mipsisa64sb1 | mipsisa64sb1el \ | mipsisa64sr71k | mipsisa64sr71kel \ | mipstx39 | mipstx39el \ | mn10200 | mn10300 \ | moxie \ | mt \ | msp430 \ | nds32 | nds32le | nds32be \ | nios | nios2 \ | ns16k | ns32k \ | open8 \ | or32 \ | pdp10 | pdp11 | pj | pjl \ | powerpc | powerpc64 | powerpc64le | powerpcle \ | pyramid \ | rl78 | rx \ | score \ | sh | sh[1234] | sh[24]a | sh[24]aeb | sh[23]e | sh[34]eb | sheb | shbe | shle | sh[1234]le | sh3ele \ | sh64 | sh64le \ | sparc | sparc64 | sparc64b | sparc64v | sparc86x | sparclet | sparclite \ | sparcv8 | sparcv9 | sparcv9b | sparcv9v \ | spu \ | tahoe | tic4x | tic54x | tic55x | tic6x | tic80 | tron \ | ubicom32 \ | v850 | v850e | v850e1 | v850e2 | v850es | v850e2v3 \ | we32k \ | x86 | xc16x | xstormy16 | xtensa \ | z8k | z80) basic_machine=$basic_machine-unknown ;; c54x) basic_machine=tic54x-unknown ;; c55x) basic_machine=tic55x-unknown ;; c6x) basic_machine=tic6x-unknown ;; m6811 | m68hc11 | m6812 | m68hc12 | m68hcs12x | picochip) basic_machine=$basic_machine-unknown os=-none ;; m88110 | m680[12346]0 | m683?2 | m68360 | m5200 | v70 | w65 | z8k) ;; ms1) basic_machine=mt-unknown ;; strongarm | thumb | xscale) basic_machine=arm-unknown ;; xgate) basic_machine=$basic_machine-unknown os=-none ;; xscaleeb) basic_machine=armeb-unknown ;; xscaleel) basic_machine=armel-unknown ;; # We use `pc' rather than `unknown' # because (1) that's what they normally are, and # (2) the word "unknown" tends to confuse beginning users. i*86 | x86_64) basic_machine=$basic_machine-pc ;; # Object if more than one company name word. *-*-*) echo Invalid configuration \`$1\': machine \`$basic_machine\' not recognized 1>&2 exit 1 ;; # Recognize the basic CPU types with company name. 580-* \ | a29k-* \ | aarch64-* | aarch64_be-* \ | alpha-* | alphaev[4-8]-* | alphaev56-* | alphaev6[78]-* \ | alpha64-* | alpha64ev[4-8]-* | alpha64ev56-* | alpha64ev6[78]-* \ | alphapca5[67]-* | alpha64pca5[67]-* | arc-* \ | arm-* | armbe-* | armle-* | armeb-* | armv*-* \ | avr-* | avr32-* \ | be32-* | be64-* \ | bfin-* | bs2000-* \ | c[123]* | c30-* | [cjt]90-* | c4x-* \ | clipper-* | craynv-* | cydra-* \ | d10v-* | d30v-* | dlx-* \ | elxsi-* \ | f30[01]-* | f700-* | fido-* | fr30-* | frv-* | fx80-* \ | h8300-* | h8500-* \ | hppa-* | hppa1.[01]-* | hppa2.0-* | hppa2.0[nw]-* | hppa64-* \ | hexagon-* \ | i*86-* | i860-* | i960-* | ia64-* \ | ip2k-* | iq2000-* \ | le32-* | le64-* \ | lm32-* \ | m32c-* | m32r-* | m32rle-* \ | m68000-* | m680[012346]0-* | m68360-* | m683?2-* | m68k-* \ | m88110-* | m88k-* | maxq-* | mcore-* | metag-* | microblaze-* \ | mips-* | mipsbe-* | mipseb-* | mipsel-* | mipsle-* \ | mips16-* \ | mips64-* | mips64el-* \ | mips64octeon-* | mips64octeonel-* \ | mips64orion-* | mips64orionel-* \ | mips64r5900-* | mips64r5900el-* \ | mips64vr-* | mips64vrel-* \ | mips64vr4100-* | mips64vr4100el-* \ | mips64vr4300-* | mips64vr4300el-* \ | mips64vr5000-* | mips64vr5000el-* \ | mips64vr5900-* | mips64vr5900el-* \ | mipsisa32-* | mipsisa32el-* \ | mipsisa32r2-* | mipsisa32r2el-* \ | mipsisa64-* | mipsisa64el-* \ | mipsisa64r2-* | mipsisa64r2el-* \ | mipsisa64sb1-* | mipsisa64sb1el-* \ | mipsisa64sr71k-* | mipsisa64sr71kel-* \ | mipstx39-* | mipstx39el-* \ | mmix-* \ | mt-* \ | msp430-* \ | nds32-* | nds32le-* | nds32be-* \ | nios-* | nios2-* \ | none-* | np1-* | ns16k-* | ns32k-* \ | open8-* \ | orion-* \ | pdp10-* | pdp11-* | pj-* | pjl-* | pn-* | power-* \ | powerpc-* | powerpc64-* | powerpc64le-* | powerpcle-* \ | pyramid-* \ | rl78-* | romp-* | rs6000-* | rx-* \ | sh-* | sh[1234]-* | sh[24]a-* | sh[24]aeb-* | sh[23]e-* | sh[34]eb-* | sheb-* | shbe-* \ | shle-* | sh[1234]le-* | sh3ele-* | sh64-* | sh64le-* \ | sparc-* | sparc64-* | sparc64b-* | sparc64v-* | sparc86x-* | sparclet-* \ | sparclite-* \ | sparcv8-* | sparcv9-* | sparcv9b-* | sparcv9v-* | sv1-* | sx?-* \ | tahoe-* \ | tic30-* | tic4x-* | tic54x-* | tic55x-* | tic6x-* | tic80-* \ | tile*-* \ | tron-* \ | ubicom32-* \ | v850-* | v850e-* | v850e1-* | v850es-* | v850e2-* | v850e2v3-* \ | vax-* \ | we32k-* \ | x86-* | x86_64-* | xc16x-* | xps100-* \ | xstormy16-* | xtensa*-* \ | ymp-* \ | z8k-* | z80-*) ;; # Recognize the basic CPU types without company name, with glob match. xtensa*) basic_machine=$basic_machine-unknown ;; # Recognize the various machine names and aliases which stand # for a CPU type and a company and sometimes even an OS. 386bsd) basic_machine=i386-unknown os=-bsd ;; 3b1 | 7300 | 7300-att | att-7300 | pc7300 | safari | unixpc) basic_machine=m68000-att ;; 3b*) basic_machine=we32k-att ;; a29khif) basic_machine=a29k-amd os=-udi ;; abacus) basic_machine=abacus-unknown ;; adobe68k) basic_machine=m68010-adobe os=-scout ;; alliant | fx80) basic_machine=fx80-alliant ;; altos | altos3068) basic_machine=m68k-altos ;; am29k) basic_machine=a29k-none os=-bsd ;; amd64) basic_machine=x86_64-pc ;; amd64-*) basic_machine=x86_64-`echo $basic_machine | sed 's/^[^-]*-//'` ;; amdahl) basic_machine=580-amdahl os=-sysv ;; amiga | amiga-*) basic_machine=m68k-unknown ;; amigaos | amigados) basic_machine=m68k-unknown os=-amigaos ;; amigaunix | amix) basic_machine=m68k-unknown os=-sysv4 ;; apollo68) basic_machine=m68k-apollo os=-sysv ;; apollo68bsd) basic_machine=m68k-apollo os=-bsd ;; aros) basic_machine=i386-pc os=-aros ;; aux) basic_machine=m68k-apple os=-aux ;; balance) basic_machine=ns32k-sequent os=-dynix ;; blackfin) basic_machine=bfin-unknown os=-linux ;; blackfin-*) basic_machine=bfin-`echo $basic_machine | sed 's/^[^-]*-//'` os=-linux ;; bluegene*) basic_machine=powerpc-ibm os=-cnk ;; c54x-*) basic_machine=tic54x-`echo $basic_machine | sed 's/^[^-]*-//'` ;; c55x-*) basic_machine=tic55x-`echo $basic_machine | sed 's/^[^-]*-//'` ;; c6x-*) basic_machine=tic6x-`echo $basic_machine | sed 's/^[^-]*-//'` ;; c90) basic_machine=c90-cray os=-unicos ;; cegcc) basic_machine=arm-unknown os=-cegcc ;; convex-c1) basic_machine=c1-convex os=-bsd ;; convex-c2) basic_machine=c2-convex os=-bsd ;; convex-c32) basic_machine=c32-convex os=-bsd ;; convex-c34) basic_machine=c34-convex os=-bsd ;; convex-c38) basic_machine=c38-convex os=-bsd ;; cray | j90) basic_machine=j90-cray os=-unicos ;; craynv) basic_machine=craynv-cray os=-unicosmp ;; cr16 | cr16-*) basic_machine=cr16-unknown os=-elf ;; crds | unos) basic_machine=m68k-crds ;; crisv32 | crisv32-* | etraxfs*) basic_machine=crisv32-axis ;; cris | cris-* | etrax*) basic_machine=cris-axis ;; crx) basic_machine=crx-unknown os=-elf ;; da30 | da30-*) basic_machine=m68k-da30 ;; decstation | decstation-3100 | pmax | pmax-* | pmin | dec3100 | decstatn) basic_machine=mips-dec ;; decsystem10* | dec10*) basic_machine=pdp10-dec os=-tops10 ;; decsystem20* | dec20*) basic_machine=pdp10-dec os=-tops20 ;; delta | 3300 | motorola-3300 | motorola-delta \ | 3300-motorola | delta-motorola) basic_machine=m68k-motorola ;; delta88) basic_machine=m88k-motorola os=-sysv3 ;; dicos) basic_machine=i686-pc os=-dicos ;; djgpp) basic_machine=i586-pc os=-msdosdjgpp ;; dpx20 | dpx20-*) basic_machine=rs6000-bull os=-bosx ;; dpx2* | dpx2*-bull) basic_machine=m68k-bull os=-sysv3 ;; ebmon29k) basic_machine=a29k-amd os=-ebmon ;; elxsi) basic_machine=elxsi-elxsi os=-bsd ;; encore | umax | mmax) basic_machine=ns32k-encore ;; es1800 | OSE68k | ose68k | ose | OSE) basic_machine=m68k-ericsson os=-ose ;; fx2800) basic_machine=i860-alliant ;; genix) basic_machine=ns32k-ns ;; gmicro) basic_machine=tron-gmicro os=-sysv ;; go32) basic_machine=i386-pc os=-go32 ;; h3050r* | hiux*) basic_machine=hppa1.1-hitachi os=-hiuxwe2 ;; h8300hms) basic_machine=h8300-hitachi os=-hms ;; h8300xray) basic_machine=h8300-hitachi os=-xray ;; h8500hms) basic_machine=h8500-hitachi os=-hms ;; harris) basic_machine=m88k-harris os=-sysv3 ;; hp300-*) basic_machine=m68k-hp ;; hp300bsd) basic_machine=m68k-hp os=-bsd ;; hp300hpux) basic_machine=m68k-hp os=-hpux ;; hp3k9[0-9][0-9] | hp9[0-9][0-9]) basic_machine=hppa1.0-hp ;; hp9k2[0-9][0-9] | hp9k31[0-9]) basic_machine=m68000-hp ;; hp9k3[2-9][0-9]) basic_machine=m68k-hp ;; hp9k6[0-9][0-9] | hp6[0-9][0-9]) basic_machine=hppa1.0-hp ;; hp9k7[0-79][0-9] | hp7[0-79][0-9]) basic_machine=hppa1.1-hp ;; hp9k78[0-9] | hp78[0-9]) # FIXME: really hppa2.0-hp basic_machine=hppa1.1-hp ;; hp9k8[67]1 | hp8[67]1 | hp9k80[24] | hp80[24] | hp9k8[78]9 | hp8[78]9 | hp9k893 | hp893) # FIXME: really hppa2.0-hp basic_machine=hppa1.1-hp ;; hp9k8[0-9][13679] | hp8[0-9][13679]) basic_machine=hppa1.1-hp ;; hp9k8[0-9][0-9] | hp8[0-9][0-9]) basic_machine=hppa1.0-hp ;; hppa-next) os=-nextstep3 ;; hppaosf) basic_machine=hppa1.1-hp os=-osf ;; hppro) basic_machine=hppa1.1-hp os=-proelf ;; i370-ibm* | ibm*) basic_machine=i370-ibm ;; i*86v32) basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'` os=-sysv32 ;; i*86v4*) basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'` os=-sysv4 ;; i*86v) basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'` os=-sysv ;; i*86sol2) basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'` os=-solaris2 ;; i386mach) basic_machine=i386-mach os=-mach ;; i386-vsta | vsta) basic_machine=i386-unknown os=-vsta ;; iris | iris4d) basic_machine=mips-sgi case $os in -irix*) ;; *) os=-irix4 ;; esac ;; isi68 | isi) basic_machine=m68k-isi os=-sysv ;; m68knommu) basic_machine=m68k-unknown os=-linux ;; m68knommu-*) basic_machine=m68k-`echo $basic_machine | sed 's/^[^-]*-//'` os=-linux ;; m88k-omron*) basic_machine=m88k-omron ;; magnum | m3230) basic_machine=mips-mips os=-sysv ;; merlin) basic_machine=ns32k-utek os=-sysv ;; microblaze) basic_machine=microblaze-xilinx ;; mingw32) basic_machine=i386-pc os=-mingw32 ;; mingw32ce) basic_machine=arm-unknown os=-mingw32ce ;; miniframe) basic_machine=m68000-convergent ;; *mint | -mint[0-9]* | *MiNT | *MiNT[0-9]*) basic_machine=m68k-atari os=-mint ;; mips3*-*) basic_machine=`echo $basic_machine | sed -e 's/mips3/mips64/'` ;; mips3*) basic_machine=`echo $basic_machine | sed -e 's/mips3/mips64/'`-unknown ;; monitor) basic_machine=m68k-rom68k os=-coff ;; morphos) basic_machine=powerpc-unknown os=-morphos ;; msdos) basic_machine=i386-pc os=-msdos ;; ms1-*) basic_machine=`echo $basic_machine | sed -e 's/ms1-/mt-/'` ;; msys) basic_machine=i386-pc os=-msys ;; mvs) basic_machine=i370-ibm os=-mvs ;; nacl) basic_machine=le32-unknown os=-nacl ;; ncr3000) basic_machine=i486-ncr os=-sysv4 ;; netbsd386) basic_machine=i386-unknown os=-netbsd ;; netwinder) basic_machine=armv4l-rebel os=-linux ;; news | news700 | news800 | news900) basic_machine=m68k-sony os=-newsos ;; news1000) basic_machine=m68030-sony os=-newsos ;; news-3600 | risc-news) basic_machine=mips-sony os=-newsos ;; necv70) basic_machine=v70-nec os=-sysv ;; next | m*-next ) basic_machine=m68k-next case $os in -nextstep* ) ;; -ns2*) os=-nextstep2 ;; *) os=-nextstep3 ;; esac ;; nh3000) basic_machine=m68k-harris os=-cxux ;; nh[45]000) basic_machine=m88k-harris os=-cxux ;; nindy960) basic_machine=i960-intel os=-nindy ;; mon960) basic_machine=i960-intel os=-mon960 ;; nonstopux) basic_machine=mips-compaq os=-nonstopux ;; np1) basic_machine=np1-gould ;; neo-tandem) basic_machine=neo-tandem ;; nse-tandem) basic_machine=nse-tandem ;; nsr-tandem) basic_machine=nsr-tandem ;; op50n-* | op60c-*) basic_machine=hppa1.1-oki os=-proelf ;; openrisc | openrisc-*) basic_machine=or32-unknown ;; os400) basic_machine=powerpc-ibm os=-os400 ;; OSE68000 | ose68000) basic_machine=m68000-ericsson os=-ose ;; os68k) basic_machine=m68k-none os=-os68k ;; pa-hitachi) basic_machine=hppa1.1-hitachi os=-hiuxwe2 ;; paragon) basic_machine=i860-intel os=-osf ;; parisc) basic_machine=hppa-unknown os=-linux ;; parisc-*) basic_machine=hppa-`echo $basic_machine | sed 's/^[^-]*-//'` os=-linux ;; pbd) basic_machine=sparc-tti ;; pbb) basic_machine=m68k-tti ;; pc532 | pc532-*) basic_machine=ns32k-pc532 ;; pc98) basic_machine=i386-pc ;; pc98-*) basic_machine=i386-`echo $basic_machine | sed 's/^[^-]*-//'` ;; pentium | p5 | k5 | k6 | nexgen | viac3) basic_machine=i586-pc ;; pentiumpro | p6 | 6x86 | athlon | athlon_*) basic_machine=i686-pc ;; pentiumii | pentium2 | pentiumiii | pentium3) basic_machine=i686-pc ;; pentium4) basic_machine=i786-pc ;; pentium-* | p5-* | k5-* | k6-* | nexgen-* | viac3-*) basic_machine=i586-`echo $basic_machine | sed 's/^[^-]*-//'` ;; pentiumpro-* | p6-* | 6x86-* | athlon-*) basic_machine=i686-`echo $basic_machine | sed 's/^[^-]*-//'` ;; pentiumii-* | pentium2-* | pentiumiii-* | pentium3-*) basic_machine=i686-`echo $basic_machine | sed 's/^[^-]*-//'` ;; pentium4-*) basic_machine=i786-`echo $basic_machine | sed 's/^[^-]*-//'` ;; pn) basic_machine=pn-gould ;; power) basic_machine=power-ibm ;; ppc | ppcbe) basic_machine=powerpc-unknown ;; ppc-* | ppcbe-*) basic_machine=powerpc-`echo $basic_machine | sed 's/^[^-]*-//'` ;; ppcle | powerpclittle | ppc-le | powerpc-little) basic_machine=powerpcle-unknown ;; ppcle-* | powerpclittle-*) basic_machine=powerpcle-`echo $basic_machine | sed 's/^[^-]*-//'` ;; ppc64) basic_machine=powerpc64-unknown ;; ppc64-*) basic_machine=powerpc64-`echo $basic_machine | sed 's/^[^-]*-//'` ;; ppc64le | powerpc64little | ppc64-le | powerpc64-little) basic_machine=powerpc64le-unknown ;; ppc64le-* | powerpc64little-*) basic_machine=powerpc64le-`echo $basic_machine | sed 's/^[^-]*-//'` ;; ps2) basic_machine=i386-ibm ;; pw32) basic_machine=i586-unknown os=-pw32 ;; rdos) basic_machine=i386-pc os=-rdos ;; rom68k) basic_machine=m68k-rom68k os=-coff ;; rm[46]00) basic_machine=mips-siemens ;; rtpc | rtpc-*) basic_machine=romp-ibm ;; s390 | s390-*) basic_machine=s390-ibm ;; s390x | s390x-*) basic_machine=s390x-ibm ;; sa29200) basic_machine=a29k-amd os=-udi ;; sb1) basic_machine=mipsisa64sb1-unknown ;; sb1el) basic_machine=mipsisa64sb1el-unknown ;; sde) basic_machine=mipsisa32-sde os=-elf ;; sei) basic_machine=mips-sei os=-seiux ;; sequent) basic_machine=i386-sequent ;; sh) basic_machine=sh-hitachi os=-hms ;; sh5el) basic_machine=sh5le-unknown ;; sh64) basic_machine=sh64-unknown ;; sparclite-wrs | simso-wrs) basic_machine=sparclite-wrs os=-vxworks ;; sps7) basic_machine=m68k-bull os=-sysv2 ;; spur) basic_machine=spur-unknown ;; st2000) basic_machine=m68k-tandem ;; stratus) basic_machine=i860-stratus os=-sysv4 ;; strongarm-* | thumb-*) basic_machine=arm-`echo $basic_machine | sed 's/^[^-]*-//'` ;; sun2) basic_machine=m68000-sun ;; sun2os3) basic_machine=m68000-sun os=-sunos3 ;; sun2os4) basic_machine=m68000-sun os=-sunos4 ;; sun3os3) basic_machine=m68k-sun os=-sunos3 ;; sun3os4) basic_machine=m68k-sun os=-sunos4 ;; sun4os3) basic_machine=sparc-sun os=-sunos3 ;; sun4os4) basic_machine=sparc-sun os=-sunos4 ;; sun4sol2) basic_machine=sparc-sun os=-solaris2 ;; sun3 | sun3-*) basic_machine=m68k-sun ;; sun4) basic_machine=sparc-sun ;; sun386 | sun386i | roadrunner) basic_machine=i386-sun ;; sv1) basic_machine=sv1-cray os=-unicos ;; symmetry) basic_machine=i386-sequent os=-dynix ;; t3e) basic_machine=alphaev5-cray os=-unicos ;; t90) basic_machine=t90-cray os=-unicos ;; tile*) basic_machine=$basic_machine-unknown os=-linux-gnu ;; tx39) basic_machine=mipstx39-unknown ;; tx39el) basic_machine=mipstx39el-unknown ;; toad1) basic_machine=pdp10-xkl os=-tops20 ;; tower | tower-32) basic_machine=m68k-ncr ;; tpf) basic_machine=s390x-ibm os=-tpf ;; udi29k) basic_machine=a29k-amd os=-udi ;; ultra3) basic_machine=a29k-nyu os=-sym1 ;; v810 | necv810) basic_machine=v810-nec os=-none ;; vaxv) basic_machine=vax-dec os=-sysv ;; vms) basic_machine=vax-dec os=-vms ;; vpp*|vx|vx-*) basic_machine=f301-fujitsu ;; vxworks960) basic_machine=i960-wrs os=-vxworks ;; vxworks68) basic_machine=m68k-wrs os=-vxworks ;; vxworks29k) basic_machine=a29k-wrs os=-vxworks ;; w65*) basic_machine=w65-wdc os=-none ;; w89k-*) basic_machine=hppa1.1-winbond os=-proelf ;; xbox) basic_machine=i686-pc os=-mingw32 ;; xps | xps100) basic_machine=xps100-honeywell ;; xscale-* | xscalee[bl]-*) basic_machine=`echo $basic_machine | sed 's/^xscale/arm/'` ;; ymp) basic_machine=ymp-cray os=-unicos ;; z8k-*-coff) basic_machine=z8k-unknown os=-sim ;; z80-*-coff) basic_machine=z80-unknown os=-sim ;; none) basic_machine=none-none os=-none ;; # Here we handle the default manufacturer of certain CPU types. It is in # some cases the only manufacturer, in others, it is the most popular. w89k) basic_machine=hppa1.1-winbond ;; op50n) basic_machine=hppa1.1-oki ;; op60c) basic_machine=hppa1.1-oki ;; romp) basic_machine=romp-ibm ;; mmix) basic_machine=mmix-knuth ;; rs6000) basic_machine=rs6000-ibm ;; vax) basic_machine=vax-dec ;; pdp10) # there are many clones, so DEC is not a safe bet basic_machine=pdp10-unknown ;; pdp11) basic_machine=pdp11-dec ;; we32k) basic_machine=we32k-att ;; sh[1234] | sh[24]a | sh[24]aeb | sh[34]eb | sh[1234]le | sh[23]ele) basic_machine=sh-unknown ;; sparc | sparcv8 | sparcv9 | sparcv9b | sparcv9v) basic_machine=sparc-sun ;; cydra) basic_machine=cydra-cydrome ;; orion) basic_machine=orion-highlevel ;; orion105) basic_machine=clipper-highlevel ;; mac | mpw | mac-mpw) basic_machine=m68k-apple ;; pmac | pmac-mpw) basic_machine=powerpc-apple ;; *-unknown) # Make sure to match an already-canonicalized machine name. ;; *) echo Invalid configuration \`$1\': machine \`$basic_machine\' not recognized 1>&2 exit 1 ;; esac # Here we canonicalize certain aliases for manufacturers. case $basic_machine in *-digital*) basic_machine=`echo $basic_machine | sed 's/digital.*/dec/'` ;; *-commodore*) basic_machine=`echo $basic_machine | sed 's/commodore.*/cbm/'` ;; *) ;; esac # Decode manufacturer-specific aliases for certain operating systems. if [ x"$os" != x"" ] then case $os in # First match some system type aliases # that might get confused with valid system types. # -solaris* is a basic system type, with this one exception. -auroraux) os=-auroraux ;; -solaris1 | -solaris1.*) os=`echo $os | sed -e 's|solaris1|sunos4|'` ;; -solaris) os=-solaris2 ;; -svr4*) os=-sysv4 ;; -unixware*) os=-sysv4.2uw ;; -gnu/linux*) os=`echo $os | sed -e 's|gnu/linux|linux-gnu|'` ;; # First accept the basic system types. # The portable systems comes first. # Each alternative MUST END IN A *, to match a version number. # -sysv* is not here because it comes later, after sysvr4. -gnu* | -bsd* | -mach* | -minix* | -genix* | -ultrix* | -irix* \ | -*vms* | -sco* | -esix* | -isc* | -aix* | -cnk* | -sunos | -sunos[34]*\ | -hpux* | -unos* | -osf* | -luna* | -dgux* | -auroraux* | -solaris* \ | -sym* | -kopensolaris* \ | -amigaos* | -amigados* | -msdos* | -newsos* | -unicos* | -aof* \ | -aos* | -aros* \ | -nindy* | -vxsim* | -vxworks* | -ebmon* | -hms* | -mvs* \ | -clix* | -riscos* | -uniplus* | -iris* | -rtu* | -xenix* \ | -hiux* | -386bsd* | -knetbsd* | -mirbsd* | -netbsd* \ | -openbsd* | -solidbsd* \ | -ekkobsd* | -kfreebsd* | -freebsd* | -riscix* | -lynxos* \ | -bosx* | -nextstep* | -cxux* | -aout* | -elf* | -oabi* \ | -ptx* | -coff* | -ecoff* | -winnt* | -domain* | -vsta* \ | -udi* | -eabi* | -lites* | -ieee* | -go32* | -aux* \ | -chorusos* | -chorusrdb* | -cegcc* \ | -cygwin* | -msys* | -pe* | -psos* | -moss* | -proelf* | -rtems* \ | -mingw32* | -linux-gnu* | -linux-android* \ | -linux-newlib* | -linux-uclibc* \ | -uxpv* | -beos* | -mpeix* | -udk* \ | -interix* | -uwin* | -mks* | -rhapsody* | -darwin* | -opened* \ | -openstep* | -oskit* | -conix* | -pw32* | -nonstopux* \ | -storm-chaos* | -tops10* | -tenex* | -tops20* | -its* \ | -os2* | -vos* | -palmos* | -uclinux* | -nucleus* \ | -morphos* | -superux* | -rtmk* | -rtmk-nova* | -windiss* \ | -powermax* | -dnix* | -nx6 | -nx7 | -sei* | -dragonfly* \ | -skyos* | -haiku* | -rdos* | -toppers* | -drops* | -es*) # Remember, each alternative MUST END IN *, to match a version number. ;; -qnx*) case $basic_machine in x86-* | i*86-*) ;; *) os=-nto$os ;; esac ;; -nto-qnx*) ;; -nto*) os=`echo $os | sed -e 's|nto|nto-qnx|'` ;; -sim | -es1800* | -hms* | -xray | -os68k* | -none* | -v88r* \ | -windows* | -osx | -abug | -netware* | -os9* | -beos* | -haiku* \ | -macos* | -mpw* | -magic* | -mmixware* | -mon960* | -lnews*) ;; -mac*) os=`echo $os | sed -e 's|mac|macos|'` ;; -linux-dietlibc) os=-linux-dietlibc ;; -linux*) os=`echo $os | sed -e 's|linux|linux-gnu|'` ;; -sunos5*) os=`echo $os | sed -e 's|sunos5|solaris2|'` ;; -sunos6*) os=`echo $os | sed -e 's|sunos6|solaris3|'` ;; -opened*) os=-openedition ;; -os400*) os=-os400 ;; -wince*) os=-wince ;; -osfrose*) os=-osfrose ;; -osf*) os=-osf ;; -utek*) os=-bsd ;; -dynix*) os=-bsd ;; -acis*) os=-aos ;; -atheos*) os=-atheos ;; -syllable*) os=-syllable ;; -386bsd) os=-bsd ;; -ctix* | -uts*) os=-sysv ;; -nova*) os=-rtmk-nova ;; -ns2 ) os=-nextstep2 ;; -nsk*) os=-nsk ;; # Preserve the version number of sinix5. -sinix5.*) os=`echo $os | sed -e 's|sinix|sysv|'` ;; -sinix*) os=-sysv4 ;; -tpf*) os=-tpf ;; -triton*) os=-sysv3 ;; -oss*) os=-sysv3 ;; -svr4) os=-sysv4 ;; -svr3) os=-sysv3 ;; -sysvr4) os=-sysv4 ;; # This must come after -sysvr4. -sysv*) ;; -ose*) os=-ose ;; -es1800*) os=-ose ;; -xenix) os=-xenix ;; -*mint | -mint[0-9]* | -*MiNT | -MiNT[0-9]*) os=-mint ;; -aros*) os=-aros ;; -kaos*) os=-kaos ;; -zvmoe) os=-zvmoe ;; -dicos*) os=-dicos ;; -nacl*) ;; -none) ;; *) # Get rid of the `-' at the beginning of $os. os=`echo $os | sed 's/[^-]*-//'` echo Invalid configuration \`$1\': system \`$os\' not recognized 1>&2 exit 1 ;; esac else # Here we handle the default operating systems that come with various machines. # The value should be what the vendor currently ships out the door with their # machine or put another way, the most popular os provided with the machine. # Note that if you're going to try to match "-MANUFACTURER" here (say, # "-sun"), then you have to tell the case statement up towards the top # that MANUFACTURER isn't an operating system. Otherwise, code above # will signal an error saying that MANUFACTURER isn't an operating # system, and we'll never get to this point. case $basic_machine in score-*) os=-elf ;; spu-*) os=-elf ;; *-acorn) os=-riscix1.2 ;; arm*-rebel) os=-linux ;; arm*-semi) os=-aout ;; c4x-* | tic4x-*) os=-coff ;; tic54x-*) os=-coff ;; tic55x-*) os=-coff ;; tic6x-*) os=-coff ;; # This must come before the *-dec entry. pdp10-*) os=-tops20 ;; pdp11-*) os=-none ;; *-dec | vax-*) os=-ultrix4.2 ;; m68*-apollo) os=-domain ;; i386-sun) os=-sunos4.0.2 ;; m68000-sun) os=-sunos3 ;; m68*-cisco) os=-aout ;; mep-*) os=-elf ;; mips*-cisco) os=-elf ;; mips*-*) os=-elf ;; or32-*) os=-coff ;; *-tti) # must be before sparc entry or we get the wrong os. os=-sysv3 ;; sparc-* | *-sun) os=-sunos4.1.1 ;; *-be) os=-beos ;; *-haiku) os=-haiku ;; *-ibm) os=-aix ;; *-knuth) os=-mmixware ;; *-wec) os=-proelf ;; *-winbond) os=-proelf ;; *-oki) os=-proelf ;; *-hp) os=-hpux ;; *-hitachi) os=-hiux ;; i860-* | *-att | *-ncr | *-altos | *-motorola | *-convergent) os=-sysv ;; *-cbm) os=-amigaos ;; *-dg) os=-dgux ;; *-dolphin) os=-sysv3 ;; m68k-ccur) os=-rtu ;; m88k-omron*) os=-luna ;; *-next ) os=-nextstep ;; *-sequent) os=-ptx ;; *-crds) os=-unos ;; *-ns) os=-genix ;; i370-*) os=-mvs ;; *-next) os=-nextstep3 ;; *-gould) os=-sysv ;; *-highlevel) os=-bsd ;; *-encore) os=-bsd ;; *-sgi) os=-irix ;; *-siemens) os=-sysv4 ;; *-masscomp) os=-rtu ;; f30[01]-fujitsu | f700-fujitsu) os=-uxpv ;; *-rom68k) os=-coff ;; *-*bug) os=-coff ;; *-apple) os=-macos ;; *-atari*) os=-mint ;; *) os=-none ;; esac fi # Here we handle the case where we know the os, and the CPU type, but not the # manufacturer. We pick the logical manufacturer. vendor=unknown case $basic_machine in *-unknown) case $os in -riscix*) vendor=acorn ;; -sunos*) vendor=sun ;; -cnk*|-aix*) vendor=ibm ;; -beos*) vendor=be ;; -hpux*) vendor=hp ;; -mpeix*) vendor=hp ;; -hiux*) vendor=hitachi ;; -unos*) vendor=crds ;; -dgux*) vendor=dg ;; -luna*) vendor=omron ;; -genix*) vendor=ns ;; -mvs* | -opened*) vendor=ibm ;; -os400*) vendor=ibm ;; -ptx*) vendor=sequent ;; -tpf*) vendor=ibm ;; -vxsim* | -vxworks* | -windiss*) vendor=wrs ;; -aux*) vendor=apple ;; -hms*) vendor=hitachi ;; -mpw* | -macos*) vendor=apple ;; -*mint | -mint[0-9]* | -*MiNT | -MiNT[0-9]*) vendor=atari ;; -vos*) vendor=stratus ;; esac basic_machine=`echo $basic_machine | sed "s/unknown/$vendor/"` ;; esac echo $basic_machine$os exit # Local variables: # eval: (add-hook 'write-file-hooks 'time-stamp) # time-stamp-start: "timestamp='" # time-stamp-format: "%:y-%02m-%02d" # time-stamp-end: "'" # End: ldns-1.6.17/rbtree.c0000664000175100017510000004245112264060151013550 0ustar willemwillem/* * rbtree.c -- generic red black tree * * Taken from Unbound, modified for ldns * * Copyright (c) 2001-2008, NLnet Labs. All rights reserved. * * This software is open source. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * Redistributions of source code must retain the above copyright notice, * this list of conditions and the following disclaimer. * * Redistributions in binary form must reproduce the above copyright notice, * this list of conditions and the following disclaimer in the documentation * and/or other materials provided with the distribution. * * Neither the name of the NLNET LABS nor the names of its contributors may * be used to endorse or promote products derived from this software without * specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. * */ /** * \file * Implementation of a redblack tree. */ #include #include #include #include /** Node colour black */ #define BLACK 0 /** Node colour red */ #define RED 1 /** the NULL node, global alloc */ ldns_rbnode_t ldns_rbtree_null_node = { LDNS_RBTREE_NULL, /* Parent. */ LDNS_RBTREE_NULL, /* Left. */ LDNS_RBTREE_NULL, /* Right. */ NULL, /* Key. */ NULL, /* Data. */ BLACK /* Color. */ }; /** rotate subtree left (to preserve redblack property) */ static void ldns_rbtree_rotate_left(ldns_rbtree_t *rbtree, ldns_rbnode_t *node); /** rotate subtree right (to preserve redblack property) */ static void ldns_rbtree_rotate_right(ldns_rbtree_t *rbtree, ldns_rbnode_t *node); /** Fixup node colours when insert happened */ static void ldns_rbtree_insert_fixup(ldns_rbtree_t *rbtree, ldns_rbnode_t *node); /** Fixup node colours when delete happened */ static void ldns_rbtree_delete_fixup(ldns_rbtree_t* rbtree, ldns_rbnode_t* child, ldns_rbnode_t* child_parent); /* * Creates a new red black tree, intializes and returns a pointer to it. * * Return NULL on failure. * */ ldns_rbtree_t * ldns_rbtree_create (int (*cmpf)(const void *, const void *)) { ldns_rbtree_t *rbtree; /* Allocate memory for it */ rbtree = (ldns_rbtree_t *) LDNS_MALLOC(ldns_rbtree_t); if (!rbtree) { return NULL; } /* Initialize it */ ldns_rbtree_init(rbtree, cmpf); return rbtree; } void ldns_rbtree_init(ldns_rbtree_t *rbtree, int (*cmpf)(const void *, const void *)) { /* Initialize it */ rbtree->root = LDNS_RBTREE_NULL; rbtree->count = 0; rbtree->cmp = cmpf; } void ldns_rbtree_free(ldns_rbtree_t *rbtree) { LDNS_FREE(rbtree); } /* * Rotates the node to the left. * */ static void ldns_rbtree_rotate_left(ldns_rbtree_t *rbtree, ldns_rbnode_t *node) { ldns_rbnode_t *right = node->right; node->right = right->left; if (right->left != LDNS_RBTREE_NULL) right->left->parent = node; right->parent = node->parent; if (node->parent != LDNS_RBTREE_NULL) { if (node == node->parent->left) { node->parent->left = right; } else { node->parent->right = right; } } else { rbtree->root = right; } right->left = node; node->parent = right; } /* * Rotates the node to the right. * */ static void ldns_rbtree_rotate_right(ldns_rbtree_t *rbtree, ldns_rbnode_t *node) { ldns_rbnode_t *left = node->left; node->left = left->right; if (left->right != LDNS_RBTREE_NULL) left->right->parent = node; left->parent = node->parent; if (node->parent != LDNS_RBTREE_NULL) { if (node == node->parent->right) { node->parent->right = left; } else { node->parent->left = left; } } else { rbtree->root = left; } left->right = node; node->parent = left; } static void ldns_rbtree_insert_fixup(ldns_rbtree_t *rbtree, ldns_rbnode_t *node) { ldns_rbnode_t *uncle; /* While not at the root and need fixing... */ while (node != rbtree->root && node->parent->color == RED) { /* If our parent is left child of our grandparent... */ if (node->parent == node->parent->parent->left) { uncle = node->parent->parent->right; /* If our uncle is red... */ if (uncle->color == RED) { /* Paint the parent and the uncle black... */ node->parent->color = BLACK; uncle->color = BLACK; /* And the grandparent red... */ node->parent->parent->color = RED; /* And continue fixing the grandparent */ node = node->parent->parent; } else { /* Our uncle is black... */ /* Are we the right child? */ if (node == node->parent->right) { node = node->parent; ldns_rbtree_rotate_left(rbtree, node); } /* Now we're the left child, repaint and rotate... */ node->parent->color = BLACK; node->parent->parent->color = RED; ldns_rbtree_rotate_right(rbtree, node->parent->parent); } } else { uncle = node->parent->parent->left; /* If our uncle is red... */ if (uncle->color == RED) { /* Paint the parent and the uncle black... */ node->parent->color = BLACK; uncle->color = BLACK; /* And the grandparent red... */ node->parent->parent->color = RED; /* And continue fixing the grandparent */ node = node->parent->parent; } else { /* Our uncle is black... */ /* Are we the right child? */ if (node == node->parent->left) { node = node->parent; ldns_rbtree_rotate_right(rbtree, node); } /* Now we're the right child, repaint and rotate... */ node->parent->color = BLACK; node->parent->parent->color = RED; ldns_rbtree_rotate_left(rbtree, node->parent->parent); } } } rbtree->root->color = BLACK; } void ldns_rbtree_insert_vref(ldns_rbnode_t *data, void *rbtree) { (void) ldns_rbtree_insert((ldns_rbtree_t *) rbtree, data); } /* * Inserts a node into a red black tree. * * Returns NULL on failure or the pointer to the newly added node * otherwise. */ ldns_rbnode_t * ldns_rbtree_insert (ldns_rbtree_t *rbtree, ldns_rbnode_t *data) { /* XXX Not necessary, but keeps compiler quiet... */ int r = 0; /* We start at the root of the tree */ ldns_rbnode_t *node = rbtree->root; ldns_rbnode_t *parent = LDNS_RBTREE_NULL; /* Lets find the new parent... */ while (node != LDNS_RBTREE_NULL) { /* Compare two keys, do we have a duplicate? */ if ((r = rbtree->cmp(data->key, node->key)) == 0) { return NULL; } parent = node; if (r < 0) { node = node->left; } else { node = node->right; } } /* Initialize the new node */ data->parent = parent; data->left = data->right = LDNS_RBTREE_NULL; data->color = RED; rbtree->count++; /* Insert it into the tree... */ if (parent != LDNS_RBTREE_NULL) { if (r < 0) { parent->left = data; } else { parent->right = data; } } else { rbtree->root = data; } /* Fix up the red-black properties... */ ldns_rbtree_insert_fixup(rbtree, data); return data; } /* * Searches the red black tree, returns the data if key is found or NULL otherwise. * */ ldns_rbnode_t * ldns_rbtree_search (ldns_rbtree_t *rbtree, const void *key) { ldns_rbnode_t *node; if (ldns_rbtree_find_less_equal(rbtree, key, &node)) { return node; } else { return NULL; } } /** helpers for delete: swap node colours */ static void swap_int8(uint8_t* x, uint8_t* y) { uint8_t t = *x; *x = *y; *y = t; } /** helpers for delete: swap node pointers */ static void swap_np(ldns_rbnode_t** x, ldns_rbnode_t** y) { ldns_rbnode_t* t = *x; *x = *y; *y = t; } /** Update parent pointers of child trees of 'parent' */ static void change_parent_ptr(ldns_rbtree_t* rbtree, ldns_rbnode_t* parent, ldns_rbnode_t* old, ldns_rbnode_t* new) { if(parent == LDNS_RBTREE_NULL) { if(rbtree->root == old) rbtree->root = new; return; } if(parent->left == old) parent->left = new; if(parent->right == old) parent->right = new; } /** Update parent pointer of a node 'child' */ static void change_child_ptr(ldns_rbnode_t* child, ldns_rbnode_t* old, ldns_rbnode_t* new) { if(child == LDNS_RBTREE_NULL) return; if(child->parent == old) child->parent = new; } ldns_rbnode_t* ldns_rbtree_delete(ldns_rbtree_t *rbtree, const void *key) { ldns_rbnode_t *to_delete; ldns_rbnode_t *child; if((to_delete = ldns_rbtree_search(rbtree, key)) == 0) return 0; rbtree->count--; /* make sure we have at most one non-leaf child */ if(to_delete->left != LDNS_RBTREE_NULL && to_delete->right != LDNS_RBTREE_NULL) { /* swap with smallest from right subtree (or largest from left) */ ldns_rbnode_t *smright = to_delete->right; while(smright->left != LDNS_RBTREE_NULL) smright = smright->left; /* swap the smright and to_delete elements in the tree, * but the ldns_rbnode_t is first part of user data struct * so cannot just swap the keys and data pointers. Instead * readjust the pointers left,right,parent */ /* swap colors - colors are tied to the position in the tree */ swap_int8(&to_delete->color, &smright->color); /* swap child pointers in parents of smright/to_delete */ change_parent_ptr(rbtree, to_delete->parent, to_delete, smright); if(to_delete->right != smright) change_parent_ptr(rbtree, smright->parent, smright, to_delete); /* swap parent pointers in children of smright/to_delete */ change_child_ptr(smright->left, smright, to_delete); change_child_ptr(smright->left, smright, to_delete); change_child_ptr(smright->right, smright, to_delete); change_child_ptr(smright->right, smright, to_delete); change_child_ptr(to_delete->left, to_delete, smright); if(to_delete->right != smright) change_child_ptr(to_delete->right, to_delete, smright); if(to_delete->right == smright) { /* set up so after swap they work */ to_delete->right = to_delete; smright->parent = smright; } /* swap pointers in to_delete/smright nodes */ swap_np(&to_delete->parent, &smright->parent); swap_np(&to_delete->left, &smright->left); swap_np(&to_delete->right, &smright->right); /* now delete to_delete (which is at the location where the smright previously was) */ } if(to_delete->left != LDNS_RBTREE_NULL) child = to_delete->left; else child = to_delete->right; /* unlink to_delete from the tree, replace to_delete with child */ change_parent_ptr(rbtree, to_delete->parent, to_delete, child); change_child_ptr(child, to_delete, to_delete->parent); if(to_delete->color == RED) { /* if node is red then the child (black) can be swapped in */ } else if(child->color == RED) { /* change child to BLACK, removing a RED node is no problem */ if(child!=LDNS_RBTREE_NULL) child->color = BLACK; } else ldns_rbtree_delete_fixup(rbtree, child, to_delete->parent); /* unlink completely */ to_delete->parent = LDNS_RBTREE_NULL; to_delete->left = LDNS_RBTREE_NULL; to_delete->right = LDNS_RBTREE_NULL; to_delete->color = BLACK; return to_delete; } static void ldns_rbtree_delete_fixup(ldns_rbtree_t* rbtree, ldns_rbnode_t* child, ldns_rbnode_t* child_parent) { ldns_rbnode_t* sibling; int go_up = 1; /* determine sibling to the node that is one-black short */ if(child_parent->right == child) sibling = child_parent->left; else sibling = child_parent->right; while(go_up) { if(child_parent == LDNS_RBTREE_NULL) { /* removed parent==black from root, every path, so ok */ return; } if(sibling->color == RED) { /* rotate to get a black sibling */ child_parent->color = RED; sibling->color = BLACK; if(child_parent->right == child) ldns_rbtree_rotate_right(rbtree, child_parent); else ldns_rbtree_rotate_left(rbtree, child_parent); /* new sibling after rotation */ if(child_parent->right == child) sibling = child_parent->left; else sibling = child_parent->right; } if(child_parent->color == BLACK && sibling->color == BLACK && sibling->left->color == BLACK && sibling->right->color == BLACK) { /* fixup local with recolor of sibling */ if(sibling != LDNS_RBTREE_NULL) sibling->color = RED; child = child_parent; child_parent = child_parent->parent; /* prepare to go up, new sibling */ if(child_parent->right == child) sibling = child_parent->left; else sibling = child_parent->right; } else go_up = 0; } if(child_parent->color == RED && sibling->color == BLACK && sibling->left->color == BLACK && sibling->right->color == BLACK) { /* move red to sibling to rebalance */ if(sibling != LDNS_RBTREE_NULL) sibling->color = RED; child_parent->color = BLACK; return; } /* get a new sibling, by rotating at sibling. See which child of sibling is red */ if(child_parent->right == child && sibling->color == BLACK && sibling->right->color == RED && sibling->left->color == BLACK) { sibling->color = RED; sibling->right->color = BLACK; ldns_rbtree_rotate_left(rbtree, sibling); /* new sibling after rotation */ if(child_parent->right == child) sibling = child_parent->left; else sibling = child_parent->right; } else if(child_parent->left == child && sibling->color == BLACK && sibling->left->color == RED && sibling->right->color == BLACK) { sibling->color = RED; sibling->left->color = BLACK; ldns_rbtree_rotate_right(rbtree, sibling); /* new sibling after rotation */ if(child_parent->right == child) sibling = child_parent->left; else sibling = child_parent->right; } /* now we have a black sibling with a red child. rotate and exchange colors. */ sibling->color = child_parent->color; child_parent->color = BLACK; if(child_parent->right == child) { sibling->left->color = BLACK; ldns_rbtree_rotate_right(rbtree, child_parent); } else { sibling->right->color = BLACK; ldns_rbtree_rotate_left(rbtree, child_parent); } } int ldns_rbtree_find_less_equal(ldns_rbtree_t *rbtree, const void *key, ldns_rbnode_t **result) { int r; ldns_rbnode_t *node; /* We start at root... */ node = rbtree->root; *result = NULL; /* While there are children... */ while (node != LDNS_RBTREE_NULL) { r = rbtree->cmp(key, node->key); if (r == 0) { /* Exact match */ *result = node; return 1; } if (r < 0) { node = node->left; } else { /* Temporary match */ *result = node; node = node->right; } } return 0; } /* * Finds the first element in the red black tree * */ ldns_rbnode_t * ldns_rbtree_first (ldns_rbtree_t *rbtree) { ldns_rbnode_t *node = rbtree->root; if (rbtree->root != LDNS_RBTREE_NULL) { for (node = rbtree->root; node->left != LDNS_RBTREE_NULL; node = node->left); } return node; } ldns_rbnode_t * ldns_rbtree_last (ldns_rbtree_t *rbtree) { ldns_rbnode_t *node = rbtree->root; if (rbtree->root != LDNS_RBTREE_NULL) { for (node = rbtree->root; node->right != LDNS_RBTREE_NULL; node = node->right); } return node; } /* * Returns the next node... * */ ldns_rbnode_t * ldns_rbtree_next (ldns_rbnode_t *node) { ldns_rbnode_t *parent; if (node->right != LDNS_RBTREE_NULL) { /* One right, then keep on going left... */ for (node = node->right; node->left != LDNS_RBTREE_NULL; node = node->left); } else { parent = node->parent; while (parent != LDNS_RBTREE_NULL && node == parent->right) { node = parent; parent = parent->parent; } node = parent; } return node; } ldns_rbnode_t * ldns_rbtree_previous(ldns_rbnode_t *node) { ldns_rbnode_t *parent; if (node->left != LDNS_RBTREE_NULL) { /* One left, then keep on going right... */ for (node = node->left; node->right != LDNS_RBTREE_NULL; node = node->right); } else { parent = node->parent; while (parent != LDNS_RBTREE_NULL && node == parent->left) { node = parent; parent = parent->parent; } node = parent; } return node; } /** * split off elements number of elements from the start * of the name tree and return a new tree */ ldns_rbtree_t * ldns_rbtree_split(ldns_rbtree_t *tree, size_t elements) { ldns_rbtree_t *new_tree; ldns_rbnode_t *cur_node; ldns_rbnode_t *move_node; size_t count = 0; new_tree = ldns_rbtree_create(tree->cmp); cur_node = ldns_rbtree_first(tree); while (count < elements && cur_node != LDNS_RBTREE_NULL) { move_node = ldns_rbtree_delete(tree, cur_node->key); (void)ldns_rbtree_insert(new_tree, move_node); cur_node = ldns_rbtree_first(tree); count++; } return new_tree; } /* * add all node from the second tree to the first (removing them from the * second), and fix up nsec(3)s if present */ void ldns_rbtree_join(ldns_rbtree_t *tree1, ldns_rbtree_t *tree2) { ldns_traverse_postorder(tree2, ldns_rbtree_insert_vref, tree1); } /** recursive descent traverse */ static void traverse_post(void (*func)(ldns_rbnode_t*, void*), void* arg, ldns_rbnode_t* node) { if(!node || node == LDNS_RBTREE_NULL) return; /* recurse */ traverse_post(func, arg, node->left); traverse_post(func, arg, node->right); /* call user func */ (*func)(node, arg); } void ldns_traverse_postorder(ldns_rbtree_t* tree, void (*func)(ldns_rbnode_t*, void*), void* arg) { traverse_post(func, arg, tree->root); } ldns-1.6.17/examples/0000775000175100017510000000000012264060171013733 5ustar willemwillemldns-1.6.17/examples/ldns-mx.10000664000175100017510000000102512264060151015373 0ustar willemwillem.TH ldns-mx 1 "27 Apr 2005" .SH NAME ldns-mx \- print out the mx record(s) for a domain .SH SYNOPSIS .B ldns-mx .IR DOMAIN .SH DESCRIPTION \fBldns-mx\fR is used to print out mx information of a domain. .SH OPTIONS \fBldns-mx\fR has no options. .SH AUTHOR Written by the ldns team as an example for ldns usage. .SH REPORTING BUGS Report bugs to . .SH COPYRIGHT Copyright (C) 2005 NLnet Labs. This is free software. There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. ldns-1.6.17/examples/ldns-verify-zone.c0000664000175100017510000005561612264060151017325 0ustar willemwillem/* * read a zone file from disk and prints it, one RR per line * * (c) NLnetLabs 2008 * * See the file LICENSE for the license * * Missing from the checks: empty non-terminals */ #include "config.h" #include #include #include #include #include #ifdef HAVE_SSL #include static int verbosity = 3; static time_t check_time = 0; static int32_t inception_offset = 0; static int32_t expiration_offset = 0; static bool do_sigchase = false; static bool no_nomatch_msg = false; static FILE* myout; static FILE* myerr; static void update_error(ldns_status* result, ldns_status status) { if (status != LDNS_STATUS_OK) { if (*result == LDNS_STATUS_OK || *result == LDNS_STATUS_ERR || ( *result == LDNS_STATUS_CRYPTO_NO_MATCHING_KEYTAG_DNSKEY && status != LDNS_STATUS_ERR )) { *result = status; } } } static void print_type(FILE* stream, ldns_rr_type type) { const ldns_rr_descriptor *descriptor = ldns_rr_descript(type); if (descriptor && descriptor->_name) { fprintf(stream, "%s", descriptor->_name); } else { fprintf(stream, "TYPE%u", type); } } ldns_status read_key_file(const char *filename, ldns_rr_list *keys) { ldns_status status = LDNS_STATUS_ERR; ldns_rr *rr; FILE *fp; uint32_t my_ttl = 0; ldns_rdf *my_origin = NULL; ldns_rdf *my_prev = NULL; int line_nr; if (!(fp = fopen(filename, "r"))) { return LDNS_STATUS_FILE_ERR; } while (!feof(fp)) { status = ldns_rr_new_frm_fp_l(&rr, fp, &my_ttl, &my_origin, &my_prev, &line_nr); if (status == LDNS_STATUS_OK) { if ( ldns_rr_get_type(rr) == LDNS_RR_TYPE_DS || ldns_rr_get_type(rr) == LDNS_RR_TYPE_DNSKEY) ldns_rr_list_push_rr(keys, rr); } else if ( status == LDNS_STATUS_SYNTAX_EMPTY || status == LDNS_STATUS_SYNTAX_TTL || status == LDNS_STATUS_SYNTAX_ORIGIN || status == LDNS_STATUS_SYNTAX_INCLUDE) status = LDNS_STATUS_OK; else break; } fclose(fp); return status; } static void print_rr_error(FILE* stream, ldns_rr* rr, const char* msg) { if (verbosity > 0) { fprintf(stream, "Error: %s for ", msg); ldns_rdf_print(stream, ldns_rr_owner(rr)); fprintf(stream, "\t"); print_type(stream, ldns_rr_get_type(rr)); fprintf(stream, "\n"); } } static void print_rr_status_error(FILE* stream, ldns_rr* rr, ldns_status status) { if (status != LDNS_STATUS_OK) { print_rr_error(stream, rr, ldns_get_errorstr_by_id(status)); if (verbosity > 0 && status == LDNS_STATUS_SSL_ERR) { ERR_load_crypto_strings(); ERR_print_errors_fp(stream); } } } static void print_rrs_status_error(FILE* stream, ldns_rr_list* rrs, ldns_status status, ldns_dnssec_rrs* cur_sig) { if (status != LDNS_STATUS_OK) { if (ldns_rr_list_rr_count(rrs) > 0) { print_rr_status_error(stream, ldns_rr_list_rr(rrs, 0), status); } else if (verbosity > 0) { fprintf(stream, "Error: %s for \n", ldns_get_errorstr_by_id(status)); } if (verbosity >= 4) { fprintf(stream, "RRSet:\n"); ldns_rr_list_print(stream, rrs); fprintf(stream, "Signature:\n"); ldns_rr_print(stream, cur_sig->rr); fprintf(stream, "\n"); } } } static ldns_status rrsig_check_time_margins(ldns_rr* rrsig #if 0 /* Passing those as arguments becomes sensible when * rrsig_check_time_margins will be added to the library. */ ,time_t check_time, int32_t inception_offset, int32_t expiration_offset #endif ) { int32_t inception, expiration; inception = ldns_rdf2native_int32(ldns_rr_rrsig_inception (rrsig)); expiration = ldns_rdf2native_int32(ldns_rr_rrsig_expiration(rrsig)); if (((int32_t) (check_time - inception_offset)) - inception < 0) { return LDNS_STATUS_CRYPTO_SIG_NOT_INCEPTED_WITHIN_MARGIN; } if (expiration - ((int32_t) (check_time + expiration_offset)) < 0) { return LDNS_STATUS_CRYPTO_SIG_EXPIRED_WITHIN_MARGIN; } return LDNS_STATUS_OK; } static ldns_status verify_rrs(ldns_rr_list* rrset_rrs, ldns_dnssec_rrs* cur_sig, ldns_rr_list* keys) { ldns_rr_list* good_keys; ldns_status status, result = LDNS_STATUS_OK; while (cur_sig) { good_keys = ldns_rr_list_new(); status = ldns_verify_rrsig_keylist_time(rrset_rrs, cur_sig->rr, keys, check_time, good_keys); status = status ? status : rrsig_check_time_margins(cur_sig->rr); if (status != LDNS_STATUS_CRYPTO_NO_MATCHING_KEYTAG_DNSKEY || !no_nomatch_msg) { print_rrs_status_error(myerr, rrset_rrs, status, cur_sig); } update_error(&result, status); ldns_rr_list_free(good_keys); cur_sig = cur_sig->next; } return result; } static ldns_status verify_dnssec_rrset(ldns_rdf *zone_name, ldns_rdf *name, ldns_dnssec_rrsets *rrset, ldns_rr_list *keys) { ldns_rr_list *rrset_rrs; ldns_dnssec_rrs *cur_rr, *cur_sig; ldns_status status; if (!rrset->rrs) return LDNS_STATUS_OK; rrset_rrs = ldns_rr_list_new(); cur_rr = rrset->rrs; while(cur_rr && cur_rr->rr) { ldns_rr_list_push_rr(rrset_rrs, cur_rr->rr); cur_rr = cur_rr->next; } cur_sig = rrset->signatures; if (cur_sig) { status = verify_rrs(rrset_rrs, cur_sig, keys); } else /* delegations may be unsigned (on opt out...) */ if (rrset->type != LDNS_RR_TYPE_NS || ldns_dname_compare(name, zone_name) == 0) { print_rr_error(myerr, rrset->rrs->rr, "no signatures"); status = LDNS_STATUS_CRYPTO_NO_RRSIG; } else { status = LDNS_STATUS_OK; } ldns_rr_list_free(rrset_rrs); return status; } static ldns_status verify_single_rr(ldns_rr *rr, ldns_dnssec_rrs *signature_rrs, ldns_rr_list *keys) { ldns_rr_list *rrset_rrs; ldns_status status; rrset_rrs = ldns_rr_list_new(); ldns_rr_list_push_rr(rrset_rrs, rr); status = verify_rrs(rrset_rrs, signature_rrs, keys); ldns_rr_list_free(rrset_rrs); return status; } static ldns_status verify_next_hashed_name(ldns_dnssec_zone* zone, ldns_dnssec_name *name) { ldns_rbnode_t *next_node; ldns_dnssec_name *next_name; int cmp; char *next_owner_str; ldns_rdf *next_owner_dname; assert(name->hashed_name != NULL); next_node = ldns_rbtree_search(zone->hashed_names, name->hashed_name); assert(next_node != NULL); do { next_node = ldns_rbtree_next(next_node); if (next_node == LDNS_RBTREE_NULL) { next_node = ldns_rbtree_first(zone->hashed_names); } next_name = (ldns_dnssec_name *) next_node->data; } while (! next_name->nsec); next_owner_str = ldns_rdf2str(ldns_nsec3_next_owner(name->nsec)); next_owner_dname = ldns_dname_new_frm_str(next_owner_str); cmp = ldns_dname_compare(next_owner_dname, next_name->hashed_name); ldns_rdf_deep_free(next_owner_dname); LDNS_FREE(next_owner_str); if (cmp != 0) { if (verbosity > 0) { fprintf(myerr, "Error: The NSEC3 record for "); ldns_rdf_print(stdout, name->name); fprintf(myerr, " points to the wrong next hashed owner" " name\n\tshould point to "); ldns_rdf_print(myerr, next_name->name); fprintf(myerr, ", whose hashed name is "); ldns_rdf_print(myerr, next_name->hashed_name); fprintf(myerr, "\n"); } return LDNS_STATUS_ERR; } else { return LDNS_STATUS_OK; } } static bool zone_is_nsec3_optout(ldns_dnssec_zone* zone) { static int remember = -1; if (remember == -1) { remember = ldns_dnssec_zone_is_nsec3_optout(zone) ? 1 : 0; } return remember == 1; } static ldns_status verify_nsec(ldns_dnssec_zone* zone, ldns_rbnode_t *cur_node, ldns_rr_list *keys) { ldns_rbnode_t *next_node; ldns_dnssec_name *name, *next_name; ldns_status status, result; result = LDNS_STATUS_OK; name = (ldns_dnssec_name *) cur_node->data; if (name->nsec) { if (name->nsec_signatures) { status = verify_single_rr(name->nsec, name->nsec_signatures, keys); update_error(&result, status); } else { if (verbosity > 0) { fprintf(myerr, "Error: the NSEC(3) record of "); ldns_rdf_print(myerr, name->name); fprintf(myerr, " has no signatures\n"); } update_error(&result, LDNS_STATUS_ERR); } /* check whether the NSEC record points to the right name */ switch (ldns_rr_get_type(name->nsec)) { case LDNS_RR_TYPE_NSEC: /* simply try next name */ next_node = ldns_rbtree_next(cur_node); if (next_node == LDNS_RBTREE_NULL) { next_node = ldns_rbtree_first( zone->names); } next_node = ldns_dnssec_name_node_next_nonglue( next_node); if (!next_node) { next_node = ldns_dnssec_name_node_next_nonglue( ldns_rbtree_first(zone->names)); } next_name = (ldns_dnssec_name*)next_node->data; if (ldns_dname_compare(next_name->name, ldns_rr_rdf(name->nsec, 0)) != 0) { if (verbosity > 0) { fprintf(myerr, "Error: the " "NSEC record for "); ldns_rdf_print(myerr, name->name); fprintf(myerr, " points to " "the wrong " "next owner name\n"); } if (verbosity >= 4) { fprintf(myerr, "\t: "); ldns_rdf_print(myerr, ldns_rr_rdf( name->nsec, 0)); fprintf(myerr, " i.s.o. "); ldns_rdf_print(myerr, next_name->name); fprintf(myerr, ".\n"); } update_error(&result, LDNS_STATUS_ERR); } break; case LDNS_RR_TYPE_NSEC3: /* find the hashed next name in the tree */ /* this is expensive, do we need to add * support for this in the structs? * (ie. pointer to next hashed name?) */ status = verify_next_hashed_name(zone, name); update_error(&result, status); break; default: break; } } else { if (zone_is_nsec3_optout(zone) && (ldns_dnssec_name_is_glue(name) || ( ldns_dnssec_rrsets_contains_type(name->rrsets, LDNS_RR_TYPE_NS) && !ldns_dnssec_rrsets_contains_type(name->rrsets, LDNS_RR_TYPE_DS)))) { /* ok, no problem, but we need to remember to check * whether the chain does not actually point to this * name later */ } else { if (verbosity > 0) { fprintf(myerr, "Error: there is no NSEC(3) for "); ldns_rdf_print(myerr, name->name); fprintf(myerr, "\n"); } update_error(&result, LDNS_STATUS_ERR); } } return result; } static ldns_status verify_dnssec_name(ldns_rdf *zone_name, ldns_dnssec_zone* zone, ldns_rbnode_t *cur_node, ldns_rr_list *keys) { ldns_status result = LDNS_STATUS_OK; ldns_status status; ldns_dnssec_rrsets *cur_rrset; ldns_dnssec_name *name; int on_delegation_point; /* for NSEC chain checks */ name = (ldns_dnssec_name *) cur_node->data; if (verbosity >= 5) { fprintf(myout, "Checking: "); ldns_rdf_print(myout, name->name); fprintf(myout, "\n"); } if (ldns_dnssec_name_is_glue(name)) { /* glue */ cur_rrset = name->rrsets; while (cur_rrset) { if (cur_rrset->signatures) { if (verbosity > 0) { fprintf(myerr, "Error: "); ldns_rdf_print(myerr, name->name); fprintf(myerr, "\t"); print_type(myerr, cur_rrset->type); fprintf(myerr, " has signature(s)," " but is glue\n"); } result = LDNS_STATUS_ERR; } cur_rrset = cur_rrset->next; } if (name->nsec) { if (verbosity > 0) { fprintf(myerr, "Error: "); ldns_rdf_print(myerr, name->name); fprintf(myerr, " has an NSEC(3)," " but is glue\n"); } result = LDNS_STATUS_ERR; } } else { /* not glue, do real verify */ on_delegation_point = ldns_dnssec_rrsets_contains_type(name->rrsets, LDNS_RR_TYPE_NS) && !ldns_dnssec_rrsets_contains_type(name->rrsets, LDNS_RR_TYPE_SOA); cur_rrset = name->rrsets; while(cur_rrset) { /* Do not check occluded rrsets * on the delegation point */ if ((on_delegation_point && (cur_rrset->type == LDNS_RR_TYPE_NS || cur_rrset->type == LDNS_RR_TYPE_DS)) || (!on_delegation_point && cur_rrset->type != LDNS_RR_TYPE_RRSIG && cur_rrset->type != LDNS_RR_TYPE_NSEC)) { status = verify_dnssec_rrset(zone_name, name->name, cur_rrset, keys); update_error(&result, status); } cur_rrset = cur_rrset->next; } status = verify_nsec(zone, cur_node, keys); update_error(&result, status); } return result; } static void add_keys_with_matching_ds(ldns_dnssec_rrsets* from_keys, ldns_rr_list *dss, ldns_rr_list *to_keys) { size_t i; ldns_rr* ds_rr; ldns_dnssec_rrs *cur_key; for (i = 0; i < ldns_rr_list_rr_count(dss); i++) { if (ldns_rr_get_type(ds_rr = ldns_rr_list_rr(dss, i)) == LDNS_RR_TYPE_DS) { for (cur_key = from_keys->rrs; cur_key; cur_key = cur_key->next ) { if (ldns_rr_compare_ds(cur_key->rr, ds_rr)) { ldns_rr_list_push_rr(to_keys, cur_key->rr); break; } } } } } static ldns_status sigchase(ldns_resolver* res, ldns_rdf *zone_name, ldns_dnssec_rrsets *zonekeys, ldns_rr_list *keys) { ldns_dnssec_rrs* cur_key; ldns_status status; bool free_resolver = false; ldns_rdf* parent_name; ldns_rr_list* parent_keys; ldns_rr_list* ds_keys; add_keys_with_matching_ds(zonekeys, keys, keys); /* First try to authenticate the keys offline. * When do_sigchase is given validation may continue lookup up * keys online. Reporting the failure of the offline validation * should then be suppressed. */ no_nomatch_msg = do_sigchase; status = verify_dnssec_rrset(zone_name, zone_name, zonekeys, keys); no_nomatch_msg = false; /* Continue online on validation failure when the -S option was given. */ if (do_sigchase && status == LDNS_STATUS_CRYPTO_NO_MATCHING_KEYTAG_DNSKEY && ldns_dname_label_count(zone_name) > 0 ) { if (!res) { if ((status = ldns_resolver_new_frm_file(&res, NULL))){ ldns_resolver_free(res); if (verbosity > 0) { fprintf(myerr, "Could not create resolver: " "%s\n", ldns_get_errorstr_by_id(status) ); } return status; } free_resolver = true; ldns_resolver_set_dnssec(res,1); ldns_resolver_set_dnssec_cd(res, 1); } if ((parent_name = ldns_dname_left_chop(zone_name))) { /* * Use the (authenticated) keys of the parent zone ... */ parent_keys = ldns_fetch_valid_domain_keys(res, parent_name, keys, &status); ldns_rdf_deep_free(parent_name); /* * ... to validate the DS for the zone ... */ ds_keys = ldns_validate_domain_ds(res, zone_name, parent_keys); ldns_rr_list_free(parent_keys); /* * ... to use it to add the KSK to the trusted keys ... */ add_keys_with_matching_ds(zonekeys, ds_keys, keys); ldns_rr_list_free(ds_keys); /* * ... to validate all zonekeys ... */ status = verify_dnssec_rrset(zone_name, zone_name, zonekeys, keys); } else { status = LDNS_STATUS_MEM_ERR; } if (free_resolver) { ldns_resolver_deep_free(res); } } /* * ... so they can all be added to our list of trusted keys. */ if (status == LDNS_STATUS_OK) for (cur_key = zonekeys->rrs; cur_key; cur_key = cur_key->next) ldns_rr_list_push_rr(keys, cur_key->rr); return status; } static ldns_status verify_dnssec_zone(ldns_dnssec_zone *dnssec_zone, ldns_rdf *zone_name, ldns_rr_list *keys, bool apexonly, int percentage) { ldns_rbnode_t *cur_node; ldns_dnssec_rrsets *cur_key_rrset; ldns_dnssec_rrs *cur_key; ldns_status status; ldns_status result = LDNS_STATUS_OK; cur_key_rrset = ldns_dnssec_zone_find_rrset(dnssec_zone, zone_name, LDNS_RR_TYPE_DNSKEY); if (!cur_key_rrset || !cur_key_rrset->rrs) { if (verbosity > 0) { fprintf(myerr, "Error: No DNSKEY records at zone apex\n"); } result = LDNS_STATUS_ERR; } else { /* are keys given with -k to use for validation? */ if (ldns_rr_list_rr_count(keys) > 0) { if ((result = sigchase(NULL, zone_name, cur_key_rrset, keys))) goto error; } else for (cur_key = cur_key_rrset->rrs; cur_key; cur_key = cur_key->next) ldns_rr_list_push_rr(keys, cur_key->rr); cur_node = ldns_rbtree_first(dnssec_zone->names); if (cur_node == LDNS_RBTREE_NULL) { if (verbosity > 0) { fprintf(myerr, "Error: Empty zone?\n"); } result = LDNS_STATUS_ERR; } if (apexonly) { /* * In this case, only the first node in the treewalk * below should be checked. */ assert( cur_node->data == dnssec_zone->soa ); /* * Allthough the percentage option doesn't make sense * here, we set it to 100 to force the first node to * be checked. */ percentage = 100; } while (cur_node != LDNS_RBTREE_NULL) { /* should we check this one? saves calls to random. */ if (percentage == 100 || ((random() % 100) >= 100 - percentage)) { status = verify_dnssec_name(zone_name, dnssec_zone, cur_node, keys); update_error(&result, status); if (apexonly) break; } cur_node = ldns_rbtree_next(cur_node); } } error: ldns_rr_list_free(keys); return result; } int main(int argc, char **argv) { char *filename; FILE *fp; int line_nr = 0; int c; ldns_status s; ldns_dnssec_zone *dnssec_zone = NULL; ldns_status result = LDNS_STATUS_ERR; bool apexonly = false; int percentage = 100; struct tm tm; ldns_duration_type *duration; ldns_rr_list *keys = ldns_rr_list_new(); size_t nkeys = 0; check_time = ldns_time(NULL); myout = stdout; myerr = stderr; while ((c = getopt(argc, argv, "ae:hi:k:vV:p:St:")) != -1) { switch(c) { case 'a': apexonly = true; break; case 'h': printf("Usage: %s [OPTIONS] \n", argv[0]); printf("\tReads the zonefile and checks for DNSSEC " "errors.\n"); printf("\nIt checks whether NSEC(3)s are present, " "and verifies all signatures\n"); printf("It also checks the NSEC(3) chain, but it " "will error on opted-out delegations\n"); printf("\nOPTIONS:\n"); printf("\t-h\t\tshow this text\n"); printf("\t-a\t\tapex only, " "check only the zone apex\n"); printf("\t-e \tsignatures may not expire " "within this period.\n\t\t\t" "(default no period is used)\n"); printf("\t-i \tsignatures must have been " "valid at least this long.\n\t\t\t" "(default signatures should just be valid " "now)\n"); printf("\t-k \tspecify a file that contains a " "trusted DNSKEY or DS rr.\n\t\t\t" "This option may be given more than once.\n" "\t\t\tDefault is %s", LDNS_TRUST_ANCHOR_FILE); printf("\t-p [0-100]\tonly checks this percentage of " "the zone.\n\t\t\tDefaults to 100\n"); printf("\t-S\t\tchase signature(s) to a known key. " "The network may be\n\t\t\taccessed to " "validate the zone's DNSKEYs. (implies -k)\n"); printf("\t-t YYYYMMDDhhmmss | [+|-]offset\n\t\t\t" "set the validation time either by an " "absolute time\n\t\t\tvalue or as an " "offset in seconds from .\n\t\t\t" "For data that came from the network (while " "chasing),\n\t\t\tsystem time will be used " "for validating it regardless.\n"); printf("\t-v\t\tshows the version and exits\n"); printf("\t-V [0-5]\tset verbosity level (default 3)\n" ); printf("\ns are given " "in ISO 8601 duration format: " "P[n]Y[n]M[n]DT[n]H[n]M[n]S\n"); printf("\nif no file is given " "standard input is read\n"); exit(EXIT_SUCCESS); break; case 'e': case 'i': duration = ldns_duration_create_from_string(optarg); if (!duration) { if (verbosity > 0) { fprintf(myerr, " should be in ISO " "8601 duration format: " "P[n]Y[n]M[n]DT[n]H[n]M[n]S\n" ); } exit(EXIT_FAILURE); } if (c == 'e') expiration_offset = ldns_duration2time(duration); else inception_offset = ldns_duration2time(duration); break; case 'k': s = read_key_file(optarg, keys); if (s == LDNS_STATUS_FILE_ERR) { if (verbosity > 0) { fprintf(myerr, "Error opening %s: %s\n", optarg, strerror(errno)); } } if (s != LDNS_STATUS_OK) { if (verbosity > 0) { fprintf(myerr, "Could not parse key file " "%s: %s\n",optarg, ldns_get_errorstr_by_id(s)); } exit(EXIT_FAILURE); } if (ldns_rr_list_rr_count(keys) == nkeys) { if (verbosity > 0) { fprintf(myerr, "No keys found in file %s\n", optarg); } exit(EXIT_FAILURE); } nkeys = ldns_rr_list_rr_count(keys); break; case 'p': percentage = atoi(optarg); if (percentage < 0 || percentage > 100) { if (verbosity > 0) { fprintf(myerr, "percentage needs to fall " "between 0..100\n"); } exit(EXIT_FAILURE); } srandom(time(NULL) ^ getpid()); break; case 'S': do_sigchase = true; /* may chase */ break; case 't': if (strlen(optarg) == 14 && sscanf(optarg, "%4d%2d%2d%2d%2d%2d", &tm.tm_year, &tm.tm_mon, &tm.tm_mday, &tm.tm_hour, &tm.tm_min , &tm.tm_sec ) == 6) { tm.tm_year -= 1900; tm.tm_mon--; check_time = ldns_mktime_from_utc(&tm); } else { check_time += atoi(optarg); } break; case 'v': printf("verify-zone version %s (ldns version %s)\n", LDNS_VERSION, ldns_version()); exit(EXIT_SUCCESS); break; case 'V': verbosity = atoi(optarg); break; } } if (do_sigchase && nkeys == 0) { (void) read_key_file(LDNS_TRUST_ANCHOR_FILE, keys); nkeys = ldns_rr_list_rr_count(keys); if (nkeys == 0) { if (verbosity > 0) { fprintf(myerr, "Unable to chase " "signature without keys.\n"); } exit(EXIT_FAILURE); } } argc -= optind; argv += optind; if (argc == 0) { fp = stdin; } else { filename = argv[0]; fp = fopen(filename, "r"); if (!fp) { if (verbosity > 0) { fprintf(myerr, "Unable to open %s: %s\n", filename, strerror(errno)); } exit(EXIT_FAILURE); } } s = ldns_dnssec_zone_new_frm_fp_l(&dnssec_zone, fp, NULL, 0, LDNS_RR_CLASS_IN, &line_nr); if (s == LDNS_STATUS_OK) { if (!dnssec_zone->soa) { if (verbosity > 0) { fprintf(myerr, "; Error: no SOA in the zone\n"); } exit(EXIT_FAILURE); } result = ldns_dnssec_zone_mark_glue(dnssec_zone); if (result != LDNS_STATUS_OK) { if (verbosity > 0) { fprintf(myerr, "There were errors identifying the " "glue in the zone\n"); } } if (verbosity >= 5) { ldns_dnssec_zone_print(myout, dnssec_zone); } result = verify_dnssec_zone(dnssec_zone, dnssec_zone->soa->name, keys, apexonly, percentage); if (result == LDNS_STATUS_OK) { if (verbosity >= 3) { fprintf(myout, "Zone is verified and complete\n"); } } else { if (verbosity > 0) { fprintf(myerr, "There were errors in the zone\n"); } } ldns_dnssec_zone_deep_free(dnssec_zone); } else { if (verbosity > 0) { fprintf(myerr, "%s at %d\n", ldns_get_errorstr_by_id(s), line_nr); } exit(EXIT_FAILURE); } fclose(fp); exit(result); } #else int main(int argc, char **argv) { fprintf(stderr, "ldns-verify-zone needs OpenSSL support, " "which has not been compiled in\n"); return 1; } #endif /* HAVE_SSL */ ldns-1.6.17/examples/ldns-read-zone.c0000664000175100017510000001771612264060151016733 0ustar willemwillem/* * read a zone file from disk and prints it, one RR per line * * (c) NLnetLabs 2005-2008 * * See the file LICENSE for the license */ #include "config.h" #include #include #include #include #include void print_usage(const char* progname) { printf("Usage: %s [OPTIONS] \n", progname); printf("\tReads the zonefile and prints it.\n"); printf("\tThe RR count of the zone is printed to stderr.\n"); printf("\t-b include Bubble Babble encoding of DS's.\n"); printf("\t-0 zeroize timestamps and signature in RRSIG records.\n"); printf("\t-c canonicalize all rrs in the zone.\n"); printf("\t-d only show DNSSEC data from the zone\n"); printf("\t-h show this text\n"); printf("\t-n do not print the SOA record\n"); printf("\t-p prepend SOA serial with spaces so" " it takes exactly ten characters.\n"); printf("\t-s strip DNSSEC data from the zone\n"); printf("\t-S [[+|-] | YYYYMMDDxx | " " unixtime ]\n" "\t\tSet serial number to or," " when preceded by a sign,\n" "\t\toffset the existing number with " ". With YYYYMMDDxx\n" "\t\tthe serial is formatted as a datecounter" ", and with unixtime as\n" "\t\tthe number of seconds since 1-1-1970." " However, on serial\n" "\t\tnumber decrease, +1 is used in stead" ". (implies -s)\n"); printf("\t-u \n"); printf("\t\tMark for printing in unknown type format.\n"); printf("\t\tThis option may be given multiple times.\n"); printf("\t\t-u is not meant to be used together with -U.\n"); printf("\t-U \n"); printf("\t\tMark for not printing in unknown type format.\n"); printf("\t\tThis option may be given multiple times.\n"); printf( "\t\tThe first occurrence of the -U option marks all RR types for" "\n\t\tprinting in unknown type format except for the given ." "\n\t\tSubsequent -U options will clear the mark for those s" "\n\t\ttoo, so that only the given s will be printed in the" "\n\t\tpresentation format specific for those s.\n"); printf("\t\t-U is not meant to be used together with -u.\n"); printf("\t-v shows the version and exits\n"); printf("\t-z sort the zone (implies -c).\n"); printf("\nif no file is given standard input is read\n"); exit(EXIT_SUCCESS); } int main(int argc, char **argv) { char *filename; FILE *fp; ldns_zone *z; int line_nr = 0; int c; bool canonicalize = false; bool sort = false; bool strip = false; bool only_dnssec = false; bool print_soa = true; ldns_status s; size_t i; ldns_rr_list *stripped_list; ldns_rr *cur_rr; ldns_rr_type cur_rr_type; ldns_output_format_storage fmt_storage; ldns_output_format* fmt = ldns_output_format_init(&fmt_storage); ldns_soa_serial_increment_func_t soa_serial_increment_func = NULL; int soa_serial_increment_func_data = 0; while ((c = getopt(argc, argv, "0bcdhnpsu:U:vzS:")) != -1) { switch(c) { case 'b': fmt->flags |= ( LDNS_COMMENT_BUBBLEBABBLE | LDNS_COMMENT_FLAGS ); break; case '0': fmt->flags |= LDNS_FMT_ZEROIZE_RRSIGS; break; case 'c': canonicalize = true; break; case 'd': only_dnssec = true; if (strip) { fprintf(stderr, "Warning: stripping both DNSSEC and non-DNSSEC records. Output will be sparse.\n"); } break; case 'h': print_usage("ldns-read-zone"); break; case 'n': print_soa = false; break; case 'p': fmt->flags |= LDNS_FMT_PAD_SOA_SERIAL; break; case 's': strip = true; if (only_dnssec) { fprintf(stderr, "Warning: stripping both DNSSEC and non-DNSSEC records. Output will be sparse.\n"); } break; case 'u': s = ldns_output_format_set_type(fmt, ldns_get_rr_type_by_name(optarg)); if (s != LDNS_STATUS_OK) { fprintf( stderr , "Cannot set rr type %s " "in output format to " "print as unknown type: %s\n" , ldns_rr_descript( ldns_get_rr_type_by_name(optarg) )->_name , ldns_get_errorstr_by_id(s) ); exit(EXIT_FAILURE); } break; case 'U': s = ldns_output_format_clear_type(fmt, ldns_get_rr_type_by_name(optarg)); if (s != LDNS_STATUS_OK) { fprintf( stderr , "Cannot set rr type %s " "in output format to not " "print as unknown type: %s\n" , ldns_rr_descript( ldns_get_rr_type_by_name(optarg) )->_name , ldns_get_errorstr_by_id(s) ); exit(EXIT_FAILURE); } break; case 'v': printf("read zone version %s (ldns version %s)\n", LDNS_VERSION, ldns_version()); exit(EXIT_SUCCESS); break; case 'z': canonicalize = true; sort = true; break; case 'S': strip = true; if (*optarg == '+' || *optarg == '-') { soa_serial_increment_func_data = atoi(optarg); soa_serial_increment_func = ldns_soa_serial_increment_by; } else if (! strtok(optarg, "0123456789")) { soa_serial_increment_func_data = atoi(optarg); soa_serial_increment_func = ldns_soa_serial_identity; } else if (!strcasecmp(optarg, "YYYYMMDDxx")){ soa_serial_increment_func = ldns_soa_serial_datecounter; } else if (!strcasecmp(optarg, "unixtime")){ soa_serial_increment_func = ldns_soa_serial_unixtime; } else { fprintf(stderr, "-S expects a number " "optionally preceded by a " "+ or - sign to indicate an " "offset, or the text YYYYMM" "DDxx or unixtime\n"); exit(EXIT_FAILURE); } break; } } argc -= optind; argv += optind; if (argc == 0) { fp = stdin; } else { filename = argv[0]; fp = fopen(filename, "r"); if (!fp) { fprintf(stderr, "Unable to open %s: %s\n", filename, strerror(errno)); exit(EXIT_FAILURE); } } s = ldns_zone_new_frm_fp_l(&z, fp, NULL, 0, LDNS_RR_CLASS_IN, &line_nr); fclose(fp); if (s != LDNS_STATUS_OK) { fprintf(stderr, "%s at %d\n", ldns_get_errorstr_by_id(s), line_nr); exit(EXIT_FAILURE); } if (strip) { stripped_list = ldns_rr_list_new(); while ((cur_rr = ldns_rr_list_pop_rr(ldns_zone_rrs(z)))) { cur_rr_type = ldns_rr_get_type(cur_rr); if (cur_rr_type == LDNS_RR_TYPE_RRSIG || cur_rr_type == LDNS_RR_TYPE_NSEC || cur_rr_type == LDNS_RR_TYPE_NSEC3 || cur_rr_type == LDNS_RR_TYPE_NSEC3PARAM ) { ldns_rr_free(cur_rr); } else { ldns_rr_list_push_rr(stripped_list, cur_rr); } } ldns_rr_list_free(ldns_zone_rrs(z)); ldns_zone_set_rrs(z, stripped_list); } if (only_dnssec) { stripped_list = ldns_rr_list_new(); while ((cur_rr = ldns_rr_list_pop_rr(ldns_zone_rrs(z)))) { cur_rr_type = ldns_rr_get_type(cur_rr); if (cur_rr_type == LDNS_RR_TYPE_RRSIG || cur_rr_type == LDNS_RR_TYPE_NSEC || cur_rr_type == LDNS_RR_TYPE_NSEC3 || cur_rr_type == LDNS_RR_TYPE_NSEC3PARAM ) { ldns_rr_list_push_rr(stripped_list, cur_rr); } else { ldns_rr_free(cur_rr); } } ldns_rr_list_free(ldns_zone_rrs(z)); ldns_zone_set_rrs(z, stripped_list); } if (canonicalize) { ldns_rr2canonical(ldns_zone_soa(z)); for (i = 0; i < ldns_rr_list_rr_count(ldns_zone_rrs(z)); i++) { ldns_rr2canonical(ldns_rr_list_rr(ldns_zone_rrs(z), i)); } } if (sort) { ldns_zone_sort(z); } if (print_soa && ldns_zone_soa(z)) { if (soa_serial_increment_func) { ldns_rr_soa_increment_func_int( ldns_zone_soa(z) , soa_serial_increment_func , soa_serial_increment_func_data ); } ldns_rr_print_fmt(stdout, fmt, ldns_zone_soa(z)); } ldns_rr_list_print_fmt(stdout, fmt, ldns_zone_rrs(z)); ldns_zone_deep_free(z); exit(EXIT_SUCCESS); } ldns-1.6.17/examples/ldns-key2ds.c0000664000175100017510000001110412264060151016231 0ustar willemwillem/* * key2ds transforms a public key into its DS * It (currently) prints out the public key * * (c) NLnet Labs, 2005 - 2008 * See the file LICENSE for the license */ #include "config.h" #include #include static void usage(FILE *fp, char *prog) { fprintf(fp, "%s [-fn] [-1|-2] keyfile\n", prog); fprintf(fp, " Generate a DS RR from the DNSKEYS in keyfile\n"); fprintf(fp, " The following file will be created: "); fprintf(fp, "K++.ds\n"); fprintf(fp, " The base name (K++ will be printed to stdout\n"); fprintf(fp, "Options:\n"); fprintf(fp, " -f: ignore SEP flag (i.e. make DS records for any key)\n"); fprintf(fp, " -n: do not write DS records to file(s) but to stdout\n"); fprintf(fp, " (default) use similar hash to the key algorithm.\n"); fprintf(fp, " -1: use SHA1 for the DS hash\n"); fprintf(fp, " -2: use SHA256 for the DS hash\n"); #ifdef USE_GOST fprintf(fp, " -g: use GOST for the DS hash\n"); #endif #ifdef USE_ECDSA fprintf(fp, " -4: use SHA384 for the DS hash\n"); #endif } static int is_suitable_dnskey(ldns_rr *rr, int sep_only) { if (!rr || ldns_rr_get_type(rr) != LDNS_RR_TYPE_DNSKEY) { return 0; } return !sep_only || (ldns_rdf2native_int16(ldns_rr_dnskey_flags(rr)) & LDNS_KEY_SEP_KEY); } static ldns_hash suitable_hash(ldns_signing_algorithm algorithm) { switch (algorithm) { case LDNS_SIGN_RSASHA256: case LDNS_SIGN_RSASHA512: return LDNS_SHA256; case LDNS_SIGN_ECC_GOST: #ifdef USE_GOST return LDNS_HASH_GOST; #else return LDNS_SHA256; #endif #ifdef USE_ECDSA case LDNS_SIGN_ECDSAP256SHA256: return LDNS_SHA256; case LDNS_SIGN_ECDSAP384SHA384: return LDNS_SHA384; #endif default: break; } return LDNS_SHA1; } int main(int argc, char *argv[]) { FILE *keyfp, *dsfp; char *keyname; char *dsname; char *owner; ldns_rr *k, *ds; ldns_signing_algorithm alg; ldns_hash h; int similar_hash=1; char *program = argv[0]; int nofile = 0; ldns_rdf *origin = NULL; ldns_status result = LDNS_STATUS_OK; int sep_only = 1; alg = 0; h = LDNS_SHA1; argv++, argc--; while (argc && argv[0][0] == '-') { if (strcmp(argv[0], "-1") == 0) { h = LDNS_SHA1; similar_hash = 0; } if (strcmp(argv[0], "-2") == 0) { h = LDNS_SHA256; similar_hash = 0; } #ifdef USE_GOST if (strcmp(argv[0], "-g") == 0) { if(!ldns_key_EVP_load_gost_id()) { fprintf(stderr, "error: libcrypto does not provide GOST\n"); exit(EXIT_FAILURE); } h = LDNS_HASH_GOST; similar_hash = 0; } #endif #ifdef USE_ECDSA if (strcmp(argv[0], "-4") == 0) { h = LDNS_SHA384; similar_hash = 0; } #endif if (strcmp(argv[0], "-f") == 0) { sep_only = 0; } if (strcmp(argv[0], "-n") == 0) { nofile=1; } argv++, argc--; } if (argc != 1) { usage(stderr, program); exit(EXIT_FAILURE); } keyname = strdup(argv[0]); keyfp = fopen(keyname, "r"); if (!keyfp) { fprintf(stderr, "Failed to open public key file %s: %s\n", keyname, strerror(errno)); exit(EXIT_FAILURE); } while (result == LDNS_STATUS_OK) { result = ldns_rr_new_frm_fp(&k, keyfp, 0, &origin, NULL); while (result == LDNS_STATUS_SYNTAX_ORIGIN || result == LDNS_STATUS_SYNTAX_TTL || (result == LDNS_STATUS_OK && !is_suitable_dnskey(k, sep_only)) ) { if (result == LDNS_STATUS_OK) { ldns_rr_free(k); } result = ldns_rr_new_frm_fp(&k, keyfp, 0, &origin, NULL); } if (result == LDNS_STATUS_SYNTAX_EMPTY) { /* we're done */ break; } if (result != LDNS_STATUS_OK) { fprintf(stderr, "Could not read public key from file %s: %s\n", keyname, ldns_get_errorstr_by_id(result)); exit(EXIT_FAILURE); } owner = ldns_rdf2str(ldns_rr_owner(k)); alg = ldns_rdf2native_int8(ldns_rr_dnskey_algorithm(k)); if(similar_hash) h = suitable_hash(alg); ds = ldns_key_rr2ds(k, h); if (!ds) { fprintf(stderr, "Conversion to a DS RR failed\n"); ldns_rr_free(k); free(owner); exit(EXIT_FAILURE); } /* print the public key RR to .key */ dsname = LDNS_XMALLOC(char, strlen(owner) + 16); snprintf(dsname, strlen(owner) + 15, "K%s+%03u+%05u.ds", owner, alg, (unsigned int) ldns_calc_keytag(k)); if (nofile) ldns_rr_print(stdout,ds); else { dsfp = fopen(dsname, "w"); if (!dsfp) { fprintf(stderr, "Unable to open %s: %s\n", dsname, strerror(errno)); exit(EXIT_FAILURE); } else { ldns_rr_print(dsfp, ds); fclose(dsfp); fprintf(stdout, "K%s+%03u+%05u\n", owner, alg, (unsigned int) ldns_calc_keytag(k)); } } ldns_rr_free(ds); ldns_rr_free(k); free(owner); LDNS_FREE(dsname); } fclose(keyfp); free(keyname); exit(EXIT_SUCCESS); } ldns-1.6.17/examples/ldns-rrsig.c0000664000175100017510000001360412264060151016165 0ustar willemwillem/* * ldns-rrsig prints out the inception and expiration dates in a more readable * way than the normal RRSIG presentation format * * for a particulary domain * (c) NLnet Labs, 2005 - 2008 * See the file LICENSE for the license */ #include "config.h" #include static int usage(FILE *fp, char *prog) { fprintf(fp, "%s domain [type]\n", prog); fprintf(fp, " print out the inception and expiration dates\n"); fprintf(fp, " in a more human readable form\n"); fprintf(fp, " \tquery for RRSIG(), defaults to SOA\n"); return 0; } int main(int argc, char *argv[]) { ldns_resolver *res; ldns_resolver *localres; ldns_rdf *domain; ldns_pkt *p; ldns_rr_list *rrsig; ldns_rr_list *rrsig_type; ldns_rr_list *ns; ldns_rr_list *ns_ip; uint8_t i, j; ldns_rr_type t; const char * type_name; struct tm incep, expir; char incep_buf[26]; char expir_buf[26]; ldns_status s; time_t now = time(NULL); p = NULL; rrsig = NULL; rrsig_type = NULL; domain = NULL; /* option parsing */ if (argc < 2) { usage(stdout, argv[0]); exit(EXIT_FAILURE); } else { /* create a rdf from the command line arg */ domain = ldns_dname_new_frm_str(argv[1]); if (!domain) { usage(stdout, argv[0]); exit(EXIT_FAILURE); } } if (argc == 3) { /* optional type arg */ type_name = strdup(argv[2]); t = ldns_rdf2rr_type( ldns_rdf_new_frm_str(LDNS_RDF_TYPE_TYPE, type_name)); if (t == 0) { fprintf(stderr, " *** %s is not a valid RR type\n", type_name); exit(EXIT_FAILURE); } } else { t = LDNS_RR_TYPE_SOA; type_name = "SOA"; } /* create a new resolver from /etc/resolv.conf */ s = ldns_resolver_new_frm_file(&localres, NULL); if (s != LDNS_STATUS_OK) { exit(EXIT_FAILURE); } /* first get the nameserver of the domain in question */ p = ldns_resolver_query(localres, domain, LDNS_RR_TYPE_NS, LDNS_RR_CLASS_IN, LDNS_RD); if (!p) { fprintf(stderr," *** Could not find any nameserver for %s", argv[1]); ldns_resolver_deep_free(localres); exit(EXIT_FAILURE); } ns = ldns_pkt_rr_list_by_type(p, LDNS_RR_TYPE_NS, LDNS_SECTION_ANSWER); if (!ns) { fprintf(stderr," *** Could not find any nameserver for %s", argv[1]); ldns_pkt_free(p); ldns_resolver_deep_free(localres); exit(EXIT_FAILURE); } /* use our local resolver to resolv the names in the for usage in our * new resolver */ res = ldns_resolver_new(); if (!res) { ldns_pkt_free(p); ldns_resolver_deep_free(localres); ldns_rr_list_deep_free(ns); exit(EXIT_FAILURE); } for(i = 0; i < ldns_rr_list_rr_count(ns); i++) { ns_ip = ldns_get_rr_list_addr_by_name(localres, ldns_rr_ns_nsdname(ldns_rr_list_rr(ns, i)), LDNS_RR_CLASS_IN, LDNS_RD); /* add these to new resolver */ for(j = 0; j < ldns_rr_list_rr_count(ns_ip); j++) { if (ldns_resolver_push_nameserver(res, ldns_rr_a_address(ldns_rr_list_rr(ns_ip, j))) != LDNS_STATUS_OK) { printf("Error adding nameserver to resolver\n"); ldns_pkt_free(p); ldns_resolver_deep_free(res); ldns_resolver_deep_free(localres); ldns_rr_list_deep_free(ns); exit(EXIT_FAILURE); } } ldns_rr_list_deep_free(ns_ip); } /* enable DNSSEC */ ldns_resolver_set_dnssec(res, true); /* also set CD, we want EVERYTHING! */ ldns_resolver_set_dnssec_cd(res, true); /* use the resolver to send it a query for the soa * records of the domain given on the command line */ ldns_pkt_free(p); p = ldns_resolver_query(res, domain, LDNS_RR_TYPE_RRSIG, LDNS_RR_CLASS_IN, LDNS_RD); ldns_rdf_deep_free(domain); if (!p) { ldns_resolver_deep_free(localres); ldns_rr_list_deep_free(ns); exit(EXIT_FAILURE); } else { /* retrieve the RRSIG records from the answer section of that * packet */ rrsig = ldns_pkt_rr_list_by_type(p, LDNS_RR_TYPE_RRSIG, LDNS_SECTION_ANSWER); if (!rrsig) { fprintf(stderr, " *** invalid answer name %s after RRSIG query for %s\n", argv[1], argv[1]); ldns_pkt_free(p); ldns_resolver_deep_free(res); ldns_rr_list_deep_free(ns); exit(EXIT_FAILURE); } else { rrsig_type = ldns_rr_list_new(); for(i = 0; i < ldns_rr_list_rr_count(rrsig); i++) { if (ldns_rdf2rr_type( ldns_rr_rrsig_typecovered( ldns_rr_list_rr(rrsig, i))) == t) { ldns_rr_list_push_rr(rrsig_type, ldns_rr_list_rr(rrsig, i)); } } if (ldns_rr_list_rr_count(rrsig_type) == 0) { fprintf(stderr, " *** No RRSIG(%s) type found\n", type_name); ldns_resolver_deep_free(localres); ldns_resolver_deep_free(res); ldns_pkt_free(p); ldns_rr_list_deep_free(ns); ldns_rr_list_free(rrsig); ldns_rr_list_deep_free(rrsig_type); exit(EXIT_FAILURE); } for(i = 0; i < ldns_rr_list_rr_count(rrsig_type); i++) { memset(&incep, 0, sizeof(incep)); if (ldns_serial_arithmitics_gmtime_r( ldns_rdf2native_time_t( ldns_rr_rrsig_inception( ldns_rr_list_rr(rrsig_type, i))), now, &incep ) && asctime_r(&incep, incep_buf)) { incep_buf[24] = '\0'; } else { incep_buf[0] = '\0'; } memset(&expir, 0, sizeof(expir)); if (ldns_serial_arithmitics_gmtime_r( ldns_rdf2native_time_t( ldns_rr_rrsig_expiration( ldns_rr_list_rr(rrsig_type, i))), now, &expir ) && asctime_r(&expir, expir_buf)) { expir_buf[24] = '\0'; } else { expir_buf[0] = '\0'; } fprintf(stdout, "%s RRSIG(%s): %s - %s\n", argv[1], type_name, incep_buf, expir_buf); } ldns_rr_list_free(rrsig); ldns_rr_list_deep_free(rrsig_type); } } ldns_pkt_free(p); ldns_resolver_deep_free(localres); ldns_resolver_deep_free(res); ldns_rr_list_deep_free(ns); return 0; } ldns-1.6.17/examples/ldns-verify-zone.1.in0000664000175100017510000000451112264060151017634 0ustar willemwillem.TH ldns-verifyzone 1 "27 May 2008" .SH NAME ldns-verify-zone \- read a DNSSEC signed zone and verify it. .SH SYNOPSIS .B ldns-verify-zone .IR ZONEFILE .SH DESCRIPTION \fBldns-verify-zone\fR reads a DNS zone file and verifies it. RRSIG resource records are checked against the DNSKEY set at the zone apex. Each name is checked for an NSEC(3), if appropriate. .SH OPTIONS .TP \fB-h\fR Show usage and exit .TP \fB-a\fR Apex only, check only the zone apex .TP \fB-e\fR \fIperiod\fR Signatures may not expire within this period. Default no period is used. .TP \fB-i\fR \fIperiod\fR Signatures must have been valid at least this long. Default signatures should just be valid now. .TP \fB-k\fR \fIfile\fR A file that contains a trusted DNSKEY or DS rr. This option may be given more than once. Alternatively, if \fB-k\fR is not specified, and a default trust anchor (@LDNS_TRUST_ANCHOR_FILE@) exists and contains a valid DNSKEY or DS record, it will be used as the trust anchor. .TP \fB-p\fR \fI[0-100]\fR Only check this percentage of the zone. Which names to check is determined randomly. Defaults to 100. .TP \fB-S\fR Chase signature(s) to a known key. The network may be accessed to validate the zone's DNSKEYs. (implies -k) .TP \fB-t\fR \fIYYYYMMDDhhmmss | [+|-]offset\fR Set the validation time either by an absolute time value or as an offset in seconds from the current time. .TP \fB-v\fR Show the version and exit .TP \fB-V\fR \fInumber\fR Set the verbosity level (default 3): 0: Be silent 1: Print result, and any errors 2: Same as 1 for now 3: Print result, any errors, and the names that are being checked 4: Same as 3 for now 5: Print the zone after it has been read, the result, any errors, and the names that are being checked .LP \fIperiod\fRs are given in ISO 8601 duration format: .RS P[n]Y[n]M[n]DT[n]H[n]M[n]S .RE .LP If no file is given standard input is read. .SH "FILES" .TP @LDNS_TRUST_ANCHOR_FILE@ The file from which trusted keys are loaded for signature chasing, when no \fB-k\fR option is given. .SH "SEE ALSO" .LP unbound-anchor(8) .SH AUTHOR Written by the ldns team as an example for ldns usage. .SH REPORTING BUGS Report bugs to . .SH COPYRIGHT Copyright (C) 2008 NLnet Labs. This is free software. There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. ldns-1.6.17/examples/ldns-dane.1.in0000664000175100017510000001067012264060151016271 0ustar willemwillem.TH ldns-dane 1 "17 September 2012" .SH NAME ldns-dane \- verify or create TLS authentication with DANE (RFC6698) .SH SYNOPSIS .PD 0 .B ldns-dane .IR [OPTIONS] .IR verify .IR name .IR port .PP .B ldns-dane .IR [OPTIONS] .IR -t .IR tlsafile .IR verify .B ldns-dane .IR [OPTIONS] .IR name .IR port .IR create .PP [ .IR Certificate-usage [ .IR Selector [ .IR Matching-type ] ] ] .B ldns-dane .IR -h .PP .B ldns-dane .IR -v .PD 1 .SH DESCRIPTION In the first form: A TLS connection to \fIname\fR:\fIport\fR is established. The TLSA resource record(s) for \fIname\fR are used to authenticate the connection. In the second form: The TLSA record(s) are read from \fItlsafile\fR and used to authenticate the TLS service they reference. In the third form: A TLS connection to \fIname\fR:\fIport\fR is established and used to create the TLSA resource record(s) that would authenticate the connection. The parameters for TLSA rr creation are: .PD 0 .I Certificate-usage\fR: .RS .IP 0 CA constraint .IP 1 Service certificate constraint .IP 2 Trust anchor assertion .IP 3 Domain-issued certificate (default) .RE .I Selector\fR: .RS .IP 0 Full certificate (default) .IP 1 SubjectPublicKeyInfo .RE .I Matching-type\fR: .RS .IP 0 No hash used .IP 1 SHA-256 (default) .IP 2 SHA-512 .RE .PD 1 In stead of numbers the first few letters of the value may be used. Except for the hash algorithm name, where the full name must be specified. .SH OPTIONS .IP -4 TLS connect IPv4 only .IP -6 TLS connect IPv6 only .IP "-a \fIaddress\fR" Don't try to resolve \fIname\fR, but connect to \fIaddress\fR instead. This option may be given more than once. .IP -b print "\fIname\fR\. TYPE52 \\# \fIsize\fR \fIhexdata\fR" form instead of TLSA presentation format. .IP "-c \fIcertfile\fR" Do not TLS connect to \fIname\fR:\fIport\fR, but authenticate (or make TLSA records) for the certificate (chain) in \fIcertfile\fR instead. .IP -d Assume DNSSEC validity even when the TLSA records were acquired insecure or were bogus. .IP "-f \fICAfile\fR" Use CAfile to validate. @DEFAULT_CAFILE@ .IP -h Print short usage help .IP -i Interact after connecting. .IP "-k \fIkeyfile\fR" Specify a file that contains a trusted DNSKEY or DS rr. Key(s) are used when chasing signatures (i.e. \fI-S\fR is given). This option may be given more than once. Alternatively, if \fB-k\fR is not specified, and a default trust anchor (@LDNS_TRUST_ANCHOR_FILE@) exists and contains a valid DNSKEY or DS record, it will be used as the trust anchor. .IP -n Do \fBnot\fR verify server name in certificate. .IP "-o \fIoffset\fR" When creating a "Trust anchor assertion" TLSA resource record, select the \fIoffset\fRth certificate offset from the end of the validation chain. 0 means the last certificate, 1 the one but last, 2 the second but last, etc. When \fIoffset\fR is -1 (the default), the last certificate is used (like with 0) that MUST be self-signed. This can help to make sure that the intended (self signed) trust anchor is actually present in the server certificate chain (which is a DANE requirement). .IP "-p \fICApath\fR" Use certificates in the \fICApath\fR directory to validate. @DEFAULT_CAPATH@ .IP -s When creating TLSA resource records with the "CA Constraint" and the "Service Certificate Constraint" certificate usage, do not validate and assume PKIX is valid. For "CA Constraint" this means that verification should end with a self-signed certificate. .IP -S Chase signature(s) to a known key. Without this option, the local network is trusted to provide a DNSSEC resolver (i.e. AD bit is checked). .IP "-t \fItlsafile\fR" Read TLSA record(s) from \fItlsafile\fR. When \fIname\fR and \fIport\fR are also given, only TLSA records that match the \fIname\fR, \fIport\fR and \fItransport\fR are used. Otherwise the owner name of the TLSA record(s) will be used to determine \fIname\fR, \fIport\fR and \fItransport\fR. .IP -T Return exit status 2 for PKIX validated connections without (secure) TLSA records(s) .IP -u Use UDP transport instead of TCP. .IP -v Show version and exit. .SH "FILES" .TP @LDNS_TRUST_ANCHOR_FILE@ The file from which trusted keys are loaded for signature chasing, when no \fB-k\fR option is given. .SH "SEE ALSO" .LP unbound-anchor(8) .SH AUTHOR Written by the ldns team as an example for ldns usage. .SH REPORTING BUGS Report bugs to \fIldns-team@nlnetlabs.nl\fR. .SH COPYRIGHT Copyright (C) 2012 NLnet Labs. This is free software. There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. ldns-1.6.17/examples/ldns-version.c0000664000175100017510000000035212264060151016520 0ustar willemwillem/* * ldns-version shows ldns's version * * (c) NLnet Labs, 2005 - 2008 * See the file LICENSE for the license */ #include "config.h" #include int main(void) { printf("%s\n", ldns_version()); return 0; } ldns-1.6.17/examples/ldns-resolver.c0000664000175100017510000000206212264060151016674 0ustar willemwillem/* * ldns-resolver tries to create a resolver structure from /dev/urandom * this is only useful to test the library for robusteness with input data * * (c) NLnet Labs 2006 - 2008 * See the file LICENSE for the license */ #include "config.h" #include "errno.h" #include int main(int argc, char **argv) { ldns_resolver *r; int line = 1; FILE *rand; ldns_status s; if (argc != 2 || strncmp(argv[1], "-h", 3) == 0) { printf("Usage: ldns-resolver \n"); printf("Tries to create a stub resolver structure from the given file.\n"); exit(EXIT_FAILURE); } if (!(rand = fopen(argv[1], "r"))) { printf("Error opening %s: %s\n", argv[1], strerror(errno)); exit(EXIT_FAILURE); } printf("Trying to read from %s\n", argv[1]); s = ldns_resolver_new_frm_fp_l(&r, rand, &line); if (s != LDNS_STATUS_OK) { printf("Failed: %s at line %d\n", ldns_get_errorstr_by_id(s), line); exit(EXIT_FAILURE); } else { printf("Succes\n"); ldns_resolver_print(stdout, r); ldns_resolver_deep_free(r); } fclose(rand); return EXIT_SUCCESS; } ldns-1.6.17/examples/ldns-keyfetcher.c0000664000175100017510000005274512264060151017201 0ustar willemwillem/* * ldns-keyfetcher retrieves the DNSKEYS for a certain domain * It traces the authoritatives nameservers down from the root * And uses TCP, to minimize spoofing danger. * * (c) NLnet Labs, 2006 - 2008 * See the file LICENSE for the license */ #include "config.h" #include #include int verbosity = 0; /* 0=use both ip4 and ip6 (default). 1=ip4only. 2=ip6only. */ uint8_t address_family = 0; bool store_in_file = false; static void usage(FILE *fp, char *prog) { fprintf(fp, "%s domain\n", prog); fprintf(fp, " retrieve the dnskeys for a domain\n"); fprintf(fp, "Options:\n"); fprintf(fp, "-4\t\tUse IPv4 only\n"); fprintf(fp, "-6\t\tUse IPv6 only\n"); fprintf(fp, "-h\t\tShow this help\n"); fprintf(fp, "-i\t\tInsecurer mode; don't do checks, just query for the keys\n"); fprintf(fp, "-r \tUse file to read root hints from\n"); fprintf(fp, "-s\t\tDon't print the keys but store them in files\n\t\tcalled K.+.+.key\n"); fprintf(fp, "-v \tVerbosity level (0-5, not verbose-very verbose)\n"); } static ldns_rr_list * retrieve_dnskeys(ldns_resolver *local_res, ldns_rdf *name, ldns_rr_type t, ldns_rr_class c, ldns_rr_list *dns_root) { ldns_resolver *res; ldns_pkt *p; ldns_rr_list *new_nss_a; ldns_rr_list *new_nss_aaaa; ldns_rr_list *new_nss; ldns_rr_list *ns_addr; ldns_rr_list *ns_addr2; uint16_t loop_count; ldns_rdf *pop; ldns_status status; size_t i; size_t nss_i; ldns_rr_list *answer_list = NULL; ldns_rr_list *authority_list = NULL; size_t last_nameserver_count; ldns_rdf **last_nameservers; loop_count = 0; new_nss_a = NULL; new_nss_aaaa = NULL; new_nss = NULL; ns_addr = NULL; ns_addr2 = NULL; p = ldns_pkt_new(); res = ldns_resolver_new(); if (!p || !res) { fprintf(stderr, "Memory allocation failed"); return NULL; } if (verbosity >= 2) { printf("Finding dnskey data for zone: "); ldns_rdf_print(stdout, name); printf("\n\n"); } /* transfer some properties of local_res to res, * because they were given on the commandline */ ldns_resolver_set_ip6(res, ldns_resolver_ip6(local_res)); ldns_resolver_set_port(res, ldns_resolver_port(local_res)); ldns_resolver_set_debug(res, ldns_resolver_debug(local_res)); ldns_resolver_set_dnssec(res, ldns_resolver_dnssec(local_res)); ldns_resolver_set_fail(res, ldns_resolver_fail(local_res)); ldns_resolver_set_usevc(res, ldns_resolver_usevc(local_res)); ldns_resolver_set_random(res, ldns_resolver_random(local_res)); ldns_resolver_set_recursive(res, false); /* setup the root nameserver in the new resolver */ status = ldns_resolver_push_nameserver_rr_list(res, dns_root); if (status != LDNS_STATUS_OK) { fprintf(stderr, "Error setting root nameservers in resolver: %s\n", ldns_get_errorstr_by_id(status)); return NULL; } ldns_pkt_free(p); status = ldns_resolver_send(&p, res, name, t, c, 0); if (status != LDNS_STATUS_OK) { fprintf(stderr, "Error querying root servers: %s\n", ldns_get_errorstr_by_id(status)); return NULL; } if (ldns_pkt_get_rcode(p) != LDNS_RCODE_NOERROR) { printf("Error in packet:\n"); ldns_pkt_print(stdout, p); return NULL; } if (verbosity >= 4) { ldns_pkt_print(stdout, p); printf("\n\n"); } /* from now on, use TCP */ ldns_resolver_set_usevc(res, true); while(status == LDNS_STATUS_OK && ldns_pkt_reply_type(p) == LDNS_PACKET_REFERRAL) { if (verbosity >= 3) { printf("This is a delegation!\n\n"); } if (address_family == 0 || address_family == 1) { new_nss_a = ldns_pkt_rr_list_by_type(p, LDNS_RR_TYPE_A, LDNS_SECTION_ADDITIONAL); } else { new_nss_a = ldns_rr_list_new(); } if (address_family == 0 || address_family == 2) { new_nss_aaaa = ldns_pkt_rr_list_by_type(p, LDNS_RR_TYPE_AAAA, LDNS_SECTION_ADDITIONAL); } else { new_nss_aaaa = ldns_rr_list_new(); } new_nss = ldns_pkt_rr_list_by_type(p, LDNS_RR_TYPE_NS, LDNS_SECTION_AUTHORITY); /* remove the old nameserver from the resolver */ while((pop = ldns_resolver_pop_nameserver(res))) { ldns_rdf_deep_free(pop); } /* also check for new_nss emptyness */ if (!new_nss_aaaa && !new_nss_a) { /* * no nameserver found!!! * try to resolve the names we do got */ if (verbosity >= 3) { printf("Did not get address record for nameserver, doing separate query.\n"); } ns_addr = ldns_rr_list_new(); for(i = 0; (size_t) i < ldns_rr_list_rr_count(new_nss); i++) { /* get the name of the nameserver */ pop = ldns_rr_rdf(ldns_rr_list_rr(new_nss, i), 0); if (!pop) { break; } /* retrieve it's addresses */ ns_addr2 = ldns_get_rr_list_addr_by_name(local_res, pop, c, 0); if (!ldns_rr_list_cat(ns_addr, ns_addr2)) { fprintf(stderr, "Internal error adding nameserver address.\n"); exit(EXIT_FAILURE); } ldns_rr_list_free(ns_addr2); } if (ns_addr) { if (ldns_resolver_push_nameserver_rr_list(res, ns_addr) != LDNS_STATUS_OK) { fprintf(stderr, "Error adding new nameservers"); ldns_pkt_free(p); return NULL; } ldns_rr_list_deep_free(ns_addr); } else { ldns_rr_list_print(stdout, ns_addr); fprintf(stderr, "Could not find the nameserver ip addr; abort"); ldns_pkt_free(p); return NULL; } } /* normally, the first working ns is used, but we need all now, so do it one by one * if the answer is null, take it from the next resolver * if the answer is not, compare it to that of the next resolver * error if different, continue if the same * if answer list null and no resolvers left die. */ ldns_rr_list_deep_free(answer_list); ldns_rr_list_deep_free(authority_list); answer_list = NULL; authority_list = NULL; for (nss_i = 0; nss_i < ldns_rr_list_rr_count(new_nss_aaaa); nss_i++) { while((pop = ldns_resolver_pop_nameserver(res))) { ldns_rdf_deep_free(pop); } status = ldns_resolver_push_nameserver(res, ldns_rr_rdf(ldns_rr_list_rr(new_nss_aaaa, nss_i), 0)); if (status != LDNS_STATUS_OK) { fprintf(stderr, "Error adding nameserver to resolver: %s\n", ldns_get_errorstr_by_id(status)); } if (verbosity >= 1) { fprintf(stdout, "Querying nameserver: "); ldns_rdf_print(stdout, ldns_rr_owner(ldns_rr_list_rr(new_nss_aaaa, nss_i))); fprintf(stdout, " ("); ldns_rdf_print(stdout, ldns_rr_rdf(ldns_rr_list_rr(new_nss_aaaa, nss_i), 0)); fprintf(stdout, ")\n"); } status = ldns_resolver_push_nameserver(res, ldns_rr_rdf(ldns_rr_list_rr(new_nss_aaaa, nss_i), 0)); if (status != LDNS_STATUS_OK) { fprintf(stderr, "Error adding nameserver to resolver: %s\n", ldns_get_errorstr_by_id(status)); } ldns_pkt_free(p); status = ldns_resolver_send(&p, res, name, t, c, 0); if (status == LDNS_STATUS_OK && p) { if (ldns_pkt_get_rcode(p) != LDNS_RCODE_NOERROR) { printf("Error in packet:\n"); ldns_pkt_print(stdout, p); return NULL; } if (verbosity >= 4) { ldns_pkt_print(stdout, p); printf("\n\n"); } if (answer_list) { if (verbosity >= 2) { printf("Comparing answer list of answer to previous\n\n"); } ldns_rr_list_sort(ldns_pkt_answer(p)); ldns_rr_list_sort(answer_list); if (ldns_rr_list_compare(answer_list, ldns_pkt_answer(p)) != 0) { fprintf(stderr, "ERROR: different answer answer from nameserver\n"); fprintf(stderr, "\nI had (from previous servers):\n"); ldns_rr_list_print(stderr, answer_list); fprintf(stderr, "\nI received (from nameserver at "); ldns_rdf_print(stderr, ldns_resolver_nameservers(res)[0]); fprintf(stderr, "):\n"); ldns_rr_list_print(stderr, ldns_pkt_answer(p)); exit(EXIT_FAILURE); } } else { answer_list = ldns_rr_list_clone(ldns_pkt_answer(p)); ldns_rr_list_sort(answer_list); if (verbosity >= 2) { printf("First answer list for this set, nothing to compare with\n\n"); } } if (authority_list) { if (verbosity >= 2) { printf("Comparing authority list of answer to previous\n\n"); } ldns_rr_list_sort(ldns_pkt_authority(p)); ldns_rr_list_sort(authority_list); if (ldns_rr_list_compare(authority_list, ldns_pkt_authority(p)) != 0) { fprintf(stderr, "ERROR: different authority answer from nameserver\n"); fprintf(stderr, "\nI had (from previous servers):\n"); ldns_rr_list_print(stderr, authority_list); fprintf(stderr, "\nI received (from nameserver at "); ldns_rdf_print(stderr, ldns_resolver_nameservers(res)[0]); fprintf(stderr, "):\n"); ldns_rr_list_print(stderr, ldns_pkt_authority(p)); exit(EXIT_FAILURE); } } else { authority_list = ldns_rr_list_clone(ldns_pkt_authority(p)); ldns_rr_list_sort(authority_list); if (verbosity >= 2) { printf("First authority list for this set, nothing to compare with\n\n"); } if (verbosity >= 3) { printf("NS RRset:\n"); ldns_rr_list_print(stdout, authority_list); printf("\n"); } } } } ldns_rr_list_deep_free(answer_list); ldns_rr_list_deep_free(authority_list); answer_list = NULL; authority_list = NULL; for (nss_i = 0; nss_i < ldns_rr_list_rr_count(new_nss_a); nss_i++) { while((pop = ldns_resolver_pop_nameserver(res))) {ldns_rdf_deep_free(pop); } if (verbosity >= 1) { fprintf(stdout, "Querying nameserver: "); ldns_rdf_print(stdout, ldns_rr_owner(ldns_rr_list_rr(new_nss_a, nss_i))); fprintf(stdout, " ("); ldns_rdf_print(stdout, ldns_rr_rdf(ldns_rr_list_rr(new_nss_a, nss_i), 0)); fprintf(stdout, ")\n"); } status = ldns_resolver_push_nameserver(res, ldns_rr_rdf(ldns_rr_list_rr(new_nss_a, nss_i), 0)); if (status != LDNS_STATUS_OK) { fprintf(stderr, "Error adding nameserver to resolver: %s\n", ldns_get_errorstr_by_id(status)); } ldns_pkt_free(p); status = ldns_resolver_send(&p, res, name, t, c, 0); if (status == LDNS_STATUS_OK) { if (ldns_pkt_get_rcode(p) != LDNS_RCODE_NOERROR) { printf("Error in packet:\n"); ldns_pkt_print(stdout, p); return NULL; } if (verbosity >= 4) { ldns_pkt_print(stdout, p); printf("\n\n"); } if (answer_list) { if (verbosity >= 2) { printf("Comparing answer list of answer to previous\n\n"); } ldns_rr_list_sort(ldns_pkt_answer(p)); ldns_rr_list_sort(answer_list); if (ldns_rr_list_compare(answer_list, ldns_pkt_answer(p)) != 0) { fprintf(stderr, "ERROR: different answer answer from nameserver\n"); fprintf(stderr, "\nI had (from previous servers):\n"); ldns_rr_list_print(stderr, answer_list); fprintf(stderr, "\nI received (from nameserver at "); ldns_rdf_print(stderr, ldns_resolver_nameservers(res)[0]); fprintf(stderr, "):\n"); ldns_rr_list_print(stderr, ldns_pkt_answer(p)); exit(EXIT_FAILURE); } } else { if (verbosity >= 2) { printf("First answer list for this set, nothing to compare with\n\n"); } answer_list = ldns_rr_list_clone(ldns_pkt_answer(p)); ldns_rr_list_sort(answer_list); } if (authority_list) { if (verbosity >= 2) { printf("Comparing authority list of answer to previous\n\n"); } ldns_rr_list_sort(ldns_pkt_authority(p)); ldns_rr_list_sort(authority_list); if (ldns_rr_list_compare(authority_list, ldns_pkt_authority(p)) != 0) { fprintf(stderr, "ERROR: different authority answer from nameserver\n"); fprintf(stderr, "\nI had (from previous servers):\n"); ldns_rr_list_print(stderr, authority_list); fprintf(stderr, "\nI received (from nameserver at "); ldns_rdf_print(stderr, ldns_resolver_nameservers(res)[0]); fprintf(stderr, "):\n"); ldns_rr_list_print(stderr, ldns_pkt_authority(p)); exit(EXIT_FAILURE); } } else { if (verbosity >= 2) { printf("First authority list for this set, nothing to compare with\n\n"); } authority_list = ldns_rr_list_clone(ldns_pkt_authority(p)); ldns_rr_list_sort(authority_list); if (verbosity >= 3) { printf("NS RRset:\n"); ldns_rr_list_print(stdout, authority_list); printf("\n"); } } } } ldns_rr_list_deep_free(authority_list); authority_list = NULL; if (loop_count++ > 20) { /* unlikely that we are doing something usefull */ fprintf(stderr, "Looks like we are looping"); ldns_pkt_free(p); return NULL; } ldns_pkt_free(p); if (verbosity >= 3) { fprintf(stdout, "This level ok. Continuing to next.\n\n"); } status = ldns_resolver_send(&p, res, name, t, c, 0); if (status != LDNS_STATUS_OK) { fprintf(stderr, "Error querying root servers: %s\n", ldns_get_errorstr_by_id(status)); return NULL; } if (ldns_pkt_get_rcode(p) != LDNS_RCODE_NOERROR) { printf("Error in packet:\n"); ldns_pkt_print(stdout, p); return NULL; } if (verbosity >= 4) { ldns_pkt_print(stdout, p); printf("\n\n"); } ldns_rr_list_deep_free(new_nss_aaaa); ldns_rr_list_deep_free(new_nss_a); ldns_rr_list_deep_free(new_nss); new_nss_aaaa = NULL; new_nss_a = NULL; ns_addr = NULL; } ldns_rr_list_deep_free(answer_list); answer_list = NULL; /* clone the nameserver list, we are going to handle them one by one */ last_nameserver_count = 0; last_nameservers = LDNS_XMALLOC(ldns_rdf *, ldns_resolver_nameserver_count(res)); pop = NULL; while((pop = ldns_resolver_pop_nameserver(res))) { last_nameservers[last_nameserver_count] = pop; last_nameserver_count++; } for (nss_i = 0; nss_i < last_nameserver_count; nss_i++) { /* remove previous nameserver */ while((pop = ldns_resolver_pop_nameserver(res))) { ldns_rdf_deep_free(pop); } if (verbosity >= 1) { printf("Querying nameserver: "); ldns_rdf_print(stdout, last_nameservers[nss_i]); printf("\n"); } status = ldns_resolver_push_nameserver(res, last_nameservers[nss_i]); if (status != LDNS_STATUS_OK) { fprintf(stderr, "Error adding nameserver to resolver: %s\n", ldns_get_errorstr_by_id(status)); } ldns_pkt_free(p); status = ldns_resolver_send(&p, res, name, t, c, 0); if (!p) { fprintf(stderr, "no packet received\n"); return NULL; } if (status == LDNS_STATUS_RES_NO_NS) { fprintf(stderr, "Error: nameserver at "); ldns_rdf_print(stderr, last_nameservers[nss_i]); fprintf(stderr, " not responding. Unable to check RRset here, aborting.\n"); return NULL; } if (ldns_pkt_get_rcode(p) != LDNS_RCODE_NOERROR) { printf("Error in packet:\n"); ldns_pkt_print(stdout, p); return NULL; } if (answer_list) { if (verbosity >= 2) { printf("1Comparing answer rr list of answer to previous\n"); } ldns_rr_list_sort(ldns_pkt_answer(p)); ldns_rr_list_sort(answer_list); if (ldns_rr_list_compare(answer_list, ldns_pkt_answer(p)) != 0) { printf("ERROR: different answer section in response from nameserver\n"); fprintf(stderr, "\nI had:\n"); ldns_rr_list_print(stderr, answer_list); fprintf(stderr, "\nI received (from nameserver at "); ldns_rdf_print(stderr, ldns_resolver_nameservers(res)[0]); fprintf(stderr, "):\n"); ldns_rr_list_print(stderr, ldns_pkt_answer(p)); exit(EXIT_FAILURE); } } else { if (verbosity >= 2) { printf("First answer rr list for this set, nothing to compare with\n"); } answer_list = ldns_rr_list_clone(ldns_pkt_answer(p)); if (verbosity >= 3) { printf("DNSKEY RRset:\n"); ldns_rr_list_print(stdout, answer_list); } } } for (nss_i = 0; nss_i < last_nameserver_count; nss_i++) { ldns_rdf_deep_free(last_nameservers[nss_i]); } LDNS_FREE(last_nameservers); ldns_resolver_deep_free(res); ldns_pkt_free(p); return answer_list; } /* * The file with the given path should contain a list of NS RRs * for the root zone and A records for those NS RRs. * Read them, check them, and append the a records to the rr list given. */ ldns_rr_list * read_root_hints(const char *filename) { FILE *fp = NULL; int line_nr = 0; ldns_zone *z; ldns_status status; ldns_rr_list *addresses = NULL; ldns_rr *rr; size_t i; fp = fopen(filename, "r"); if (!fp) { fprintf(stderr, "Unable to open %s for reading: %s\n", filename, strerror(errno)); return NULL; } status = ldns_zone_new_frm_fp_l(&z, fp, NULL, 0, 0, &line_nr); fclose(fp); if (status != LDNS_STATUS_OK) { fprintf(stderr, "Error reading root hints file: %s\n", ldns_get_errorstr_by_id(status)); return NULL; } else { addresses = ldns_rr_list_new(); for (i = 0; i < ldns_rr_list_rr_count(ldns_zone_rrs(z)); i++) { rr = ldns_rr_list_rr(ldns_zone_rrs(z), i); if ((address_family == 0 || address_family == 1) && ldns_rr_get_type(rr) == LDNS_RR_TYPE_A ) { ldns_rr_list_push_rr(addresses, ldns_rr_clone(rr)); } if ((address_family == 0 || address_family == 2) && ldns_rr_get_type(rr) == LDNS_RR_TYPE_AAAA) { ldns_rr_list_push_rr(addresses, ldns_rr_clone(rr)); } } ldns_zone_deep_free(z); return addresses; } } int main(int argc, char *argv[]) { ldns_resolver *res; ldns_rdf *ns; ldns_rdf *domain; ldns_rr_list *l = NULL; ldns_rr_list *dns_root = NULL; const char *root_file = "/etc/named.root"; ldns_status status; int i; char *domain_str; char *outputfile_str; ldns_buffer *outputfile_buffer; FILE *outputfile; ldns_rr *k; bool insecure = false; ldns_pkt *pkt; domain = NULL; res = NULL; if (argc < 2) { usage(stdout, argv[0]); exit(EXIT_FAILURE); } else { for (i = 1; i < argc; i++) { if (strncmp("-4", argv[i], 3) == 0) { if (address_family != 0) { fprintf(stderr, "Options -4 and -6 cannot be specified at the same time\n"); exit(EXIT_FAILURE); } address_family = 1; } else if (strncmp("-6", argv[i], 3) == 0) { if (address_family != 0) { fprintf(stderr, "Options -4 and -6 cannot be specified at the same time\n"); exit(EXIT_FAILURE); } address_family = 2; } else if (strncmp("-h", argv[i], 3) == 0) { usage(stdout, argv[0]); exit(EXIT_SUCCESS); } else if (strncmp("-i", argv[i], 2) == 0) { insecure = true; } else if (strncmp("-r", argv[i], 2) == 0) { if (strlen(argv[i]) > 2) { root_file = argv[i]+2; } else if (i+1 >= argc) { usage(stdout, argv[0]); exit(EXIT_FAILURE); } else { root_file = argv[i+1]; i++; } } else if (strncmp("-s", argv[i], 3) == 0) { store_in_file = true; } else if (strncmp("-v", argv[i], 2) == 0) { if (strlen(argv[i]) > 2) { verbosity = atoi(argv[i]+2); } else if (i+1 > argc) { usage(stdout, argv[0]); exit(EXIT_FAILURE); } else { verbosity = atoi(argv[i+1]); i++; } } else { /* create a rdf from the command line arg */ if (domain) { fprintf(stdout, "You can only specify one domain at a time\n"); exit(EXIT_FAILURE); } domain = ldns_dname_new_frm_str(argv[i]); } } if (!domain) { usage(stdout, argv[0]); exit(EXIT_FAILURE); } } dns_root = read_root_hints(root_file); if (!dns_root) { fprintf(stderr, "cannot read the root hints file\n"); exit(EXIT_FAILURE); } /* create a new resolver from /etc/resolv.conf */ status = ldns_resolver_new_frm_file(&res, NULL); if (status != LDNS_STATUS_OK) { fprintf(stderr, "Warning: Unable to create stub resolver from /etc/resolv.conf:\n"); fprintf(stderr, "%s\n", ldns_get_errorstr_by_id(status)); fprintf(stderr, "defaulting to nameserver at 127.0.0.1 for separate nameserver name lookups\n"); do { res = ldns_resolver_new(); if (res) { ns = ldns_rdf_new_frm_str(LDNS_RDF_TYPE_A, "127.0.0.1"); if (ns) { status = ldns_resolver_push_nameserver( res, ns); if (status == LDNS_STATUS_OK) { break; } ldns_rdf_deep_free(ns); } ldns_resolver_free(res); } fprintf(stderr, "Unable to create stub resolver: %s\n", ldns_get_errorstr_by_id(status)); exit(EXIT_FAILURE); } while (false); ldns_rdf_deep_free(ns); } ldns_resolver_set_ip6(res, address_family); if (insecure) { pkt = ldns_resolver_query(res, domain, LDNS_RR_TYPE_DNSKEY, LDNS_RR_CLASS_IN, LDNS_RD); if (pkt) { l = ldns_pkt_rr_list_by_type(pkt, LDNS_RR_TYPE_DNSKEY, LDNS_SECTION_ANY_NOQUESTION); } } else { l = retrieve_dnskeys(res, domain, LDNS_RR_TYPE_DNSKEY, LDNS_RR_CLASS_IN, dns_root); } /* separator for result data and verbosity data */ if (verbosity > 0) { fprintf(stdout, "; ---------------------------\n"); fprintf(stdout, "; Got the following keys:\n"); } if (l) { if (store_in_file) { /* create filename: * K.+.+.key */ for (i = 0; (size_t) i < ldns_rr_list_rr_count(l); i++) { k = ldns_rr_list_rr(l, (size_t) i); outputfile_buffer = ldns_buffer_new(300); domain_str = ldns_rdf2str(ldns_rr_owner(k)); ldns_buffer_printf(outputfile_buffer, "K%s+%03u+%05u.key", domain_str, ldns_rdf2native_int8(ldns_rr_rdf(k, 2)), (unsigned int) ldns_calc_keytag(k)); outputfile_str = ldns_buffer_export(outputfile_buffer); if (verbosity >= 1) { fprintf(stdout, "Writing key to file %s\n", outputfile_str); } outputfile = fopen(outputfile_str, "w"); if (!outputfile) { fprintf(stderr, "Error writing key to file %s: %s\n", outputfile_str, strerror(errno)); } else { ldns_rr_print(outputfile, k); fclose(outputfile); } LDNS_FREE(domain_str); LDNS_FREE(outputfile_str); LDNS_FREE(outputfile_buffer); } } else { ldns_rr_list_print(stdout, l); } } else { fprintf(stderr, "no answer packet received, stub resolver config:\n"); ldns_resolver_print(stderr, res); } printf("\n"); ldns_rdf_deep_free(domain); ldns_resolver_deep_free(res); ldns_rr_list_deep_free(l); ldns_rr_list_deep_free(dns_root); return EXIT_SUCCESS; } ldns-1.6.17/examples/ldns-nsec3-hash.10000664000175100017510000000152612264060151016711 0ustar willemwillem.TH ldns-nsec3-hash.c 1 "10 Dec 2008" .SH NAME ldns-nsec3-hash \- print out the NSEC3 hash for a domain name .SH SYNOPSIS .B ldns-nsec3-hash .IR .SH DESCRIPTION \fBldns-nsec3-hash\fR is used to print out the NSEC3 hash for the given domain name. .SH OPTIONS .TP \fB-a\fR \fInumber\fR Use the given algorithm number for the hash calculation. Defaults to 1 (SHA-1). .TP \fB-s\fR \fIsalt\fR Use the given salt for the hash calculation. Salt value should be in hexadecimal format. .TP \fB-t\fR \fIcount\fR Use count iterations for the hash calculation. .SH AUTHOR Written by the ldns team as an example for ldns usage. .SH REPORTING BUGS Report bugs to . .SH COPYRIGHT Copyright (C) 2008 NLnet Labs. This is free software. There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. ldns-1.6.17/examples/ldns-gen-zone.10000664000175100017510000000601212264060151016472 0ustar willemwillem.TH ldns-gen-zone 1 "10 June 2010" .SH NAME ldns-gen-zone \- read a zonefile and print it while adding DS records and extra RR's .SH SYNOPSIS .B ldns-gen-zone .IR ZONEFILE .SH DESCRIPTION \fBldns-gen-zone\fR reads a DNS zone file and prints it. It is build for speed, not for a nice formatting. The output has one resource record per line and no pretty-printing makeup. DNSSEC data (NSEC, NSEC3, RRSIG or DNSKEY) is not stripped. You may want to use \fBldns-read-zone\fR for that. Existing DS records are also not stripped. The idea is to use this tool for quickly generating a representative artificial zonefile from a real zonefile, to use it for testing purposes. .SH OPTIONS .TP \fB-a NUM\fR Adds NUM extra artificial NS RRSets to the output. The RRSets owner names start with 'xn--' in an attempt to ensure uniqueness (nl.-zone does not support IDN's - and this tool was written with that knowledge in mind). An artificial NS RRSet has two NS records; ns1.example.com and ns2.example.com. .TP \fB-p NUM\fR Add NUM% of DS RRSets to the NS RRSets (anywhere between 1-4 DS records per RRSet). .TP \fB-o ORIGIN\fR Sets an $ORIGIN, which can be handy if the one in the zonefile is set to '@' for example. If there is an $ORIGIN in the zonefile, this option will silently be ignored. .TP \fB-s\fR This is the recommended way of processing large zones that are already sorted and canonicalized (ie lowercase). It skips the sorting and canonicalization step that is required for properly grouping RRSets together (before adding any DS records to them. Skipping this step will speed things up. It is not recommended to use this option if you want to add DS records to unsorted, non-canonicalized zones. .TP \fB-h\fR Show usage and exit. .TP \fB-v\fR Show version and exit. .SH EXAMPLES .TP \fBldns-gen-zone -a 100000 -p 10 -s ./zonefile.txt\fR Read a zonefile, add 100.000 artificial NS RRSets and 10% of DS records, print it to standard output. Don't sort (will only work well if the input zonefile is already sorted and canonicalized). .TP \fBldns-gen-zone -p 10 -s -o nl zonefile.txt | named-compilezone -s relative -i none -o zonefile_10.txt nl /dev/stdin\fR This creates a nicely formatted zone file with the help of \fBnamed-compilezone\fR. It adds 10% DS records to the .nl zone, reformats it and saves it as \fBzonefile_10.txt\fR. .SH AUTHOR Initially written by Marco Davids, several modifications added by Miek Gieben, both from SIDN. .SH REPORTING BUGS Report bugs to . .SH BUGS Only undiscovered ones. .SH CAVEATS May require a machine with a considerable amount of memory for large zone files. Fake DS records hashes are generated as digest type SHA-256 (RFC4509). Be aware not to change the DIGESTTYPE #define in the source code in anything else but 2 if you want to keep things realistic. Despite a number of efforts, this program is still not the fastest in the world. .SH COPYRIGHT Copyright (C) 2010 SIDN. This is free software. There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. ldns-1.6.17/examples/ldns-notify.c0000664000175100017510000002003612264060151016344 0ustar willemwillem/* * ldns-notify.c - ldns-notify(8) * * Copyright (c) 2001-2008, NLnet Labs, All right reserved * * See LICENSE for the license * * send a notify packet to a server */ #include "config.h" /* ldns */ #include #ifdef HAVE_NETDB_H #include #endif #include static int verbose = 1; static int max_num_retry = 15; /* times to try */ static void usage(void) { fprintf(stderr, "usage: ldns-notify [other options] -z zone \n"); fprintf(stderr, "Ldns notify utility\n\n"); fprintf(stderr, " Supported options:\n"); fprintf(stderr, "\t-z zone\t\tThe zone\n"); fprintf(stderr, "\t-s version\tSOA version number to include\n"); fprintf(stderr, "\t-y key:data\tTSIG sign the query\n"); fprintf(stderr, "\t-p port\t\tport to use to send to\n"); fprintf(stderr, "\t-v\t\tPrint version information\n"); fprintf(stderr, "\t-d\t\tPrint verbose debug information\n"); fprintf(stderr, "\t-r num\t\tmax number of retries (%d)\n", max_num_retry); fprintf(stderr, "\t-h\t\tPrint this help information\n\n"); fprintf(stderr, "Report bugs to \n"); exit(1); } static void version(void) { fprintf(stderr, "%s version %s\n", PACKAGE_NAME, PACKAGE_VERSION); fprintf(stderr, "Written by NLnet Labs.\n\n"); fprintf(stderr, "Copyright (C) 2001-2008 NLnet Labs. This is free software.\n" "There is NO warranty; not even for MERCHANTABILITY or FITNESS\n" "FOR A PARTICULAR PURPOSE.\n"); exit(0); } static void notify_host(int s, struct addrinfo* res, uint8_t* wire, size_t wiresize, const char* addrstr) { int timeout_retry = 5; /* seconds */ int num_retry = max_num_retry; #ifndef S_SPLINT_S fd_set rfds; #endif struct timeval tv; int retval = 0; ssize_t received = 0; int got_ack = 0; socklen_t addrlen = 0; uint8_t replybuf[2048]; ldns_status status; ldns_pkt* pkt = NULL; while(!got_ack) { /* send it */ if(sendto(s, (void*)wire, wiresize, 0, res->ai_addr, res->ai_addrlen) == -1) { printf("warning: send to %s failed: %s\n", addrstr, strerror(errno)); #ifndef USE_WINSOCK close(s); #else closesocket(s); #endif return; } /* wait for ACK packet */ #ifndef S_SPLINT_S FD_ZERO(&rfds); FD_SET(s, &rfds); tv.tv_sec = timeout_retry; /* seconds */ #endif tv.tv_usec = 0; /* microseconds */ retval = select(s + 1, &rfds, NULL, NULL, &tv); if (retval == -1) { printf("error waiting for reply from %s: %s\n", addrstr, strerror(errno)); #ifndef USE_WINSOCK close(s); #else closesocket(s); #endif return; } if(retval == 0) { num_retry--; if(num_retry == 0) { printf("error: failed to send notify to %s.\n", addrstr); exit(1); } printf("timeout (%d s) expired, retry notify to %s.\n", timeout_retry, addrstr); } if (retval == 1) { got_ack = 1; } } /* got reply */ addrlen = res->ai_addrlen; received = recvfrom(s, (void*)replybuf, sizeof(replybuf), 0, res->ai_addr, &addrlen); res->ai_addrlen = addrlen; #ifndef USE_WINSOCK close(s); #else closesocket(s); #endif if (received == -1) { printf("recv %s failed: %s\n", addrstr, strerror(errno)); return; } /* check reply */ status = ldns_wire2pkt(&pkt, replybuf, (size_t)received); if(status != LDNS_STATUS_OK) { ssize_t i; printf("Could not parse reply packet: %s\n", ldns_get_errorstr_by_id(status)); if (verbose > 1) { printf("hexdump of reply: "); for(i=0; i 1) { printf("hexdump of reply: "); for(i=0; i 1) { printf("Hexdump of notify packet:\n"); for(i=0; i<(int)wiresize; i++) printf("%02x", (unsigned)wire[i]); printf("\n"); } for(i=0; iai_next) { int s = socket(res->ai_family, res->ai_socktype, res->ai_protocol); if(s == -1) continue; /* send the notify */ notify_host(s, res, wire, wiresize, argv[i]); } freeaddrinfo(res0); } ldns_pkt_free(notify); free(wire); return 0; } ldns-1.6.17/examples/ldns-rrsig.10000664000175100017510000000156112264060151016102 0ustar willemwillem.TH ldns-rrsig 1 "27 Apr 2005" .SH NAME ldns-rrsig \- print out the inception and expiration dates in human readable form .SH SYNOPSIS .B ldns-rrsig .IR domain [ .IR type ] .SH DESCRIPTION \fBldns-rrsig\fR is used to print the expiration and inception date of a RRSIG. The first argument is a domain name. \fBldns-rrsig\fR will query the authoritative servers for that domain to get a list of RRSIGs. It will then print out the inception and experiration dates for the RRSIG covering the SOA record. .PP If the second argument \fBtype\fR is given the RRSIG covering that type will be shown. .SH AUTHOR Written by the ldns team as an example for ldns usage. .SH REPORTING BUGS Report bugs to . .SH COPYRIGHT Copyright (C) 2005 NLnet Labs. This is free software. There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. ldns-1.6.17/examples/Makefile.in0000664000175100017510000001506612264060151016006 0ustar willemwillem# Standard installation pathnames # See the file LICENSE for the license SHELL = @SHELL@ VERSION = @PACKAGE_VERSION@ basesrcdir = $(shell basename `pwd`) srcdir = @srcdir@ prefix = @prefix@ exec_prefix = @exec_prefix@ bindir = @bindir@ mandir = @mandir@ libtool = @libtool@ datarootdir = @datarootdir@ CC = @CC@ CFLAGS = -I. -I${srcdir} @CFLAGS@ CPPFLAGS = @CPPFLAGS@ LDFLAGS = @LDFLAGS@ LIBNSL_LIBS = @LIBNSL_LIBS@ LIBSSL_CPPFLAGS = @LIBSSL_CPPFLAGS@ LIBSSL_LDFLAGS = @LIBSSL_LDFLAGS@ LIBSSL_LIBS = @LIBSSL_LIBS@ LIBSSL_SSL_LIBS = @LIBSSL_SSL_LIBS@ LIBS = @LIBS@ RUNTIME_PATH = @RUNTIME_PATH@ LDNSDIR = @LDNSDIR@ INSTALL = $(srcdir)/../install-sh COMPILE = $(CC) $(CPPFLAGS) $(LIBSSL_CPPFLAGS) $(CFLAGS) LINK = $(libtool) --tag=CC --quiet --mode=link $(CC) $(CFLAGS) $(LDFLAGS) $(LIBS) $(RUNTIME_PATH) LINK_STATIC = $(libtool) --tag=CC --quiet --mode=link $(CC) $(CFLAGS) -static $(LDFLAGS) $(LIBS) $(RUNTIME_PATH) LINT = splint LINTFLAGS=+quiet -weak -warnposix -unrecog -Din_addr_t=uint32_t -Du_int=unsigned -Du_char=uint8_t -preproc -Drlimit=rlimit64 -D__gnuc_va_list=va_list #-Dglob64=glob -Dglobfree64=globfree # compat with openssl linux edition. LINTFLAGS+="-DBN_ULONG=unsigned long" -Dkrb5_int32=int "-Dkrb5_ui_4=unsigned int" -DPQ_64BIT=uint64_t -DRC4_INT=unsigned -fixedformalarray -D"ENGINE=unsigned" -D"RSA=unsigned" -D"DSA=unsigned" -D"EVP_PKEY=unsigned" -D"EVP_MD=unsigned" -D"SSL=unsigned" -D"SSL_CTX=unsigned" -D"X509=unsigned" -D"RC4_KEY=unsigned" -D"EVP_MD_CTX=unsigned" # compat with NetBSD ifeq "$(shell uname)" "NetBSD" LINTFLAGS+="-D__RENAME(x)=" -D_NETINET_IN_H_ endif # compat with OpenBSD LINTFLAGS+="-Dsigset_t=long" # FreeBSD8 LINTFLAGS+="-D__uint16_t=uint16_t" LINTFLAGS+=-D__signed__=signed "-D__packed=" "-D__aligned(x)=" # Ubuntu 11.04 LINTFLAGS+="-D__u16=struct __u16" "-D__u32=struct __u32" "-D__u64=struct __u64" HEADER = config.h MAIN_SOURCES = ldns-read-zone.c \ ldns-mx.c \ ldns-chaos.c \ ldns-update.c \ ldns-keygen.c \ ldns-key2ds.c \ ldns-version.c \ ldns-rrsig.c \ ldns-walk.c \ ldns-zsplit.c \ ldns-zcat.c \ ldns-dpa.c \ ldns-resolver.c \ ldns-test-edns.c \ ldns-keyfetcher.c \ ldns-notify.c \ ldns-testns.c \ ldns-compare-zones.c \ ldns-gen-zone.c \ ldnsd.c MAIN_SSL_SOURCES = ldns-signzone.c \ ldns-verify-zone.c \ ldns-revoke.c \ ldns-nsec3-hash.c \ ldns-dane.c OTHER_SOURCES = ldns-testpkts.c PROGRAMS=$(MAIN_SOURCES:.c=) SSL_PROGRAMS=$(MAIN_SSL_SOURCES:.c=) .PHONY: all clean realclean all-static .SECONDARY: $(MAIN_SOURCES:.c=.o) $(OTHER_SOURCES:.c=.o) $(MAIN_SSL_SOURCES:.c=.o) all: $(addsuffix .prg,$(PROGRAMS)) $(addsuffix .prg-ssl,$(SSL_PROGRAMS)) all-static: $(addsuffix .stc,$(PROGRAMS)) $(addsuffix .stc-ssl,$(SSL_PROGRAMS)) %.o: $(srcdir)/%.c $(COMPILE) -o $@ -c $< # ldns-testns uses more sources. ldns-testns.o: $(srcdir)/ldns-testns.c $(srcdir)/ldns-testpkts.c $(srcdir)/ldns-testpkts.h ldns-testns.prg: ldns-testpkts.o ldns-testns.stc: ldns-testpkts.o ldnsd.prg: ldnsd.o @if test ! -f $(@:.prg=) -o $< -nt $(@:.prg=); then \ echo $(LINK) $(LIBNSL_LIBS) -o $(@:.prg=) $^ ; \ $(LINK) $(LIBNSL_LIBS) -o $(@:.prg=) $^ ; \ fi ldnsd.stc: ldnsd.o @if test ! -f $@ -o $< -nt $@; then \ echo $(LINK_STATIC) $(LIBNSL_LDFLAGS) -o $@ $^ ; \ $(LINK_STATIC) $(LIBNSL_LDFLAGS) -o $@ $^ ; \ fi ldns-dane.prg-ssl: ldns-dane.o @if test ! -f $(@:.prg-ssl=) -o $< -nt $(@:.prg-ssl=); then \ echo $(LINK) $(LIBNSL_LIBS) $(LIBSSL_LDFLAGS) $(LIBSSL_SSL_LIBS) -o $(@:.prg-ssl=) $^ ; \ $(LINK) $(LIBNSL_LIBS) $(LIBSSL_LDFLAGS) $(LIBSSL_SSL_LIBS) -o $(@:.prg-ssl=) $^ ; \ fi ldns-dane.stc-ssl: ldns-dane.o @if test ! -f $@ -o $< -nt $@; then \ echo $(LINK_STATIC) $(LIBNSL_LIBS) $(LIBSSL_LDFLAGS) $(LIBSSL_SSL_LIBS) -o $@ $^ ; \ $(LINK_STATIC) $(LIBNSL_LIBS) $(LIBSSL_LDFLAGS) $(LIBSSL_SSL_LIBS) -o $@ $^ ; \ fi %.prg-ssl: %.o @if test ! -f $(@:.prg-ssl=) -o $< -nt $(@:.prg-ssl=); then \ echo $(LINK) $(LIBNSL_LIBS) $(LIBSSL_LDFLAGS) $(LIBSSL_LIBS) -o $(@:.prg-ssl=) $^ ; \ $(LINK) $(LIBNSL_LIBS) $(LIBSSL_LDFLAGS) $(LIBSSL_LIBS) -o $(@:.prg-ssl=) $^ ; \ fi %.stc-ssl: %.o @if test ! -f $@ -o $< -nt $@; then \ echo $(LINK_STATIC) $(LIBNSL_LIBS) $(LIBSSL_LDFLAGS) $(LIBSSL_LIBS) -o $@ $^ ; \ $(LINK_STATIC) $(LIBNSL_LIBS) $(LIBSSL_LDFLAGS) $(LIBSSL_LIBS) -o $@ $^ ; \ fi %.prg: %.o @if test ! -f $(@:.prg=) -o $< -nt $(@:.prg=); then \ echo $(LINK) -o $(@:.prg=) $^ ; \ $(LINK) -o $(@:.prg=) $^ ; \ fi %.stc: %.o @if test ! -f $@ -o $< -nt $@; then \ echo $(LINK_STATIC) -o $@ $^ ; \ $(LINK_STATIC) -o $@ $^ ; \ fi lint: for i in $(MAIN_SOURCES) $(OTHER_SOURCES); do \ $(LINT) $(LINTFLAGS) -I. -I$(srcdir) $(srcdir)/$$i $(CPPFLAGS); \ if [ $$? -ne 0 ] ; then exit 1 ; fi ; \ done clean: rm -f *.o *.lo rm -rf .libs rm -f $(PROGRAMS) $(SSL_PROGRAMS) rm -f $(addsuffix .stc,$(PROGRAMS)) $(addsuffix .stc-ssl,$(SSL_PROGRAMS)) realclean: clean rm -rf autom4te.cache/ rm -f config.log config.status aclocal.m4 config.h.in configure rm -f config.h ldns-dane.1 ldns-verify-zone.1 Makefile confclean: clean rm -rf config.log config.status rm -f config.h ldns-dane.1 ldns-verify-zone.1 Makefile install: $(PROGRAMS) $(SSL_PROGRAMS) $(INSTALL) -d -m 755 $(DESTDIR)$(bindir) $(INSTALL) -d -m 755 $(DESTDIR)$(mandir) $(INSTALL) -d -m 755 $(DESTDIR)$(mandir)/man1 for i in $(PROGRAMS) $(SSL_PROGRAMS); do \ $(libtool) --tag=CC --mode=install ${INSTALL} -c $$i $(DESTDIR)$(bindir) ; \ if test -f $$i.1 ; \ then $(INSTALL) -c -m 644 $$i.1 $(DESTDIR)$(mandir)/man1/$$i.1 ; \ else $(INSTALL) -c -m 644 $(srcdir)/$$i.1 $(DESTDIR)$(mandir)/man1/$$i.1 ; \ fi ; \ done exit 0 install-static: all-static $(INSTALL) -d -m 755 $(DESTDIR)$(bindir) $(INSTALL) -d -m 755 $(DESTDIR)$(mandir) $(INSTALL) -d -m 755 $(DESTDIR)$(mandir)/man1 for i in $(PROGRAMS); do \ $(libtool) --tag=CC --mode=install ${INSTALL} -c $$i.stc $(DESTDIR)$(bindir) ; \ if test -f $$i.1 ; \ then $(INSTALL) -c -m 644 $$i.1 $(DESTDIR)$(mandir)/man1/$$i.1 ; \ else $(INSTALL) -c -m 644 $(srcdir)/$$i.1 $(DESTDIR)$(mandir)/man1/$$i.1 ; \ fi ; \ done for i in $(SSL_PROGRAMS); do \ $(libtool) --tag=CC --mode=install ${INSTALL} -c $$i.stc-ssl $(DESTDIR)$(bindir) ; \ if test -f $$i.1 ; \ then $(INSTALL) -c -m 644 $$i.1 $(DESTDIR)$(mandir)/man1/$$i.1 ; \ else $(INSTALL) -c -m 644 $(srcdir)/$$i.1 $(DESTDIR)$(mandir)/man1/$$i.1 ; \ fi ; \ done exit 0 uninstall: for i in $(PROGRAMS) $(SSL_PROGRAMS); do \ rm -f $(DESTDIR)$(bindir)/$$i ; \ rm -f $(DESTDIR)$(mandir)/man1/$$i.1 ; \ done exit 0 rmdir -p $(DESTDIR)$(bindir) rmdir -p $(DESTDIR)$(mandir) ldns-1.6.17/examples/ldnsd.10000664000175100017510000000115212264060151015116 0ustar willemwillem.TH ldnsd 1 "27 Apr 2005" .SH NAME ldnsd \- simple daemon example code .SH SYNOPSIS .B ldnsd .IR port .IR zone .IR zonefile .SH DESCRIPTION \fBldnsd\fR is a simple daemon that answers queries for a zone. This is NOT a full-fledged authoritative nameserver! .SH OPTIONS \fBldnsd\fR takes a port, zone and zonefile as arguments. .SH AUTHOR Written by the ldns team as an example for ldns usage. .SH REPORTING BUGS Report bugs to . .SH COPYRIGHT Copyright (C) 2005 NLnet Labs. This is free software. There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. ldns-1.6.17/examples/ldns-zsplit.c0000664000175100017510000001500712264060151016363 0ustar willemwillem/* * read a zone from disk and split it up: * * zone: SOA a b c d e f g h i j k l * becomes: * zone1: SOA a b c d e f * zone2: SOA f g h i k l * * ldns-catzone removes the last name and put * the zone back together. * * This way you can incremental sign a zone * * See the file LICENSE for the license */ #include "config.h" #include #include #define DEFAULT_SPLIT 1000 #define FILE_SIZE 255 #define SPLIT_MAX 999 #define NO_SPLIT 0 #define INTENT_TO_SPLIT 1 #define SPLIT_NOW 2 static void usage(FILE *f, char *progname) { fprintf(f, "Usage: %s [OPTIONS] [keys]\n", progname); fprintf(f, " Cut a zone file into pieces, each part is put in a file\n"); fprintf(f, " named: '.NNN'. Where NNN is a integer ranging 000 to 999.\n"); fprintf(f, " If key files are given they are inserted in each part.\n"); fprintf(f, " The original SOA is also included in each part, making them correct DNS\n"); fprintf(f, " (mini) zones.\n"); fprintf(f, " This utility can be used to parallel sign a large zone.\n"); fprintf(f, " To make it work the original zone needs to be canonical ordered.\n"); fprintf(f, "\nOPTIONS:\n"); fprintf(f, " -n NUMBER\tsplit after this many RRs\n"); fprintf(f, " -o ORIGIN\tuse this as initial origin, for zones starting with @\n"); fprintf(f, " -z\t\tsort the zone prior to splitting. The current ldns zone\n"); fprintf(f, " \t\timplementation makes this unuseable for large zones.\n"); fprintf(f, " -v\t\tshow version number and exit\n"); } /* key the keys from the cmd line */ static ldns_rr_list * open_keyfiles(char **files, uint16_t filec) { uint16_t i; ldns_rr_list *pubkeys; ldns_rr *k; FILE *kfp; pubkeys = ldns_rr_list_new(); for (i = 0; i < filec; i++) { if (!(kfp = fopen(files[i], "r"))) { fprintf(stderr, "Error opening key file %s: %s\n", files[i], strerror(errno)); return NULL; } if (ldns_rr_new_frm_fp(&k, kfp, NULL, NULL, NULL) != LDNS_STATUS_OK) { fprintf(stderr, "Error parsing the key file %s: %s\n", files[i], strerror(errno)); ldns_rr_list_deep_free(pubkeys); return NULL; } fclose(kfp); ldns_rr_list_push_rr(pubkeys, k); } return pubkeys; } /* open a new zone file with the correct suffix */ static FILE * open_newfile(char *basename, ldns_zone *z, size_t counter, ldns_rr_list *keys) { char filename[FILE_SIZE]; FILE *fp; if (counter > SPLIT_MAX) { fprintf(stderr, "Maximum split count reached %u\n", (unsigned int) counter); return NULL; } snprintf(filename, FILE_SIZE, "%s.%03u", basename, (unsigned int) counter); if (!(fp = fopen(filename, "w"))) { fprintf(stderr, "Cannot open zone %s: %s\n", filename, strerror(errno)); return NULL; } else { fprintf(stderr, "%s\n", filename); } ldns_rr_print(fp, ldns_zone_soa(z)); if (keys) { ldns_rr_list_print(fp, keys); } return fp; } int main(int argc, char **argv) { char *progname; FILE *fp; ldns_zone *z; ldns_rr_list *zrrs; ldns_rdf *lastname; int c; int line_nr; size_t split; size_t i; int splitting; int compare; size_t file_counter; ldns_rdf *origin; ldns_rdf *current_rdf; ldns_rr *current_rr; ldns_rr_list *last_rrset; ldns_rr_list *pubkeys; bool sort; ldns_status s; progname = strdup(argv[0]); split = 0; splitting = NO_SPLIT; file_counter = 0; lastname = NULL; origin = NULL; last_rrset = ldns_rr_list_new(); sort = false; while ((c = getopt(argc, argv, "n:o:zv")) != -1) { switch(c) { case 'n': split = (size_t)atoi(optarg); if (split == 0) { fprintf(stderr, "-n want a integer\n"); exit(EXIT_FAILURE); } break; case 'o': origin = ldns_dname_new_frm_str(strdup(optarg)); if (!origin) { fprintf(stderr, "Cannot convert the origin %s to a domainname\n", optarg); exit(EXIT_FAILURE); } break; case 'v': printf("zone file splitter version %s (ldns version %s)\n", LDNS_VERSION, ldns_version()); exit(EXIT_SUCCESS); break; case 'z': sort = true; break; default: fprintf(stderr, "Unrecognized option\n"); usage(stdout, progname); exit(EXIT_FAILURE); } } if (split == 0) { split = DEFAULT_SPLIT; } argc -= optind; argv += optind; if (argc < 1) { usage(stdout, progname); exit(EXIT_FAILURE); } if (!(fp = fopen(argv[0], "r"))) { fprintf(stderr, "Unable to open %s: %s\n", argv[0], strerror(errno)); exit(EXIT_FAILURE); } /* get the keys */ pubkeys = open_keyfiles(argv + 1, (uint16_t) argc - 1); /* suck in the entire zone ... */ if (!origin) { origin = ldns_dname_new_frm_str("."); } s = ldns_zone_new_frm_fp_l(&z, fp, origin, 0, LDNS_RR_CLASS_IN, &line_nr); fclose(fp); if (s != LDNS_STATUS_OK) { fprintf(stderr, "Zone file %s could not be parsed correctly: %s at line %d\n", argv[0], ldns_get_errorstr_by_id(s), line_nr); exit(EXIT_FAILURE); } /* these kind of things can kill you... */ if (sort) { ldns_zone_sort(z); } zrrs = ldns_zone_rrs(z); if (ldns_rr_list_rr_count(zrrs) / split > SPLIT_MAX) { fprintf(stderr, "The zone is too large for the used -n value: %u\n", (unsigned int) split); exit(EXIT_FAILURE); } /* Setup */ if (!(fp = open_newfile(argv[0], z, file_counter, pubkeys))) { exit(EXIT_FAILURE); } for(i = 0; i < ldns_rr_list_rr_count(zrrs); i++) { current_rr = ldns_rr_list_rr(zrrs, i); current_rdf = ldns_rr_owner(current_rr); compare = ldns_dname_compare(current_rdf, lastname); if (compare == 0) { ldns_rr_list_push_rr(last_rrset, current_rr); } if (i > 0 && (i % split) == 0) { splitting = INTENT_TO_SPLIT; } if (splitting == INTENT_TO_SPLIT) { if (compare != 0) { splitting = SPLIT_NOW; } } if (splitting == SPLIT_NOW) { fclose(fp); lastname = NULL; splitting = NO_SPLIT; file_counter++; if (!(fp = open_newfile(argv[0], z, file_counter, pubkeys))) { exit(EXIT_FAILURE); } /* insert the last RRset in the new file */ ldns_rr_list_print(fp, last_rrset); /* print the current rr */ ldns_rr_print(fp, current_rr); /* remove them */ ldns_rr_list_free(last_rrset); last_rrset = ldns_rr_list_new(); /* add the current RR */ ldns_rr_list_push_rr(last_rrset, current_rr); continue; } if (splitting == NO_SPLIT || splitting == INTENT_TO_SPLIT) { ldns_rr_print(fp, current_rr); } if (compare != 0) { /* remove them and then add the current one */ ldns_rr_list_free(last_rrset); last_rrset = ldns_rr_list_new(); ldns_rr_list_push_rr(last_rrset, current_rr); } lastname = current_rdf; } fclose(fp); exit(EXIT_SUCCESS); } ldns-1.6.17/examples/ldns-nsec3-hash.c0000664000175100017510000000606712264060151017000 0ustar willemwillem/* * ldns-signzone signs a zone file * * (c) NLnet Labs, 2005 - 2008 * See the file LICENSE for the license */ #include "config.h" #include #include #include #include #include #include #ifdef HAVE_SSL #include #include #endif /* HAVE_SSL */ #define MAX_FILENAME_LEN 250 int verbosity = 1; static void usage(FILE *fp, const char *prog) { fprintf(fp, "%s [OPTIONS] \n", prog); fprintf(fp, " prints the NSEC3 hash of the given domain name\n"); fprintf(fp, "-a [algorithm] hashing algorithm\n"); fprintf(fp, "-t [number] number of hash iterations\n"); fprintf(fp, "-s [string] salt\n"); } int main(int argc, char *argv[]) { ldns_rdf *dname, *hashed_dname; uint8_t nsec3_algorithm = 1; size_t nsec3_iterations_cmd = 1; uint16_t nsec3_iterations = 1; uint8_t nsec3_salt_length = 0; uint8_t *nsec3_salt = NULL; char *prog = strdup(argv[0]); int c; while ((c = getopt(argc, argv, "a:s:t:")) != -1) { switch (c) { case 'a': nsec3_algorithm = (uint8_t) atoi(optarg); break; case 's': if (strlen(optarg) % 2 != 0) { fprintf(stderr, "Salt value is not valid hex data, not a multiple of 2 characters\n"); exit(EXIT_FAILURE); } if (strlen(optarg) > 512) { fprintf(stderr, "Salt too long\n"); exit(EXIT_FAILURE); } nsec3_salt_length = (uint8_t) (strlen(optarg) / 2); nsec3_salt = LDNS_XMALLOC(uint8_t, nsec3_salt_length); for (c = 0; c < (int) strlen(optarg); c += 2) { if (isxdigit((int) optarg[c]) && isxdigit((int) optarg[c+1])) { nsec3_salt[c/2] = (uint8_t) ldns_hexdigit_to_int(optarg[c]) * 16 + ldns_hexdigit_to_int(optarg[c+1]); } else { fprintf(stderr, "Salt value is not valid hex data.\n"); exit(EXIT_FAILURE); } } break; case 't': nsec3_iterations_cmd = (size_t) atol(optarg); if (nsec3_iterations_cmd > LDNS_NSEC3_MAX_ITERATIONS) { fprintf(stderr, "Iterations count can not exceed %u, quitting\n", LDNS_NSEC3_MAX_ITERATIONS); exit(EXIT_FAILURE); } nsec3_iterations = (uint16_t) nsec3_iterations_cmd; break; default: usage(stderr, prog); exit(EXIT_SUCCESS); } } argc -= optind; argv += optind; if (argc < 1) { printf("Error: not enough arguments\n"); usage(stdout, prog); exit(EXIT_FAILURE); } else { dname = ldns_dname_new_frm_str(argv[0]); if (!dname) { fprintf(stderr, "Error: unable to parse domain name\n"); return EXIT_FAILURE; } hashed_dname = ldns_nsec3_hash_name(dname, nsec3_algorithm, nsec3_iterations, nsec3_salt_length, nsec3_salt); if (!hashed_dname) { fprintf(stderr, "Error creating NSEC3 hash\n"); return EXIT_FAILURE; } ldns_rdf_print(stdout, hashed_dname); printf("\n"); ldns_rdf_deep_free(dname); ldns_rdf_deep_free(hashed_dname); } if (nsec3_salt) { free(nsec3_salt); } free(prog); return EXIT_SUCCESS; } ldns-1.6.17/examples/ldns-test-edns.10000664000175100017510000000311012264060151016652 0ustar willemwillem.TH ldns-test-edns 1 "14 Dec 2010" .SH NAME ldns-test-edns \- test if dns cache supports EDNS and DNSSEC. .SH SYNOPSIS .B ldns-test-edns [ .IR -i ] { .IR ip } .SH DESCRIPTION \fBldns-test-edns\fR tests a DNS cache and checks if it supports EDNS0 and DNSSEC types so that it can be used as a dnssec-enabled DNS cache. It sends two queries to the cache, one for the root key and one for a DS record. These must succeed, the answer must have EDNS, that type and signatures. .PP If the IP address is good for DNSSEC, it is printed with 'OK'. Otherwise short description is given of the failure. If OK is given, the cache should be good to use as a cache for a local configured DNSSEC validator. .PP The tool assumes the root is signed and Sweden is signed. Also, the queries are sent with the CD flag, the tool does not check that the results are validated, but that they \fBcan\fR be validated. .SH OPTIONS \fB-i\fR option enables a mode where the working IP addresses are printed after another, with no other explanations, and if none work or no IP addresses are on the input, 'off' is printed. .PP \fBldns-test-edns\fR takes one or more IP addresses, it checks them in turn. IPv4 and IPv6 addresses can be given. The exit value is for the last checked IP address: 0 is OK, 1 is failure, 2 is some sort of network failure. .SH AUTHOR Written by the ldns team as an example for ldns usage. .SH REPORTING BUGS Report bugs to . .SH COPYRIGHT Copyright (C) 2010 NLnet Labs. This is free software. There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. ldns-1.6.17/examples/config.h.in0000664000175100017510000002144312264060166015766 0ustar willemwillem/* config.h.in. Generated from configure.ac by autoheader. */ /* Define to 1 if you have the header file. */ #undef HAVE_ARPA_INET_H /* Define to 1 if you have the header file. */ #undef HAVE_ASSERT_H /* Define to 1 if you have the header file. */ #undef HAVE_CTYPE_H /* Is a CAFILE given at configure time */ #undef HAVE_DANE_CA_FILE /* Is a CAPATH given at configure time */ #undef HAVE_DANE_CA_PATH /* Define to 1 if you have the declaration of `in6addr_any', and to 0 if you don't. */ #undef HAVE_DECL_IN6ADDR_ANY /* Define to 1 if you have the declaration of `NID_secp384r1', and to 0 if you don't. */ #undef HAVE_DECL_NID_SECP384R1 /* Define to 1 if you have the declaration of `NID_X9_62_prime256v1', and to 0 if you don't. */ #undef HAVE_DECL_NID_X9_62_PRIME256V1 /* Define to 1 if you have the `fork' function. */ #undef HAVE_FORK /* Whether getaddrinfo is available */ #undef HAVE_GETADDRINFO /* Define to 1 if you have the header file. */ #undef HAVE_GETOPT_H /* If you have HMAC_CTX_init */ #undef HAVE_HMAC_CTX_INIT /* Define to 1 if you have the header file. */ #undef HAVE_INTTYPES_H /* Define to 1 if you have the `isblank' function. */ #undef HAVE_ISBLANK /* Define to 1 if you have the `ldns' library (-lldns). */ #undef HAVE_LIBLDNS /* Define to 1 if you have the `pcap' library (-lpcap). */ #undef HAVE_LIBPCAP /* Define to 1 if you have the header file. */ #undef HAVE_MEMORY_H /* Define to 1 if you have the header file. */ #undef HAVE_NETDB_H /* Define to 1 if you have the header file. */ #undef HAVE_NETINET_IF_ETHER_H /* Define to 1 if you have the header file. */ #undef HAVE_NETINET_IGMP_H /* Define to 1 if you have the header file. */ #undef HAVE_NETINET_IN_H /* Define to 1 if you have the header file. */ #undef HAVE_NETINET_IN_SYSTM_H /* Define to 1 if you have the header file. */ #undef HAVE_NETINET_IP6_H /* Define to 1 if you have the header file. */ #undef HAVE_NETINET_IP_H /* Define to 1 if you have the header file. */ #undef HAVE_NETINET_UDP_H /* Define to 1 if you have the header file. */ #undef HAVE_NET_IF_H /* Define to 1 if you have the header file. */ #undef HAVE_OPENSSL_ERR_H /* Define to 1 if you have the header file. */ #undef HAVE_OPENSSL_RAND_H /* Define to 1 if you have the header file. */ #undef HAVE_OPENSSL_SSL_H /* Define to 1 if you have the header file. */ #undef HAVE_PCAP_H /* Define to 1 if you have the `random' function. */ #undef HAVE_RANDOM /* Define to 1 if you have the `sleep' function. */ #undef HAVE_SLEEP /* Define to 1 if you have the `srandom' function. */ #undef HAVE_SRANDOM /* Define if you have the SSL libraries installed. */ #undef HAVE_SSL /* Define to 1 if you have the header file. */ #undef HAVE_STDINT_H /* Define to 1 if you have the header file. */ #undef HAVE_STDIO_H /* Define to 1 if you have the header file. */ #undef HAVE_STDLIB_H /* Define to 1 if you have the header file. */ #undef HAVE_STRINGS_H /* Define to 1 if you have the header file. */ #undef HAVE_STRING_H /* Define to 1 if you have the header file. */ #undef HAVE_SYS_MOUNT_H /* Define to 1 if you have the header file. */ #undef HAVE_SYS_PARAM_H /* Define to 1 if you have the header file. */ #undef HAVE_SYS_SELECT_H /* Define to 1 if you have the header file. */ #undef HAVE_SYS_SOCKET_H /* Define to 1 if you have the header file. */ #undef HAVE_SYS_STAT_H /* Define to 1 if you have the header file. */ #undef HAVE_SYS_TIME_H /* Define to 1 if you have the header file. */ #undef HAVE_SYS_TYPES_H /* Define to 1 if you have the header file. */ #undef HAVE_TIME_H /* Define to 1 if you have the header file. */ #undef HAVE_UNISTD_H /* Define to 1 if you have the `vfork' function. */ #undef HAVE_VFORK /* Define to 1 if you have the header file. */ #undef HAVE_VFORK_H /* Define to 1 if you have the header file. */ #undef HAVE_WINSOCK2_H /* Define to 1 if `fork' works. */ #undef HAVE_WORKING_FORK /* Define to 1 if `vfork' works. */ #undef HAVE_WORKING_VFORK /* Define to 1 if you have the header file. */ #undef HAVE_WS2TCPIP_H /* Is a CAFILE given at configure time */ #undef LDNS_DANE_CA_FILE /* Is a CAPATH given at configure time */ #undef LDNS_DANE_CA_PATH /* Default trust anchor file */ #undef LDNS_TRUST_ANCHOR_FILE /* Define to the address where bug reports for this package should be sent. */ #undef PACKAGE_BUGREPORT /* Define to the full name of this package. */ #undef PACKAGE_NAME /* Define to the full name and version of this package. */ #undef PACKAGE_STRING /* Define to the one symbol short name of this package. */ #undef PACKAGE_TARNAME /* Define to the home page for this package. */ #undef PACKAGE_URL /* Define to the version of this package. */ #undef PACKAGE_VERSION /* Define to 1 if you have the ANSI C header files. */ #undef STDC_HEADERS /* Define this to enable DANE support. */ #undef USE_DANE /* Define this to enable ECDSA support. */ #undef USE_ECDSA /* Define this to enable GOST support. */ #undef USE_GOST /* Define this to enable SHA256 and SHA512 support. */ #undef USE_SHA2 /* Enable extensions on AIX 3, Interix. */ #ifndef _ALL_SOURCE # undef _ALL_SOURCE #endif /* Enable GNU extensions on systems that have them. */ #ifndef _GNU_SOURCE # undef _GNU_SOURCE #endif /* Enable threading extensions on Solaris. */ #ifndef _POSIX_PTHREAD_SEMANTICS # undef _POSIX_PTHREAD_SEMANTICS #endif /* Enable extensions on HP NonStop. */ #ifndef _TANDEM_SOURCE # undef _TANDEM_SOURCE #endif /* Enable general extensions on Solaris. */ #ifndef __EXTENSIONS__ # undef __EXTENSIONS__ #endif /* the version of the windows API enabled */ #undef WINVER /* Define to 1 if on MINIX. */ #undef _MINIX /* Define to 2 if the system does not provide POSIX.1 features except with this defined. */ #undef _POSIX_1_SOURCE /* Define to 1 if you need to in order for `stat' and other things to work. */ #undef _POSIX_SOURCE /* in_addr_t */ #undef in_addr_t /* in_port_t */ #undef in_port_t /* Define to `__inline__' or `__inline' if that's what the C compiler calls it, or to nothing if 'inline' is not supported under any name. */ #ifndef __cplusplus #undef inline #endif /* Define to `short' if does not define. */ #undef int16_t /* Define to `int' if does not define. */ #undef int32_t /* Define to `long long' if does not define. */ #undef int64_t /* Define to `char' if does not define. */ #undef int8_t /* Define to `int' if does not define. */ #undef pid_t /* Define to `unsigned int' if does not define. */ #undef size_t /* Define to 'int' if not defined */ #undef socklen_t /* Define to `int' if does not define. */ #undef ssize_t /* Define to `unsigned short' if does not define. */ #undef uint16_t /* Define to `unsigned int' if does not define. */ #undef uint32_t /* Define to `unsigned long long' if does not define. */ #undef uint64_t /* Define to `unsigned char' if does not define. */ #undef uint8_t /* Define as `fork' if `vfork' does not work. */ #undef vfork #include #include #include #include #if STDC_HEADERS #include #include #endif #ifdef HAVE_STDINT_H #include #endif #ifdef HAVE_SYS_SOCKET_H #include #endif #ifdef HAVE_NETINET_IN_H #include #endif #ifdef HAVE_ARPA_INET_H #include #endif #ifdef HAVE_NETINET_UDP_H #include #endif #ifdef HAVE_TIME_H #include #endif #ifdef HAVE_PCAP_H #include #endif #ifdef HAVE_NETINET_IN_SYSTM_H #include #endif #ifdef HAVE_NETINET_IP_H #include #endif #ifdef HAVE_NET_IF_H #include #endif #ifdef HAVE_NETINET_IF_ETHER_H #include #endif #ifdef HAVE_WINSOCK2_H #define USE_WINSOCK 1 #include #endif #ifdef HAVE_WS2TCPIP_H #include #endif #ifndef HAVE_GETADDRINFO #include #endif #ifndef HAVE_RANDOM /* random can be replaced by rand for ldnsexamples */ #define random rand #endif #ifndef HAVE_SRANDOM /* srandom can be replaced by srand for ldnsexamples */ #define srandom srand #endif extern char *optarg; extern int optind, opterr; #ifndef EXIT_FAILURE #define EXIT_FAILURE 1 #endif #ifndef EXIT_SUCCESS #define EXIT_SUCCESS 0 #endif #ifdef S_SPLINT_S #define FD_ZERO(a) /* a */ #define FD_SET(a,b) /* a, b */ #endif ldns-1.6.17/examples/ldns-testns.c0000664000175100017510000003362412264060151016363 0ustar willemwillem/* * ldns-testns. Light-weight DNS daemon, gives canned replies. * * Tiny dns server, that responds with specially crafted replies * to requests. For testing dns software. * * (c) NLnet Labs, 2005 - 2008 * See the file LICENSE for the license */ /* * This program is a debugging aid. It can is not efficient, especially * with a long config file, but it can give any reply to any query. * This can help the developer pre-script replies for queries. * * It listens to IP4 UDP and TCP by default. * You can specify a packet RR by RR with header flags to return. * * Missing features: * - matching content different from reply content. * - find way to adjust mangled packets? */ /* The data file format is as follows: ; comment. ; a number of entries, these are processed first to last. ; a line based format. $ORIGIN origin $TTL default_ttl ENTRY_BEGIN ; first give MATCH lines, that say what queries are matched ; by this entry. ; 'opcode' makes the query match the opcode from the reply ; if you leave it out, any opcode matches this entry. ; 'qtype' makes the query match the qtype from the reply ; 'qname' makes the query match the qname from the reply ; 'serial=1023' makes the query match if ixfr serial is 1023. MATCH [opcode] [qtype] [qname] [serial=] MATCH [UDP|TCP] MATCH ... ; Then the REPLY header is specified. REPLY opcode, rcode or flags. (opcode) QUERY IQUERY STATUS NOTIFY UPDATE (rcode) NOERROR FORMERR SERVFAIL NXDOMAIN NOTIMPL YXDOMAIN YXRRSET NXRRSET NOTAUTH NOTZONE (flags) QR AA TC RD CD RA AD REPLY ... ; any additional actions to do. ; 'copy_id' copies the ID from the query to the answer. ADJUST copy_id ; 'sleep=10' sleeps for 10 seconds before giving the answer (TCP is open) ADJUST [sleep=] ; sleep before giving any reply ADJUST [packet_sleep=] ; sleep before this packet in sequence SECTION QUESTION ; the RRcount is determined automatically. SECTION ANSWER SECTION AUTHORITY SECTION ADDITIONAL EXTRA_PACKET ; follow with SECTION, REPLY for more packets. HEX_ANSWER_BEGIN ; follow with hex data ; this replaces any answer packet constructed ; with the SECTION keywords (only SECTION QUERY ; is used to match queries). If the data cannot ; be parsed, ADJUST rules for the answer packet ; are ignored HEX_ANSWER_END ENTRY_END */ /* Example data file: $ORIGIN nlnetlabs.nl $TTL 3600 ENTRY_BEGIN MATCH qname REPLY NOERROR ADJUST copy_id SECTION QUESTION www.nlnetlabs.nl. IN A SECTION ANSWER www.nlnetlabs.nl. IN A 195.169.215.155 SECTION AUTHORITY nlnetlabs.nl. IN NS www.nlnetlabs.nl. ENTRY_END ENTRY_BEGIN MATCH qname REPLY NOERROR ADJUST copy_id SECTION QUESTION www2.nlnetlabs.nl. IN A HEX_ANSWER_BEGIN ; 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 ;-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 00 bf 81 80 00 01 00 01 00 02 00 02 03 77 77 77 0b 6b 61 6e ; 1- 20 61 72 69 65 70 69 65 74 03 63 6f 6d 00 00 01 00 01 03 77 77 ; 21- 40 77 0b 6b 61 6e 61 72 69 65 70 69 65 74 03 63 6f 6d 00 00 01 ; 41- 60 00 01 00 01 50 8b 00 04 52 5e ed 32 0b 6b 61 6e 61 72 69 65 ; 61- 80 70 69 65 74 03 63 6f 6d 00 00 02 00 01 00 01 50 8b 00 11 03 ; 81- 100 6e 73 31 08 68 65 78 6f 6e 2d 69 73 02 6e 6c 00 0b 6b 61 6e ; 101- 120 61 72 69 65 70 69 65 74 03 63 6f 6d 00 00 02 00 01 00 01 50 ; 121- 140 8b 00 11 03 6e 73 32 08 68 65 78 6f 6e 2d 69 73 02 6e 6c 00 ; 141- 160 03 6e 73 31 08 68 65 78 6f 6e 2d 69 73 02 6e 6c 00 00 01 00 ; 161- 180 01 00 00 46 53 00 04 52 5e ed 02 03 6e 73 32 08 68 65 78 6f ; 181- 200 6e 2d 69 73 02 6e 6c 00 00 01 00 01 00 00 46 53 00 04 d4 cc ; 201- 220 db 5b HEX_ANSWER_END ENTRY_END */ struct sockaddr_storage; #include "config.h" #include #include "ldns-testpkts.h" #ifdef HAVE_SYS_SOCKET_H #include #endif #ifdef HAVE_TIME_H #include #endif #ifdef HAVE_SYS_TIME_H #include #endif #ifdef HAVE_SYS_SELECT_H #include #endif #ifdef HAVE_ARPA_INET_H #include #endif #ifdef HAVE_NETINET_IN_H #include #endif #ifdef HAVE_NETINET_UDP_H #include #endif #ifdef HAVE_NETINET_IGMP_H #include #endif #include #define INBUF_SIZE 4096 /* max size for incoming queries */ #define DEFAULT_PORT 53 /* default if no -p port is specified */ #define CONN_BACKLOG 5 /* 5 connections queued up for tcp */ static const char* prog_name = "ldns-testns"; static FILE* logfile = 0; static int do_verbose = 0; static void usage(void) { printf("Usage: %s [options] \n", prog_name); printf(" -r listens on random port. Port number is printed.\n"); printf(" -p listens on the specified port, default %d.\n", DEFAULT_PORT); printf(" -f forks given number extra instances, default none.\n"); printf(" -v more verbose, prints queries, answers and matching.\n"); printf(" -6 listen on IP6 any address, instead of IP4 any address.\n"); printf("The program answers queries with canned replies from the datafile.\n"); exit(EXIT_FAILURE); } static void log_msg(const char* msg, ...) { va_list args; va_start(args, msg); vfprintf(logfile, msg, args); fflush(logfile); va_end(args); } static void error(const char* msg, ...) { va_list args; va_start(args, msg); fprintf(logfile, "%s error: ", prog_name); vfprintf(logfile, msg, args); fprintf(logfile, "\n"); fflush(logfile); va_end(args); exit(EXIT_FAILURE); } void verbose(int ATTR_UNUSED(lvl), const char* msg, ...) { va_list args; va_start(args, msg); if(do_verbose) vfprintf(logfile, msg, args); fflush(logfile); va_end(args); } static int bind_port(int sock, int port, int fam) { struct sockaddr_in addr; #if defined(AF_INET6) && defined(HAVE_GETADDRINFO) if(fam == AF_INET6) { struct sockaddr_in6 addr6; memset(&addr6, 0, sizeof(addr6)); addr6.sin6_family = AF_INET6; addr6.sin6_port = (in_port_t)htons((uint16_t)port); # if HAVE_DECL_IN6ADDR_ANY addr6.sin6_addr = in6addr_any; # else memset(&addr6.sin6_addr, 0, sizeof(addr6.sin6_addr)); # endif return bind(sock, (struct sockaddr *)&addr6, (socklen_t) sizeof(addr6)); } #endif #ifndef S_SPLINT_S addr.sin_family = AF_INET; #endif addr.sin_port = (in_port_t)htons((uint16_t)port); addr.sin_addr.s_addr = INADDR_ANY; return bind(sock, (struct sockaddr *)&addr, (socklen_t) sizeof(addr)); } struct handle_udp_userdata { int udp_sock; struct sockaddr_storage addr_him; socklen_t hislen; }; static void send_udp(uint8_t* buf, size_t len, void* data) { struct handle_udp_userdata *userdata = (struct handle_udp_userdata*)data; /* udp send reply */ ssize_t nb; nb = sendto(userdata->udp_sock, (void*)buf, len, 0, (struct sockaddr*)&userdata->addr_him, userdata->hislen); if(nb == -1) log_msg("sendto(): %s\n", strerror(errno)); else if((size_t)nb != len) log_msg("sendto(): only sent %d of %d octets.\n", (int)nb, (int)len); } static void handle_udp(int udp_sock, struct entry* entries, int *count) { ssize_t nb; uint8_t inbuf[INBUF_SIZE]; struct handle_udp_userdata userdata; userdata.udp_sock = udp_sock; userdata.hislen = (socklen_t)sizeof(userdata.addr_him); /* udp recv */ nb = recvfrom(udp_sock, (void*)inbuf, INBUF_SIZE, 0, (struct sockaddr*)&userdata.addr_him, &userdata.hislen); if (nb < 1) { #ifndef USE_WINSOCK log_msg("recvfrom(): %s\n", strerror(errno)); #else if(WSAGetLastError() != WSAEINPROGRESS && WSAGetLastError() != WSAECONNRESET && WSAGetLastError()!= WSAEWOULDBLOCK) log_msg("recvfrom(): %d\n", WSAGetLastError()); #endif return; } handle_query(inbuf, nb, entries, count, transport_udp, send_udp, &userdata, do_verbose?logfile:0); } static void read_n_bytes(int sock, uint8_t* buf, size_t sz) { size_t count = 0; while(count < sz) { ssize_t nb = recv(sock, (void*)(buf+count), sz-count, 0); if(nb < 0) { log_msg("recv(): %s\n", strerror(errno)); return; } count += nb; } } static void write_n_bytes(int sock, uint8_t* buf, size_t sz) { size_t count = 0; while(count < sz) { ssize_t nb = send(sock, (void*)(buf+count), sz-count, 0); if(nb < 0) { log_msg("send(): %s\n", strerror(errno)); return; } count += nb; } } struct handle_tcp_userdata { int s; }; static void send_tcp(uint8_t* buf, size_t len, void* data) { struct handle_tcp_userdata *userdata = (struct handle_tcp_userdata*)data; uint16_t tcplen; /* tcp send reply */ tcplen = htons(len); write_n_bytes(userdata->s, (uint8_t*)&tcplen, sizeof(tcplen)); write_n_bytes(userdata->s, buf, len); } static void handle_tcp(int tcp_sock, struct entry* entries, int *count) { int s; struct sockaddr_storage addr_him; socklen_t hislen; uint8_t inbuf[INBUF_SIZE]; uint16_t tcplen; struct handle_tcp_userdata userdata; /* accept */ hislen = (socklen_t)sizeof(addr_him); if((s = accept(tcp_sock, (struct sockaddr*)&addr_him, &hislen)) < 0) { log_msg("accept(): %s\n", strerror(errno)); return; } userdata.s = s; /* tcp recv */ read_n_bytes(s, (uint8_t*)&tcplen, sizeof(tcplen)); tcplen = ntohs(tcplen); if(tcplen >= INBUF_SIZE) { log_msg("query %d bytes too large, buffer %d bytes.\n", tcplen, INBUF_SIZE); #ifndef USE_WINSOCK close(s); #else closesocket(s); #endif return; } read_n_bytes(s, inbuf, tcplen); handle_query(inbuf, (ssize_t) tcplen, entries, count, transport_tcp, send_tcp, &userdata, do_verbose?logfile:0); #ifndef USE_WINSOCK close(s); #else closesocket(s); #endif } /** shared by the service and main routine (forked and threaded) */ static int udp_sock, tcp_sock; static struct entry* entries; /** * Test DNS server service, uses global udpsock, tcpsock, reply entries * The signature is kept void so the function can be used as a thread function. */ static void service(void) { fd_set rset, wset, eset; int count; int maxfd; /* service */ count = 0; while (1) { #ifndef S_SPLINT_S FD_ZERO(&rset); FD_ZERO(&wset); FD_ZERO(&eset); FD_SET(udp_sock, &rset); FD_SET(tcp_sock, &rset); #endif maxfd = udp_sock; if(tcp_sock > maxfd) maxfd = tcp_sock; if(select(maxfd+1, &rset, &wset, &eset, NULL) < 0) { error("select(): %s\n", strerror(errno)); } if(FD_ISSET(udp_sock, &rset)) { handle_udp(udp_sock, entries, &count); } if(FD_ISSET(tcp_sock, &rset)) { handle_tcp(tcp_sock, entries, &count); } } } static void forkit(int number) { int i; for(i=0; i 1) usage(); datafile = argv[0]; log_msg("Reading datafile %s\n", datafile); entries = read_datafile(datafile, 0); #ifdef USE_WINSOCK if(WSAStartup(MAKEWORD(2,2), &wsa_data) != 0) error("WSAStartup failed\n"); #endif if((udp_sock = socket(fam, SOCK_DGRAM, 0)) < 0) { error("udp socket(): %s\n", strerror(errno)); } if((tcp_sock = socket(fam, SOCK_STREAM, 0)) < 0) { error("tcp socket(): %s\n", strerror(errno)); } c = 1; if(setsockopt(tcp_sock, SOL_SOCKET, SO_REUSEADDR, (void*)&c, (socklen_t) sizeof(int)) < 0) { error("setsockopt(SO_REUSEADDR): %s\n", strerror(errno)); } /* bind ip4 */ if (port > 0) { if (bind_port(udp_sock, port, fam)) { error("cannot bind(): %s\n", strerror(errno)); } if (bind_port(tcp_sock, port, fam)) { error("cannot bind(): %s\n", strerror(errno)); } if (listen(tcp_sock, CONN_BACKLOG) < 0) { error("listen(): %s\n", strerror(errno)); } } else { random_port_success = false; while (!random_port_success) { port = (random() % 64510) + 1025; log_msg("trying to bind to port %d\n", port); random_port_success = true; if (bind_port(udp_sock, port, fam)) { #ifdef EADDRINUSE if (errno != EADDRINUSE) { #elif defined(USE_WINSOCK) if (WSAGetLastError() != WSAEADDRINUSE) { #else if (1) { #endif perror("bind()"); return -1; } else { random_port_success = false; } } if (random_port_success) { if (bind_port(tcp_sock, port, fam)) { #ifdef EADDRINUSE if (errno != EADDRINUSE) { #elif defined(USE_WINSOCK) if (WSAGetLastError()!=WSAEADDRINUSE){ #else if (1) { #endif perror("bind()"); return -1; } else { random_port_success = false; } } } if (random_port_success) { if (listen(tcp_sock, CONN_BACKLOG) < 0) { error("listen(): %s\n", strerror(errno)); } } } } log_msg("Listening on port %d\n", port); /* forky! */ if(forknum > 0) forkit(forknum); service(); return 0; } ldns-1.6.17/examples/ldns-version.10000664000175100017510000000112312264060151016433 0ustar willemwillem.TH ldns-version 1 "27 Apr 2005" .SH NAME ldns-version \- print out the version of the ldns-library and tools on this system .SH SYNOPSIS .B ldns-version .SH DESCRIPTION \fBldns-version\fR is used to print out version information of the ldns library and tools .SH OPTIONS \fBldns-version\fR has no options. .SH AUTHOR Written by the ldns team as an example for ldns usage. .SH REPORTING BUGS Report bugs to . .SH COPYRIGHT Copyright (C) 2005 NLnet Labs. This is free software. There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. ldns-1.6.17/examples/ldns-test-edns.c0000664000175100017510000001453012264060151016744 0ustar willemwillem/* * ldns-test-edns tries to get DNSKEY and RRSIG from an IP address. * This can be used to test if a DNS cache supports DNSSEC (caching RRSIGs), * i.e. for automatic configuration utilities or when you get a new DNS cache * from DHCP and wonder if your local validator could use that as a cache. * * (c) NLnet Labs 2010 * See the file LICENSE for the license */ #include "config.h" #include "errno.h" #include /** print error details */ static int verb = 1; struct sockaddr_in6* cast_sockaddr_storage2sockaddr_in6( struct sockaddr_storage* s) { return (struct sockaddr_in6*)s; } struct sockaddr_in* cast_sockaddr_storage2sockaddr_in( struct sockaddr_storage* s) { return (struct sockaddr_in*)s; } /** parse IP address */ static int convert_addr(char* str, int p, struct sockaddr_storage* addr, socklen_t* len) { #ifdef AF_INET6 if(strchr(str, ':')) { *len = (socklen_t)sizeof(struct sockaddr_in6); cast_sockaddr_storage2sockaddr_in6(addr)->sin6_family = AF_INET6; cast_sockaddr_storage2sockaddr_in6(addr)->sin6_port = htons((uint16_t)p); if(inet_pton(AF_INET6, str, &((struct sockaddr_in6*)addr)->sin6_addr) == 1) return 1; } else { #endif *len = (socklen_t)sizeof(struct sockaddr_in); #ifndef S_SPLINT_S cast_sockaddr_storage2sockaddr_in(addr)->sin_family = AF_INET; #endif cast_sockaddr_storage2sockaddr_in(addr)->sin_port = htons((uint16_t)p); if(inet_pton(AF_INET, str, &((struct sockaddr_in*)addr)->sin_addr) == 1) return 1; #ifdef AF_INET6 } #endif if(verb) printf("error: cannot parse IP address %s\n", str); return 0; } /** create a query to test */ static ldns_buffer* make_query(const char* nm, int tp) { /* with EDNS DO and CDFLAG */ ldns_buffer* b = ldns_buffer_new(512); ldns_pkt* p; ldns_status s; if(!b) { if(verb) printf("error: out of memory\n"); return NULL; } s = ldns_pkt_query_new_frm_str(&p, nm, tp, LDNS_RR_CLASS_IN, (uint16_t)(LDNS_RD|LDNS_CD)); if(s != LDNS_STATUS_OK) { if(verb) printf("error: %s\n", ldns_get_errorstr_by_id(s)); ldns_buffer_free(b); return NULL; } if(!p) { if(verb) printf("error: out of memory\n"); ldns_buffer_free(b); return NULL; } ldns_pkt_set_edns_do(p, 1); ldns_pkt_set_edns_udp_size(p, 4096); ldns_pkt_set_id(p, ldns_get_random()); if( (s=ldns_pkt2buffer_wire(b, p)) != LDNS_STATUS_OK) { if(verb) printf("error: %s\n", ldns_get_errorstr_by_id(s)); ldns_pkt_free(p); ldns_buffer_free(b); return NULL; } ldns_pkt_free(p); return b; } /** try 3 times to get an EDNS reply from the server, exponential backoff */ static int get_packet(struct sockaddr_storage* addr, socklen_t len, const char* nm, int tp, uint8_t **wire, size_t* wlen) { struct timeval t; ldns_buffer* qbin; ldns_status s; int tries = 0; memset(&t, 0, sizeof(t)); t.tv_usec = 100 * 1000; /* 100 milliseconds (then 200, 400, 800) */ qbin = make_query(nm, tp); if(!qbin) return 0; while(tries < 4) { tries ++; s = ldns_udp_send(wire, qbin, addr, len, t, wlen); if(s != LDNS_STATUS_NETWORK_ERR) { break; } t.tv_usec *= 2; if(t.tv_usec > 1000*1000) { t.tv_usec -= 1000*1000; t.tv_sec += 1; } } ldns_buffer_free(qbin); if(tries == 4) { if(verb) printf("timeout\n"); return 0; } if(s != LDNS_STATUS_OK) { if(verb) printf("error: %s\n", ldns_get_errorstr_by_id(s)); return 0; } return 1; } /** test if type is present in returned packet */ static int check_type_in_answer(ldns_pkt* p, int t) { ldns_rr_list *l = ldns_pkt_rr_list_by_type(p, t, LDNS_SECTION_ANSWER); if(!l) { char* s = ldns_rr_type2str(t); if(verb) printf("no DNSSEC %s\n", s?s:"(out of memory)"); LDNS_FREE(s); return 0; } ldns_rr_list_deep_free(l); return 1; } /** check the packet and make sure that EDNS and DO and the type and RRSIG */ static int check_packet(uint8_t* wire, size_t len, int tp) { ldns_pkt *p = NULL; ldns_status s; if( (s=ldns_wire2pkt(&p, wire, len)) != LDNS_STATUS_OK) { if(verb) printf("error: %s\n", ldns_get_errorstr_by_id(s)); goto failed; } if(!p) { if(verb) printf("error: out of memory\n"); goto failed; } /* does DNS work? */ if(ldns_pkt_get_rcode(p) != LDNS_RCODE_NOERROR) { char* r = ldns_pkt_rcode2str(ldns_pkt_get_rcode(p)); if(verb) printf("no answer, %s\n", r?r:"(out of memory)"); LDNS_FREE(r); goto failed; } /* test EDNS0 presence, of OPT record */ /* LDNS forgets during pkt parse, but we test the ARCOUNT; * 0 additionals means no EDNS(on the wire), and after parsing the * same additional RRs as before means no EDNS OPT */ if(LDNS_ARCOUNT(wire) == 0 || ldns_pkt_arcount(p) == LDNS_ARCOUNT(wire)) { if(verb) printf("no EDNS\n"); goto failed; } /* test if the type, RRSIG present */ if(!check_type_in_answer(p, tp) || !check_type_in_answer(p, LDNS_RR_TYPE_RRSIG)) { goto failed; } LDNS_FREE(wire); ldns_pkt_free(p); return 1; failed: LDNS_FREE(wire); ldns_pkt_free(p); return 0; } /** check EDNS at this IP and port */ static int check_edns_ip(char* ip, int port, int info) { struct sockaddr_storage addr; socklen_t len = 0; uint8_t* wire; size_t wlen; memset(&addr, 0, sizeof(addr)); if(verb) printf("%s ", ip); if(!convert_addr(ip, port, &addr, &len)) return 2; /* try to send 3 times to the IP address, test root key */ if(!get_packet(&addr, len, ".", LDNS_RR_TYPE_DNSKEY, &wire, &wlen)) return 2; if(!check_packet(wire, wlen, LDNS_RR_TYPE_DNSKEY)) return 1; /* check support for caching type DS for chains of trust */ if(!get_packet(&addr, len, "se.", LDNS_RR_TYPE_DS, &wire, &wlen)) return 2; if(!check_packet(wire, wlen, LDNS_RR_TYPE_DS)) return 1; if(verb) printf("OK\n"); if(info) printf(" %s", ip); return 0; } int main(int argc, char **argv) { int i, r=0, info=0, ok=0; #ifdef USE_WINSOCK WSADATA wsa_data; if(WSAStartup(MAKEWORD(2,2), &wsa_data) != 0) { printf("WSAStartup failed\n"); exit(1); } #endif if (argc < 2 || strncmp(argv[1], "-h", 3) == 0) { printf("Usage: ldns-test-edns [-i] {ip address}\n"); printf("Tests if the DNS cache at IP address supports EDNS.\n"); printf("if it works, print IP address OK.\n"); printf("-i: print IPs that are OK or print 'off'.\n"); printf("exit value, last IP is 0:OK, 1:fail, 2:net error.\n"); exit(1); } if(strcmp(argv[1], "-i") == 0) { info = 1; verb = 0; } for(i=1+info; i' and you have to kill them yourself. .TP \fB-v\fR Outputs more debug information. It is possible to give this option multiple times to increase verbosity level. .TP \fB-6\fR Bind to IP6 address instead of IP4. Use together with -p. .TP \fBdatafile\fR The data file is read on start up. It contains queries and the packets that should be sent in answer to those queries. The data file format is explained below. .SH DATA FILE FORMAT The data file format has ';' to denote comment. A number of entries are processed first to last. The first matching entry is used to answer the query with. This is a line based format. DNS resource records are entered in zone-file format. You can use $ORIGIN and $TTL directives. Zone file '(' and ')' to span multiple lines are not allowed. $ORIGIN origin $TTL default_ttl ENTRY_BEGIN ; first give MATCH lines, that say what queries are matched ; by this entry. ; 'opcode' makes the query match the opcode from the reply ; if you leave it out, any opcode matches this entry. ; 'qtype' makes the query match the qtype from the reply ; 'qname' makes the query match the qname from the reply ; 'serial=1023' makes the query match if ixfr serial is 1023. MATCH [opcode] [qtype] [qname] [serial=] MATCH [UDP|TCP] MATCH ... ; Then the REPLY header is specified. REPLY opcode, rcode or flags. (opcode) QUERY IQUERY STATUS NOTIFY UPDATE (rcode) NOERROR FORMERR SERVFAIL NXDOMAIN NOTIMPL YXDOMAIN YXRRSET NXRRSET NOTAUTH NOTZONE (flags) QR AA TC RD CD RA AD REPLY ... ; any additional actions to do. ADJUST copy_id ; 'copy_id' copies the ID from the query to the answer. ; 'sleep=10' sleeps for 10 seconds before giving the answer (TCP is open) ADJUST [sleep=] ; sleep before giving any reply ADJUST [packet_sleep=] ; sleep before this packet in sequence SECTION QUESTION ; the RRcount is determined automatically. SECTION ANSWER SECTION AUTHORITY SECTION ADDITIONAL EXTRA_PACKET ; follow with SECTION, REPLY for more packets. HEX_ANSWER_BEGIN ; follow with hex data ; this replaces any answer packet constructed ; with the SECTION keywords (only SECTION QUERY ; is used to match queries). If the data cannot ; be parsed, ADJUST rules for the answer packet ; are ignored HEX_ANSWER_END ENTRY_END .SH AUTHOR Written by the ldns team as an example for ldns usage, and for testing purposes. .SH REPORTING BUGS Report bugs to . .SH COPYRIGHT Copyright (C) 2006-2008 NLnet Labs. This is free software. There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. ldns-1.6.17/examples/ldns-testpkts.h0000664000175100017510000002151012264060151016720 0ustar willemwillem/* * ldns-testpkts. Data file parse for test packets, and query matching. * * Data storage for specially crafted replies for testing purposes. * * (c) NLnet Labs, 2005, 2006, 2007 * See the file LICENSE for the license */ #ifndef LDNS_TESTPKTS_H #define LDNS_TESTPKTS_H /** * \file * * This is a debugging aid. It is not efficient, especially * with a long config file, but it can give any reply to any query. * This can help the developer pre-script replies for queries. * * You can specify a packet RR by RR with header flags to return. * * Missing features: * - matching content different from reply content. * - find way to adjust mangled packets? * */ /* The data file format is as follows: ; comment. ; a number of entries, these are processed first to last. ; a line based format. $ORIGIN origin $TTL default_ttl ENTRY_BEGIN ; first give MATCH lines, that say what queries are matched ; by this entry. ; 'opcode' makes the query match the opcode from the reply ; if you leave it out, any opcode matches this entry. ; 'qtype' makes the query match the qtype from the reply ; 'qname' makes the query match the qname from the reply ; 'subdomain' makes the query match subdomains of qname from the reply ; 'serial=1023' makes the query match if ixfr serial is 1023. ; 'all' has to match header byte for byte and all rrs in packet. ; 'ttl' used with all, rrs in packet must also have matching TTLs. ; 'DO' will match only queries with DO bit set. ; 'noedns' matches queries without EDNS OPT records. ; 'ednsdata' matches queries to HEX_EDNS section. MATCH [opcode] [qtype] [qname] [serial=] [all] [ttl] MATCH [UDP|TCP] DO MATCH ... ; Then the REPLY header is specified. REPLY opcode, rcode or flags. (opcode) QUERY IQUERY STATUS NOTIFY UPDATE (rcode) NOERROR FORMERR SERVFAIL NXDOMAIN NOTIMPL YXDOMAIN YXRRSET NXRRSET NOTAUTH NOTZONE (flags) QR AA TC RD CD RA AD DO REPLY ... ; any additional actions to do. ; 'copy_id' copies the ID from the query to the answer. ADJUST copy_id ; 'copy_query' copies the query name, type and class to the answer. ADJUST copy_query ; 'sleep=10' sleeps for 10 seconds before giving the answer (TCP is open) ADJUST [sleep=] ; sleep before giving any reply ADJUST [packet_sleep=] ; sleep before this packet in sequence SECTION QUESTION ; the RRcount is determined automatically. SECTION ANSWER SECTION AUTHORITY SECTION ADDITIONAL EXTRA_PACKET ; follow with SECTION, REPLY for more packets. HEX_ANSWER_BEGIN ; follow with hex data ; this replaces any answer packet constructed ; with the SECTION keywords (only SECTION QUERY ; is used to match queries). If the data cannot ; be parsed, ADJUST rules for the answer packet ; are ignored. Only copy_id is done. HEX_ANSWER_END HEX_EDNS_BEGIN ; follow with hex data. ; Raw EDNS data to match against. It must be an ; exact match (all options are matched) and will be ; evaluated only when 'MATCH ednsdata' given. HEX_EDNS_END ENTRY_END Example data file: $ORIGIN nlnetlabs.nl $TTL 3600 ENTRY_BEGIN MATCH qname REPLY NOERROR ADJUST copy_id SECTION QUESTION www.nlnetlabs.nl. IN A SECTION ANSWER www.nlnetlabs.nl. IN A 195.169.215.155 SECTION AUTHORITY nlnetlabs.nl. IN NS www.nlnetlabs.nl. ENTRY_END ENTRY_BEGIN MATCH qname REPLY NOERROR ADJUST copy_id SECTION QUESTION www2.nlnetlabs.nl. IN A HEX_ANSWER_BEGIN ; 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 ;-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 00 bf 81 80 00 01 00 01 00 02 00 02 03 77 77 77 0b 6b 61 6e ; 1- 20 61 72 69 65 70 69 65 74 03 63 6f 6d 00 00 01 00 01 03 77 77 ; 21- 40 77 0b 6b 61 6e 61 72 69 65 70 69 65 74 03 63 6f 6d 00 00 01 ; 41- 60 00 01 00 01 50 8b 00 04 52 5e ed 32 0b 6b 61 6e 61 72 69 65 ; 61- 80 70 69 65 74 03 63 6f 6d 00 00 02 00 01 00 01 50 8b 00 11 03 ; 81- 100 6e 73 31 08 68 65 78 6f 6e 2d 69 73 02 6e 6c 00 0b 6b 61 6e ; 101- 120 61 72 69 65 70 69 65 74 03 63 6f 6d 00 00 02 00 01 00 01 50 ; 121- 140 8b 00 11 03 6e 73 32 08 68 65 78 6f 6e 2d 69 73 02 6e 6c 00 ; 141- 160 03 6e 73 31 08 68 65 78 6f 6e 2d 69 73 02 6e 6c 00 00 01 00 ; 161- 180 01 00 00 46 53 00 04 52 5e ed 02 03 6e 73 32 08 68 65 78 6f ; 181- 200 6e 2d 69 73 02 6e 6c 00 00 01 00 01 00 00 46 53 00 04 d4 cc ; 201- 220 db 5b HEX_ANSWER_END ENTRY_END note that this file will link with your void verbose(int level, char* format, ...); output function. */ #include /** Type of transport, since some entries match based on UDP or TCP of query */ enum transport_type {transport_any = 0, transport_udp, transport_tcp }; /** struct to keep a linked list of reply packets for a query */ struct reply_packet { /** next in list of reply packets, for TCP multiple pkts on wire */ struct reply_packet* next; /** the reply pkt */ ldns_pkt* reply; /** Additional EDNS data for matching queries. */ ldns_buffer* raw_ednsdata; /** or reply pkt in hex if not parsable */ ldns_buffer* reply_from_hex; /** seconds to sleep before giving packet */ unsigned int packet_sleep; }; /** data structure to keep the canned queries in. format is the 'matching query' and the 'canned answer' */ struct entry { /* match */ /* How to match an incoming query with this canned reply */ /** match query opcode with answer opcode */ bool match_opcode; /** match qtype with answer qtype */ bool match_qtype; /** match qname with answer qname */ bool match_qname; /** match qname as subdomain of answer qname */ bool match_subdomain; /** match SOA serial number, from auth section */ bool match_serial; /** match all of the packet */ bool match_all; /** match ttls in the packet */ bool match_ttl; /** match DO bit */ bool match_do; /** match absence of EDNS OPT record in query */ bool match_noedns; /** match edns data field given in hex */ bool match_ednsdata_raw; /** match query serial with this value. */ uint32_t ixfr_soa_serial; /** match on UDP/TCP */ enum transport_type match_transport; /** pre canned reply */ struct reply_packet *reply_list; /** how to adjust the reply packet */ /** copy over the ID from the query into the answer */ bool copy_id; /** copy the query nametypeclass from query into the answer */ bool copy_query; /** in seconds */ unsigned int sleeptime; /** some number that names this entry, line number in file or so */ int lineno; /** next in list */ struct entry* next; }; /** * reads the canned reply file and returns a list of structs * does an exit on error. * @param name: name of the file to read. * @param skip_whitespace: skip leftside whitespace. */ struct entry* read_datafile(const char* name, int skip_whitespace); /** * Delete linked list of entries. */ void delete_entry(struct entry* list); /** * Read one entry from the data file. * @param in: file to read from. Filepos must be at the start of a new line. * @param name: name of the file for prettier errors. * @param lineno: line number in file, incremented as lines are read. * for prettier errors. * @param default_ttl: on first call set to default TTL for entries, * later it stores the $TTL value last seen. Try 3600 first call. * @param origin: domain name for origin appending. Can be &NULL on first call. * later it stores the $ORIGIN value last seen. Often &NULL or the zone * name on first call. * @param prev_rr: previous rr name for correcter parsing. &NULL on first call. * @param skip_whitespace: skip leftside whitespace. * @return: The entry read (malloced) or NULL if no entry could be read. */ struct entry* read_entry(FILE* in, const char* name, int *lineno, uint32_t* default_ttl, ldns_rdf** origin, ldns_rdf** prev_rr, int skip_whitespace); /** * finds entry in list, or returns NULL. */ struct entry* find_match(struct entry* entries, ldns_pkt* query_pkt, enum transport_type transport); /** * copy & adjust packet */ void adjust_packet(struct entry* match, ldns_pkt* answer_pkt, ldns_pkt* query_pkt); /** * Parses data buffer to a query, finds the correct answer * and calls the given function for every packet to send. * if verbose_out filename is given, packets are dumped there. * @param inbuf: the packet that came in * @param inlen: length of packet. * @param entries: entries read in from datafile. * @param count: is increased to count number of queries answered. * @param transport: set to UDP or TCP to match some types of entries. * @param sendfunc: called to send answer (buffer, size, userarg). * @param userdata: userarg to give to sendfunc. * @param verbose_out: if not NULL, verbose messages are printed there. */ void handle_query(uint8_t* inbuf, ssize_t inlen, struct entry* entries, int* count, enum transport_type transport, void (*sendfunc)(uint8_t*, size_t, void*), void* userdata, FILE* verbose_out); #endif /* LDNS_TESTPKTS_H */ ldns-1.6.17/examples/ldnsd.c0000664000175100017510000001424012264060151015202 0ustar willemwillem/* * ldnsd. Light-weight DNS daemon * * Tiny dns server to show how a real one could be built. * * (c) NLnet Labs, 2005 * See the file LICENSE for the license */ #include "config.h" #include #ifdef HAVE_SYS_SOCKET_H # include #endif #ifdef HAVE_ARPA_INET_H # include #endif #ifdef HAVE_NETINET_IN_H # include #endif #ifdef HAVE_NETINET_UDP_H # include #endif #ifdef HAVE_NETINET_IGMP_H # include #endif #include #define INBUF_SIZE 4096 void usage(FILE *output) { fprintf(output, "Usage: ldnsd
\n"); fprintf(output, "Listens on the specified port and answers queries for the given zone\n"); fprintf(output, "This is NOT a full-fledged authoritative nameserver!\n"); } static int udp_bind(int sock, int port, const char *my_address) { struct sockaddr_in addr; in_addr_t maddr = INADDR_ANY; if (my_address) { #ifdef AF_INET6 if (inet_pton(AF_INET6, my_address, &maddr) < 1) { #else if (0) { #endif if (inet_pton(AF_INET, my_address, &maddr) < 1) { return -2; } } } #ifndef S_SPLINT_S addr.sin_family = AF_INET; #endif addr.sin_port = (in_port_t) htons((uint16_t)port); addr.sin_addr.s_addr = maddr; return bind(sock, (struct sockaddr *)&addr, (socklen_t) sizeof(addr)); } /* this will probably be moved to a better place in the library itself */ ldns_rr_list * get_rrset(const ldns_zone *zone, const ldns_rdf *owner_name, const ldns_rr_type qtype, const ldns_rr_class qclass) { uint16_t i; ldns_rr_list *rrlist = ldns_rr_list_new(); ldns_rr *cur_rr; if (!zone || !owner_name) { fprintf(stderr, "Warning: get_rrset called with NULL zone or owner name\n"); return rrlist; } for (i = 0; i < ldns_zone_rr_count(zone); i++) { cur_rr = ldns_rr_list_rr(ldns_zone_rrs(zone), i); if (ldns_dname_compare(ldns_rr_owner(cur_rr), owner_name) == 0 && ldns_rr_get_class(cur_rr) == qclass && ldns_rr_get_type(cur_rr) == qtype ) { ldns_rr_list_push_rr(rrlist, ldns_rr_clone(cur_rr)); } } printf("Found rrset of %u rrs\n", (unsigned int) ldns_rr_list_rr_count(rrlist)); return rrlist; } int main(int argc, char **argv) { /* arguments */ int port; const char *zone_file; /* network */ int sock; ssize_t nb; struct sockaddr addr_me; struct sockaddr addr_him; socklen_t hislen = (socklen_t) sizeof(addr_him); uint8_t inbuf[INBUF_SIZE]; uint8_t *outbuf; /* dns */ ldns_status status; ldns_pkt *query_pkt; ldns_pkt *answer_pkt; size_t answer_size; ldns_rr *query_rr; ldns_rr_list *answer_qr; ldns_rr_list *answer_an; ldns_rr_list *answer_ns; ldns_rr_list *answer_ad; ldns_rdf *origin = NULL; /* zone */ ldns_zone *zone; int line_nr; FILE *zone_fp; /* use this to listen on specified interfaces later? */ char *my_address = NULL; if (argc < 5) { usage(stderr); exit(EXIT_FAILURE); } else { my_address = argv[1]; port = atoi(argv[2]); if (port < 1) { usage(stderr); exit(EXIT_FAILURE); } if (ldns_str2rdf_dname(&origin, argv[3]) != LDNS_STATUS_OK) { fprintf(stderr, "Bad origin, not a correct domain name\n"); usage(stderr); exit(EXIT_FAILURE); } zone_file = argv[4]; } printf("Reading zone file %s\n", zone_file); zone_fp = fopen(zone_file, "r"); if (!zone_fp) { fprintf(stderr, "Unable to open %s: %s\n", zone_file, strerror(errno)); exit(EXIT_FAILURE); } line_nr = 0; status = ldns_zone_new_frm_fp_l(&zone, zone_fp, origin, 0, LDNS_RR_CLASS_IN, &line_nr); if (status != LDNS_STATUS_OK) { printf("Zone reader failed, aborting\n"); exit(EXIT_FAILURE); } else { printf("Read %u resource records in zone file\n", (unsigned int) ldns_zone_rr_count(zone)); } fclose(zone_fp); printf("Listening on port %d\n", port); sock = socket(AF_INET, SOCK_DGRAM, 0); if (sock < 0) { fprintf(stderr, "%s: socket(): %s\n", argv[0], strerror(errno)); exit(1); } memset(&addr_me, 0, sizeof(addr_me)); /* bind: try all ports in that range */ if (udp_bind(sock, port, my_address)) { fprintf(stderr, "%s: cannot bind(): %s\n", argv[0], strerror(errno)); exit(errno); } /* Done. Now receive */ while (1) { nb = recvfrom(sock, (void*)inbuf, INBUF_SIZE, 0, &addr_him, &hislen); if (nb < 1) { fprintf(stderr, "%s: recvfrom(): %s\n", argv[0], strerror(errno)); exit(1); } /* show(inbuf, nb, nn, hp, sp, ip, bp); */ printf("Got query of %u bytes\n", (unsigned int) nb); status = ldns_wire2pkt(&query_pkt, inbuf, (size_t) nb); if (status != LDNS_STATUS_OK) { printf("Got bad packet: %s\n", ldns_get_errorstr_by_id(status)); } else { ldns_pkt_print(stdout, query_pkt); } query_rr = ldns_rr_list_rr(ldns_pkt_question(query_pkt), 0); printf("QUERY RR: \n"); ldns_rr_print(stdout, query_rr); answer_qr = ldns_rr_list_new(); ldns_rr_list_push_rr(answer_qr, ldns_rr_clone(query_rr)); answer_an = get_rrset(zone, ldns_rr_owner(query_rr), ldns_rr_get_type(query_rr), ldns_rr_get_class(query_rr)); answer_pkt = ldns_pkt_new(); answer_ns = ldns_rr_list_new(); answer_ad = ldns_rr_list_new(); ldns_pkt_set_qr(answer_pkt, 1); ldns_pkt_set_aa(answer_pkt, 1); ldns_pkt_set_id(answer_pkt, ldns_pkt_id(query_pkt)); ldns_pkt_push_rr_list(answer_pkt, LDNS_SECTION_QUESTION, answer_qr); ldns_pkt_push_rr_list(answer_pkt, LDNS_SECTION_ANSWER, answer_an); ldns_pkt_push_rr_list(answer_pkt, LDNS_SECTION_AUTHORITY, answer_ns); ldns_pkt_push_rr_list(answer_pkt, LDNS_SECTION_ADDITIONAL, answer_ad); status = ldns_pkt2wire(&outbuf, answer_pkt, &answer_size); printf("Answer packet size: %u bytes.\n", (unsigned int) answer_size); if (status != LDNS_STATUS_OK) { printf("Error creating answer: %s\n", ldns_get_errorstr_by_id(status)); } else { nb = sendto(sock, (void*)outbuf, answer_size, 0, &addr_him, hislen); } ldns_pkt_free(query_pkt); ldns_pkt_free(answer_pkt); LDNS_FREE(outbuf); ldns_rr_list_free(answer_qr); ldns_rr_list_free(answer_an); ldns_rr_list_free(answer_ns); ldns_rr_list_free(answer_ad); } /* No cleanup because of the infinite loop * * ldns_rdf_deep_free(origin); * ldns_zone_deep_free(zone); * return 0; */ } ldns-1.6.17/examples/ldns-keygen.10000664000175100017510000000317412264060151016240 0ustar willemwillem.TH ldns-keygen 1 "27 May 2008" .SH NAME ldns-keygen \- generate a DNSSEC key pair .SH SYNOPSIS .B ldns-keygen [ .IR OPTION ] .IR DOMAIN .SH DESCRIPTION \fBldns-keygen\fR is used to generate a private/public keypair. When run, it will create 3 files; a .key file with the public DNSKEY, a .private file with the private keydata and a .ds with the DS record of the DNSKEY record. \fBldns-keygen\fR can also be used to create symmetric keys (for TSIG) by selecting the appropriate algorithm: \%\fIhmac-md5.sig-alg.reg.int\fR, \%\fIhmac-sha1\fR or \%\fIhmac-sha256\fR. In that case no DS record will be created and no .ds file. \fBldns-keygen\fR prints the basename for the key files: K++ .SH OPTIONS .TP \fB-a \fI\fR Create a key with this algorithm. Specifying 'list' here gives a list of supported algorithms. Several alias names are also accepted (from older versions and other software), the list gives names from the RFC. Also the plain algo number is accepted. .TP \fB-b \fI\fR Use this many bits for the key length. .TP \fB-k\fR When given, generate a key signing key. This just sets the flag field to 257 instead of 256 in the DNSKEY RR in the .key file. .TP \fB-r \fIdevice\fR Make ldns-keygen use this file to seed the random generator with. This will default to /dev/random. .TP \fB-v\fR Show the version and exit .SH AUTHOR Written by the ldns team as an example for ldns usage. .SH REPORTING BUGS Report bugs to . .SH COPYRIGHT Copyright (C) 2005-2008 NLnet Labs. This is free software. There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. ldns-1.6.17/examples/ldns-gen-zone.c0000664000175100017510000003121712264060151016561 0ustar willemwillem/* * Reads a zone file from disk and prints it to stdout, one RR per line. * Adds artificial DS records and RRs. * For the purpose of generating a test zone file * * (c) SIDN 2010/2011 - Marco Davids/Miek Gieben * * See the LICENSE file for the license */ #include "config.h" #include #include #include #include #define NUM_DS 4 /* maximum of 4 DS records per delegation */ #define ALGO 8 /* Algorithm to use for fake DS records - RSASHA256 - RFC5702 */ #define DIGESTTYPE 2 /* Digest type to use for fake DS records - SHA-256 - RFC 4509 */ /** * Usage function. * */ static void usage(FILE *fp, char *prog) { fprintf(fp, "\n\nUsage: %s [-hsv] [-ap NUM] [-o ORIGIN] []\n", prog); fprintf(fp, "\tReads a zonefile and add some artificial NS RRsets and DS records.\n"); fprintf(fp, "\tIf no zonefile is given, the zone is read from stdin.\n"); fprintf(fp, "\t-a add NUM artifical delegations (NS RRSets) to output.\n"); fprintf(fp, "\t-p add NUM percent of DS RRset's to the NS RRsets (1-%d RR's per DS RRset).\n", NUM_DS); fprintf(fp, "\t-o ORIGIN sets an $ORIGIN, which can be handy if the one in the zonefile is set to @.\n"); fprintf(fp, "\t-s if input zone file is already sorted and canonicalized (ie all lowercase),\n\t use this option to speed things up while inserting DS records.\n"); fprintf(fp, "\t-h show this text.\n"); fprintf(fp, "\t-v shows the version and exits.\n"); fprintf(fp, "\nif no file is given standard input is read.\n\n"); } /** * Insert the DS records, return the amount added. * */ static int insert_ds(ldns_rdf *dsowner, uint32_t ttl) { int d, dsrand; int keytag = 0; char *dsownerstr; char digeststr[70]; /** * Average the amount of DS records per delegation a little. */ dsrand = 1+rand() % NUM_DS; for(d = 0; d < dsrand; d++) { keytag = 1+rand() % 65535; /** * Dynamic hashes method below is still too slow... 20% slower than a fixed string... * * We assume RAND_MAX is 32 bit, http://www.gnu.org/s/libc/manual/html_node/ISO-Random.html * 2147483647 or 0x7FFFFFFF */ snprintf(digeststr, 65, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x", (unsigned) rand()%RAND_MAX, (unsigned) rand()%RAND_MAX, (unsigned) rand()%RAND_MAX, (unsigned) rand()%RAND_MAX, (unsigned) rand()%RAND_MAX, (unsigned) rand()%RAND_MAX, (unsigned) rand()%RAND_MAX, (unsigned) rand()%RAND_MAX, (unsigned) rand()%RAND_MAX, (unsigned) rand()%RAND_MAX, (unsigned) rand()%RAND_MAX, (unsigned) rand()%RAND_MAX, (unsigned) rand()%RAND_MAX, (unsigned) rand()%RAND_MAX, (unsigned) rand()%RAND_MAX, (unsigned) rand()%RAND_MAX); dsownerstr = ldns_rdf2str(dsowner); fprintf(stdout, "%s\t%u\tIN\tDS\t%d %d %d %s\n", dsownerstr, (unsigned) ttl, keytag, ALGO, DIGESTTYPE, digeststr); } return dsrand; } int main(int argc, char **argv) { char *filename, *rrstr, *ownerstr; const char *classtypestr1 = "IN NS ns1.example.com."; const char *classtypestr2 = "IN NS ns2.example.com."; const size_t classtypelen = strlen(classtypestr1); /* Simply because this was developed by SIDN and we don't use xn-- for .nl :-) */ const char *punystr = "xn--fake-rr"; const size_t punylen = strlen(punystr); size_t rrstrlen, ownerlen; FILE *fp; int c, nsrand; uint32_t ttl; int counta,countd,countr; ldns_zone *z; ldns_rdf *origin = NULL; int line_nr = 0; int addrrs = 0; int dsperc = 0; bool canonicalize = true; bool sort = true; bool do_ds = false; ldns_status s; size_t i; ldns_rr_list *rrset_list; ldns_rdf *owner; ldns_rr_type cur_rr_type; ldns_rr *cur_rr; ldns_status status; counta = countd = countr = 0; /** * Set some random seed. */ srand((unsigned int)time(NULL)); /** * Commandline options. */ while ((c = getopt(argc, argv, "a:p:shvo:")) != -1) { switch (c) { case 'a': addrrs = atoi(optarg); if (addrrs <= 0) { fprintf(stderr, "error\n"); exit(EXIT_FAILURE); } break; case 'o': origin = ldns_rdf_new_frm_str(LDNS_RDF_TYPE_DNAME, optarg); if (!origin) { fprintf(stderr, "error: creating origin from -o %s failed.\n", optarg); exit(EXIT_FAILURE); } break; case 'p': dsperc = atoi(optarg); if (dsperc < 0 || dsperc > 100) { fprintf(stderr, "error: percentage of signed delegations must be between [0-100].\n"); exit(EXIT_FAILURE); } do_ds = true; break; case 's': sort = false; canonicalize = false; break; case 'h': usage(stdout, argv[0]); exit(EXIT_SUCCESS); case 'v': fprintf(stdout, "ldns-gen-zone version %s (ldns version %s)\n", LDNS_VERSION, ldns_version()); exit(EXIT_SUCCESS); default: fprintf(stderr, "\nTry -h for more information.\n\n"); exit(EXIT_FAILURE); } } argc -= optind; argv += optind; /** * Read zone. */ if (argc == 0) { fp = stdin; } else { filename = argv[0]; fp = fopen(filename, "r"); if (!fp) { fprintf(stderr, "Unable to open %s: %s\n", filename, strerror (errno)); exit(EXIT_FAILURE); } } s = ldns_zone_new_frm_fp_l(&z, fp, origin, 0, LDNS_RR_CLASS_IN, &line_nr); if (s != LDNS_STATUS_OK) { fprintf(stderr, "%s at %d\n", ldns_get_errorstr_by_id(s), line_nr); exit(EXIT_FAILURE); } if (!ldns_zone_soa(z)) { fprintf(stderr, "No zone data seen\n"); exit(EXIT_FAILURE); } ttl = ldns_rr_ttl(ldns_zone_soa(z)); if (!origin) { origin = ldns_rr_owner(ldns_zone_soa(z)); // Check for root (.) origin here TODO(MG) } ownerstr = ldns_rdf2str(origin); if (!ownerstr) { fprintf(stderr, "ldns_rdf2str(origin) failed\n"); exit(EXIT_FAILURE); } ownerlen = strlen(ownerstr); ldns_rr_print(stdout, ldns_zone_soa(z)); if (addrrs > 0) { while (addrrs > counta) { counta++; rrstrlen = punylen + ownerlen + classtypelen + 4; rrstrlen *= 2; /* estimate */ rrstr = (char*)malloc(rrstrlen); if (!rrstr) { fprintf(stderr, "malloc() failed: Out of memory\n"); exit(EXIT_FAILURE); } (void)snprintf(rrstr, rrstrlen, "%s%d.%s %u %s", punystr, counta, ownerstr, (unsigned) ttl, classtypestr1); status = ldns_rr_new_frm_str(&cur_rr, rrstr, 0, NULL, NULL); if (status == LDNS_STATUS_OK) { ldns_rr_print(stdout, cur_rr); ldns_rr_free(cur_rr); } else { fprintf(stderr, "ldns_rr_new_frm_str() failed\n"); exit(EXIT_FAILURE); } (void)snprintf(rrstr, rrstrlen, "%s%d.%s %u %s", punystr, counta, ownerstr, (unsigned) ttl, classtypestr2); status = ldns_rr_new_frm_str(&cur_rr, rrstr, 0, NULL, NULL); if (status == LDNS_STATUS_OK) { ldns_rr_print(stdout, cur_rr); } else { fprintf(stderr, "ldns_rr_new_frm_str() failed\n"); exit(EXIT_FAILURE); } free(rrstr); /* may we add a DS record as well? */ if (do_ds) { /* * Per definition this may not be the same as the origin, so no * check required same for NS check - so the only thing left is some * randomization. */ nsrand = rand() % 100; if (nsrand < dsperc) { owner = ldns_rr_owner(cur_rr); ttl = ldns_rr_ttl(cur_rr); countd += insert_ds(owner, ttl); } } ldns_rr_free(cur_rr); } } if (!do_ds) { ldns_rr_list_print(stdout, ldns_zone_rrs(z)); } else { /* * We use dns_rr_list_pop_rrset and that requires a sorted list weird things may happen * if the -s option was used on unsorted, non-canonicalized input */ if (canonicalize) { ldns_rr2canonical(ldns_zone_soa(z)); for (i = 0; i < ldns_rr_list_rr_count(ldns_zone_rrs(z)); i++) { ldns_rr2canonical(ldns_rr_list_rr(ldns_zone_rrs(z), i)); } } if (sort) { ldns_zone_sort(z); } /* Work on a per RRset basis for DS records - weird things will happen if the -s option * was used in combination with an unsorted zone file */ while((rrset_list = ldns_rr_list_pop_rrset(ldns_zone_rrs(z)))) { owner = ldns_rr_list_owner(rrset_list); cur_rr_type = ldns_rr_list_type(rrset_list); /** * Print them... */ cur_rr = ldns_rr_list_pop_rr(rrset_list); while (cur_rr) { ttl = ldns_rr_ttl(cur_rr); fprintf(stdout, "%s", ldns_rr2str(cur_rr)); cur_rr = ldns_rr_list_pop_rr(rrset_list); } /* * And all the way at the end a DS record if * we are dealing with an NS rrset */ nsrand = rand() % 100; if (nsrand == 0) { nsrand = 100; } if ((cur_rr_type == LDNS_RR_TYPE_NS) && (ldns_rdf_compare(owner, origin) != 0) && (nsrand < dsperc)) { /** * No DS records for the $ORIGIN, only for delegations, obey dsperc. */ countr++; countd += insert_ds(owner, ttl); } ldns_rr_list_free(rrset_list); ldns_rdf_free(owner); } } /** * And done... */ fclose(fp); fprintf(stdout, ";; Added %d DS records (percentage was %d) to %d NS RRset's (from input-zone: %d, from added: %d)\n;; lines in original input-zone: %d\n", countd, dsperc, counta + countr, countr, counta, line_nr); exit(EXIT_SUCCESS); } ldns-1.6.17/examples/ldns-zsplit.10000664000175100017510000000144612264060151016303 0ustar willemwillem.TH ldns-zsplit 1 "15 Dec 2005" .SH NAME ldns-zsplit \- split up a zone file .SH SYNOPSIS .B ldns-zsplit [ .IR OPTIONS ] .IR zonefile .SH DESCRIPTION .SH OPTIONS .TP .B -n NUMBER Split after NUMBER RRs, \fBldns-zsplit\fR will not split in the middle of an RRs. .PP Each part is saved with a numerical suffix, starting with .000. The largest suffix is thus .999. .TP .B -o ORIGIN use ORIGIN as origin when reading the zonefile. .TP .B -z Sort the zone before splitting. .TP .B -v Show version number and exit. .SH AUTHOR Written by the ldns team as an example for ldns usage. .SH REPORTING BUGS Report bugs to . .SH COPYRIGHT Copyright (C) 2005, 2006 NLnet Labs. This is free software. There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. ldns-1.6.17/examples/ldns-keygen.c0000664000175100017510000001742212264060151016323 0ustar willemwillem/* * keygen is a small programs that generate a dnskey and private key * for a particular domain. * * (c) NLnet Labs, 2005 - 2008 * See the file LICENSE for the license */ #include "config.h" #include #include #ifdef HAVE_SSL static void usage(FILE *fp, char *prog) { fprintf(fp, "%s -a [-b bits] [-r /dev/random] [-v] domain\n", prog); fprintf(fp, " generate a new key pair for domain\n"); fprintf(fp, " -a \tuse the specified algorithm (-a list to"); fprintf(fp, " show a list)\n"); fprintf(fp, " -k\t\tset the flags to 257; key signing key\n"); fprintf(fp, " -b \tspecify the keylength\n"); fprintf(fp, " -r \tspecify a random device (defaults to /dev/random)\n"); fprintf(fp, "\t\tto seed the random generator with\n"); fprintf(fp, " -v\t\tshow the version and exit\n"); fprintf(fp, " The following files will be created:\n"); fprintf(fp, " K++.key\tPublic key in RR format\n"); fprintf(fp, " K++.private\tPrivate key in key format\n"); fprintf(fp, " K++.ds\tDS in RR format (only for DNSSEC keys)\n"); fprintf(fp, " The base name (K++ will be printed to stdout\n"); } static void show_algorithms(FILE *out) { ldns_lookup_table *lt = ldns_signing_algorithms; fprintf(out, "Possible algorithms:\n"); while (lt->name) { fprintf(out, "%s\n", lt->name); lt++; } } int main(int argc, char *argv[]) { int c; char *prog; /* default key size */ uint16_t def_bits = 1024; uint16_t bits = def_bits; bool ksk; FILE *file; FILE *random; char *filename; char *owner; ldns_signing_algorithm algorithm; ldns_rdf *domain; ldns_rr *pubkey; ldns_key *key; ldns_rr *ds; prog = strdup(argv[0]); algorithm = 0; random = NULL; ksk = false; /* don't create a ksk per default */ while ((c = getopt(argc, argv, "a:kb:r:v")) != -1) { switch (c) { case 'a': if (algorithm != 0) { fprintf(stderr, "The -a argument can only be used once\n"); exit(1); } if (strncmp(optarg, "list", 5) == 0) { show_algorithms(stdout); exit(EXIT_SUCCESS); } algorithm = ldns_get_signing_algorithm_by_name(optarg); if (algorithm == 0) { fprintf(stderr, "Algorithm %s not found\n", optarg); show_algorithms(stderr); exit(EXIT_FAILURE); } break; case 'b': bits = (uint16_t) atoi(optarg); if (bits == 0) { fprintf(stderr, "%s: %s %d", prog, "Can not parse the -b argument, setting it to the default\n", (int) def_bits); bits = def_bits; } break; case 'k': ksk = true; break; case 'r': random = fopen(optarg, "r"); if (!random) { fprintf(stderr, "Cannot open random file %s: %s\n", optarg, strerror(errno)); exit(EXIT_FAILURE); } break; case 'v': printf("DNSSEC key generator version %s (ldns version %s)\n", LDNS_VERSION, ldns_version()); exit(EXIT_SUCCESS); break; default: usage(stderr, prog); exit(EXIT_FAILURE); } } argc -= optind; argv += optind; if (algorithm == 0) { printf("Please use the -a argument to provide an algorithm\n"); exit(1); } if (argc != 1) { usage(stderr, prog); exit(EXIT_FAILURE); } free(prog); /* check whether key size is within RFC boundaries */ switch (algorithm) { case LDNS_SIGN_RSAMD5: case LDNS_SIGN_RSASHA1: if (bits < 512 || bits > 4096) { fprintf(stderr, "For RSA, the key size must be between "); fprintf(stderr, " 512 and 4096 bytes. Aborting.\n"); exit(1); } break; case LDNS_SIGN_DSA: if (bits < 512 || bits > 4096) { fprintf(stderr, "For DSA, the key size must be between "); fprintf(stderr, " 512 and 1024 bytes. Aborting.\n"); exit(1); } break; #ifdef USE_GOST case LDNS_SIGN_ECC_GOST: if(!ldns_key_EVP_load_gost_id()) { fprintf(stderr, "error: libcrypto does not provide GOST\n"); exit(EXIT_FAILURE); } break; #endif #ifdef USE_ECDSA case LDNS_SIGN_ECDSAP256SHA256: case LDNS_SIGN_ECDSAP384SHA384: #endif case LDNS_SIGN_HMACMD5: case LDNS_SIGN_HMACSHA1: case LDNS_SIGN_HMACSHA256: default: break; } if (!random) { random = fopen("/dev/random", "r"); if (!random) { fprintf(stderr, "Cannot open random file %s: %s\n", optarg, strerror(errno)); exit(EXIT_FAILURE); } } (void)ldns_init_random(random, (unsigned int) bits/8); fclose(random); /* create an rdf from the domain name */ domain = ldns_dname_new_frm_str(argv[0]); /* generate a new key */ key = ldns_key_new_frm_algorithm(algorithm, bits); /* set the owner name in the key - this is a /separate/ step */ ldns_key_set_pubkey_owner(key, domain); /* ksk flag */ if (ksk) { ldns_key_set_flags(key, ldns_key_flags(key) + 1); } /* create the public from the ldns_key */ pubkey = ldns_key2rr(key); if (!pubkey) { fprintf(stderr, "Could not extract the public key from the key structure..."); ldns_key_deep_free(key); exit(EXIT_FAILURE); } owner = ldns_rdf2str(ldns_rr_owner(pubkey)); /* calculate and set the keytag */ ldns_key_set_keytag(key, ldns_calc_keytag(pubkey)); /* build the DS record */ switch (algorithm) { #ifdef USE_ECDSA case LDNS_SIGN_ECDSAP384SHA384: ds = ldns_key_rr2ds(pubkey, LDNS_SHA384); break; case LDNS_SIGN_ECDSAP256SHA256: #endif case LDNS_SIGN_RSASHA256: case LDNS_SIGN_RSASHA512: ds = ldns_key_rr2ds(pubkey, LDNS_SHA256); break; case LDNS_SIGN_ECC_GOST: #ifdef USE_GOST ds = ldns_key_rr2ds(pubkey, LDNS_HASH_GOST); #else ds = ldns_key_rr2ds(pubkey, LDNS_SHA256); #endif break; default: ds = ldns_key_rr2ds(pubkey, LDNS_SHA1); break; } /* print the public key RR to .key */ filename = LDNS_XMALLOC(char, strlen(owner) + 17); snprintf(filename, strlen(owner) + 16, "K%s+%03u+%05u.key", owner, algorithm, (unsigned int) ldns_key_keytag(key)); file = fopen(filename, "w"); if (!file) { fprintf(stderr, "Unable to open %s: %s\n", filename, strerror(errno)); ldns_key_deep_free(key); free(owner); ldns_rr_free(pubkey); ldns_rr_free(ds); LDNS_FREE(filename); exit(EXIT_FAILURE); } else { /* temporarily set question so that TTL is not printed */ ldns_rr_set_question(pubkey, true); ldns_rr_print(file, pubkey); ldns_rr_set_question(pubkey, false); fclose(file); LDNS_FREE(filename); } /* print the priv key to stderr */ filename = LDNS_XMALLOC(char, strlen(owner) + 21); snprintf(filename, strlen(owner) + 20, "K%s+%03u+%05u.private", owner, algorithm, (unsigned int) ldns_key_keytag(key)); file = fopen(filename, "w"); if (!file) { fprintf(stderr, "Unable to open %s: %s\n", filename, strerror(errno)); ldns_key_deep_free(key); free(owner); ldns_rr_free(pubkey); ldns_rr_free(ds); LDNS_FREE(filename); exit(EXIT_FAILURE); } else { ldns_key_print(file, key); fclose(file); LDNS_FREE(filename); } /* print the DS to .ds */ if (algorithm != LDNS_SIGN_HMACMD5 && algorithm != LDNS_SIGN_HMACSHA1 && algorithm != LDNS_SIGN_HMACSHA256) { filename = LDNS_XMALLOC(char, strlen(owner) + 16); snprintf(filename, strlen(owner) + 15, "K%s+%03u+%05u.ds", owner, algorithm, (unsigned int) ldns_key_keytag(key)); file = fopen(filename, "w"); if (!file) { fprintf(stderr, "Unable to open %s: %s\n", filename, strerror(errno)); ldns_key_deep_free(key); free(owner); ldns_rr_free(pubkey); ldns_rr_free(ds); LDNS_FREE(filename); exit(EXIT_FAILURE); } else { /* temporarily set question so that TTL is not printed */ ldns_rr_set_question(ds, true); ldns_rr_print(file, ds); ldns_rr_set_question(ds, false); fclose(file); LDNS_FREE(filename); } } fprintf(stdout, "K%s+%03u+%05u\n", owner, algorithm, (unsigned int) ldns_key_keytag(key)); ldns_key_deep_free(key); free(owner); ldns_rr_free(pubkey); ldns_rr_free(ds); exit(EXIT_SUCCESS); } #else int main(int argc, char **argv) { fprintf(stderr, "ldns-keygen needs OpenSSL support, which has not been compiled in\n"); return 1; } #endif /* HAVE_SSL */ ldns-1.6.17/examples/configure.ac0000664000175100017510000003021412264060151016217 0ustar willemwillem# -*- Autoconf -*- # Process this file with autoconf to produce a configure script. AC_PREREQ(2.56) AC_INIT(ldns, 1.6.17, libdns@nlnetlabs.nl,libdns) AC_CONFIG_SRCDIR([ldns-read-zone.c]) sinclude(../acx_nlnetlabs.m4) OURCPPFLAGS='' CPPFLAGS=${CPPFLAGS:-${OURCPPFLAGS}} OURCFLAGS='-g' CFLAGS=${CFLAGS:-${OURCFLAGS}} AC_DEFINE(WINVER, 0x0502, [the version of the windows API enabled]) AC_AIX # Checks for programs. AC_PROG_CC AC_PROG_MAKE_SET AC_CHECK_PROGS(libtool, [glibtool libtool15 libtool], [../libtool]) ACX_CHECK_COMPILER_FLAG(std=c99, [C99FLAG="-std=c99"]) ACX_CHECK_COMPILER_FLAG(xc99, [C99FLAG="-xc99"]) AC_ARG_ENABLE(rpath, [AC_HELP_STRING([--disable-rpath], [Disable hardcoded rpath (default=enabled)])], enable_rpath=$enableval, enable_rpath=yes) if test "x$enable_rpath" = xyes; then RPATH_VAL="-Wl,-rpath=\${libdir}" fi AC_TYPE_SIZE_T ACX_CHECK_COMPILER_FLAG(O2, [CFLAGS="$CFLAGS -O2"]) ACX_CHECK_COMPILER_FLAG_NEEDED($C99FLAG -D__EXTENSIONS__ -D_BSD_SOURCE -D_POSIX_C_SOURCE=200112 -D_XOPEN_SOURCE=600, [ #include "confdefs.h" #include #include #include #ifdef HAVE_TIME_H #include #endif #include #ifdef HAVE_GETOPT_H #include #endif int test() { int a; char **opts = NULL; struct timeval tv; char *t; time_t time = 0; char *buf = NULL; t = ctime_r(&time, buf); tv.tv_usec = 10; srandom(32); a = getopt(2, opts, "a"); a = isascii(32); return a; } ], [CFLAGS="$CFLAGS $C99FLAG -D__EXTENSIONS__ -D_BSD_SOURCE -D_POSIX_C_SOURCE=200112 -D_XOPEN_SOURCE=600"]) ACX_CHECK_COMPILER_FLAG_NEEDED($C99FLAG, [#include ], [CFLAGS="$CFLAGS $C99FLAG"]) AC_C_INLINE AC_CHECK_TYPE(int8_t, char) AC_CHECK_TYPE(int16_t, short) AC_CHECK_TYPE(int32_t, int) AC_CHECK_TYPE(int64_t, long long) AC_CHECK_TYPE(uint8_t, unsigned char) AC_CHECK_TYPE(uint16_t, unsigned short) AC_CHECK_TYPE(uint32_t, unsigned int) AC_CHECK_TYPE(uint64_t, unsigned long long) AC_CHECK_TYPE(ssize_t, int) AC_CHECK_HEADERS([sys/types.h getopt.h stdlib.h stdio.h assert.h netinet/in.h ctype.h time.h pcap.h arpa/inet.h sys/time.h sys/socket.h sys/select.h netdb.h],,, [AC_INCLUDES_DEFAULT]) AC_CHECK_HEADERS([winsock2.h ws2tcpip.h],,, [AC_INCLUDES_DEFAULT]) AC_CHECK_HEADERS([netinet/in_systm.h net/if.h netinet/ip.h netinet/udp.h netinet/igmp.h netinet/if_ether.h netinet/ip6.h],,, [ AC_INCLUDES_DEFAULT #ifdef HAVE_NETINET_IN_SYSTM_H #include #endif #ifdef HAVE_NETINET_IN_H #include #endif #ifdef HAVE_SYS_SOCKET_H #include #endif #ifdef HAVE_NET_IF_H #include #endif]) ACX_TYPE_SOCKLEN_T AC_CHECK_HEADERS([sys/param.h sys/mount.h],,, [AC_INCLUDES_DEFAULT] [ [ #if HAVE_SYS_PARAM_H # include #endif ] ]) AC_CHECK_TYPE(in_addr_t, [], [AC_DEFINE([in_addr_t], [uint32_t], [in_addr_t])], [ #if HAVE_SYS_TYPES_H # include #endif #if HAVE_NETINET_IN_H # include #endif]) AC_CHECK_TYPE(in_port_t, [], [AC_DEFINE([in_port_t], [uint16_t], [in_port_t])], [ #if HAVE_SYS_TYPES_H # include #endif #if HAVE_NETINET_IN_H # include #endif]) # check to see if libraries are needed for these functions. AC_SEARCH_LIBS(socket, socket) tmp_LIBS="$LIBS" LIBS= AC_SEARCH_LIBS(inet_pton, nsl) AC_SUBST(LIBNSL_LIBS,$LIBS) LIBS="$tmp_LIBS" tmp_CPPFLAGS="$CPPFLAGS" tmp_LDFLAGS="$LDFLAGS" tmp_LIBS="$LIBS" ACX_WITH_SSL_OPTIONAL AC_SUBST(LIBSSL_CPPFLAGS) AC_SUBST(LIBSSL_LDFLAGS) AC_SUBST(LIBSSL_LIBS) if test "x$HAVE_SSL" = "xyes"; then AC_SUBST(LIBSSL_SSL_LIBS, ["-lssl $LIBSSL_LIBS"]) fi CPPFLAGS="$tmp_CPPFLAGS" LDFLAGS="$tmp_LDFLAGS" LIBS="$tmp_LIBS" # use libcrypto to check the following: tmp_LDFLAGS="$LDFLAGS" tmp_LIBS="$LIBS" LDFLAGS="$LDFLAGS $LIBSSL_LDFLAGS" LIBS="$LIBS $LIBSSL_LIBS" AC_ARG_ENABLE(sha2, AC_HELP_STRING([--disable-sha2], [Disable SHA256 and SHA512 RRSIG support])) case "$enable_sha2" in no) ;; *) AC_MSG_CHECKING(for SHA256 and SHA512) AC_CHECK_FUNC(SHA256_Init,, [ AC_MSG_ERROR([SHA2 enabled, but no SHA2 functions found in OpenSSL]) ]) AC_DEFINE_UNQUOTED([USE_SHA2], [1], [Define this to enable SHA256 and SHA512 support.]) ;; esac AC_ARG_ENABLE(gost, AC_HELP_STRING([--disable-gost], [Disable GOST support])) case "$enable_gost" in no) ;; *) if test "x$HAVE_SSL" != "xyes"; then AC_MSG_ERROR([GOST enabled, but no SSL support]) fi AC_MSG_CHECKING(for GOST) AC_CHECK_FUNC(EVP_PKEY_set_type_str, [],[AC_MSG_ERROR([OpenSSL >= 1.0.0 is needed for GOST support or rerun with --disable-gost])]) AC_CHECK_FUNC(EC_KEY_new, [], [AC_MSG_ERROR([No ECC functions found in OpenSSL: please upgrade OpenSSL or rerun with --disable-gost])]) AC_DEFINE_UNQUOTED([USE_GOST], [1], [Define this to enable GOST support.]) ;; esac AC_ARG_ENABLE(ecdsa, AC_HELP_STRING([--disable-ecdsa], [Disable ECDSA support])) case "$enable_ecdsa" in no) ;; *) dnl default if test "x$HAVE_SSL" != "xyes"; then AC_MSG_ERROR([ECDSA enabled, but no SSL support]) fi AC_CHECK_FUNC(ECDSA_sign, [], [AC_MSG_ERROR([OpenSSL does not support ECDSA: please upgrade OpenSSL or rerun with --disable-ecdsa])]) AC_CHECK_FUNC(SHA384_Init, [], [AC_MSG_ERROR([OpenSSL does not support SHA384: please upgrade OpenSSL or rerun with --disable-ecdsa])]) AC_CHECK_DECLS([NID_X9_62_prime256v1, NID_secp384r1], [], [AC_MSG_ERROR([OpenSSL does not support the ECDSA curves: please upgrade OpenSSL or rerun with --disable-ecdsa])], [AC_INCLUDES_DEFAULT #include ]) # we now know we have ECDSA and the required curves. AC_DEFINE_UNQUOTED([USE_ECDSA], [1], [Define this to enable ECDSA support.]) ;; esac AC_ARG_ENABLE(dane, AC_HELP_STRING([--disable-dane], [Disable DANE support])) case "$enable_dane" in no) ;; *) dnl default if test "x$HAVE_SSL" != "xyes"; then AC_MSG_ERROR([DANE enabled, but no SSL support]) fi AC_CHECK_FUNC(X509_check_ca, [], [AC_MSG_ERROR([OpenSSL does not support DANE: please upgrade OpenSSL or rerun with --disable-dane])]) AC_DEFINE_UNQUOTED([USE_DANE], [1], [Define this to enable DANE support.]) ;; esac LDFLAGS="$tmp_LDFLAGS" LIBS="$tmp_LIBS" #AC_CHECK_HEADER(ldns/ldns.h,, [ # AC_MSG_ERROR([Can't find ldns headers (make copy-headers in devel source.)]) # ], [AC_INCLUDES_DEFAULT] #) AC_CHECK_LIB(pcap, pcap_open_offline,, [ AC_MSG_WARN([Can't find pcap library (needed for ldns-dpa, will not build dpa now.)]) ] ) AC_DEFUN([AC_CHECK_GETADDRINFO_WITH_INCLUDES], [AC_REQUIRE([AC_PROG_CC]) AC_MSG_CHECKING(for getaddrinfo) AC_CACHE_VAL(ac_cv_func_getaddrinfo, [ac_cv_func_getaddrinfo=no AC_LINK_IFELSE( [ #ifdef __cplusplus extern "C" { #endif char* getaddrinfo(); char* (*f) () = getaddrinfo; #ifdef __cplusplus } #endif int main() { ; return 0; } ], dnl this case on linux, solaris, bsd [ac_cv_func_getaddrinfo="yes"], dnl no quick getaddrinfo, try mingw32 and winsock2 library. ORIGLIBS="$LIBS" LIBS="$LIBS -lws2_32" AC_LINK_IFELSE( AC_LANG_PROGRAM( [ #ifdef HAVE_WS2TCPIP_H #include #endif ], [ (void)getaddrinfo(NULL, NULL, NULL, NULL); ] ), [ac_cv_func_getaddrinfo="yes" LDFLAGS="$LDFLAGS -lws2_32" ], [ac_cv_func_getaddrinfo="no" LIBS="$ORIGLIBS" ]) ) ]) AC_MSG_RESULT($ac_cv_func_getaddrinfo) if test $ac_cv_func_getaddrinfo = yes; then AC_DEFINE(HAVE_GETADDRINFO, 1, [Whether getaddrinfo is available]) fi ])dnl AC_CHECK_GETADDRINFO_WITH_INCLUDES AC_FUNC_FORK AC_CHECK_FUNCS(isblank srandom random sleep) AC_CHECK_DECLS([in6addr_any],,,[AC_INCLUDES_DEFAULT #ifdef HAVE_SYS_SOCKET_H #include #endif #ifdef HAVE_TIME_H #include #endif #ifdef HAVE_SYS_TIME_H #include #endif #ifdef HAVE_SYS_SELECT_H #include #endif #ifdef HAVE_ARPA_INET_H #include #endif #ifdef HAVE_NETINET_IN_H #include #endif #ifdef HAVE_NETINET_UDP_H #include #endif #ifdef HAVE_NETINET_IGMP_H #include #endif ]) # check for ldns AC_ARG_WITH(ldns, AC_HELP_STRING([--with-ldns=PATH specify prefix of path of ldns library to use]) , [ specialldnsdir="$withval" CPPFLAGS="$CPPFLAGS -I$withval/include" LDFLAGS="-L$withval -L$withval/lib $LDFLAGS" LDNSDIR="$withval" ] ) # check for ldns development source tree AC_MSG_CHECKING([for ldns devel source]) ldns_dev_dir=.. if test -f $ldns_dev_dir/ldns/util.h && \ grep LDNS_VERSION $ldns_dev_dir/ldns/util.h >/dev/null; then ldns_version=`grep LDNS_VERSION $ldns_dev_dir/ldns/util.h | sed -e 's/^.*"\(.*\)".*$/\1/'` AC_MSG_RESULT([using $ldns_dev_dir with $ldns_version]) CPPFLAGS="$CPPFLAGS -I$ldns_dev_dir/include" LDFLAGS="-L$ldns_dev_dir -L$ldns_dev_dir/lib $LDFLAGS" LIBS="$LIBS -lldns" AC_DEFINE(HAVE_LIBLDNS, 1, [If the ldns library is available.]) LDNSDIR="$ldns_dev_dir" else AC_MSG_RESULT([no]) AC_CHECK_LIB(ldns, ldns_rr_new,, [ AC_MSG_ERROR([Can't find ldns library])dnl' ] ) fi AC_SUBST(LDNSDIR) AC_ARG_WITH(trust-anchor, AC_HELP_STRING([--with-trust-anchor=KEYFILE], [Default location of the trust anchor file for drill and ldns-dane. [default=SYSCONFDIR/unbound/root.key]]), [ LDNS_TRUST_ANCHOR_FILE="$withval" ],[ if test "x$LDNS_TRUST_ANCHOR_FILE" = "x"; then if test "x$sysconfdir" = 'x${prefix}/etc' ; then if test "x$prefix" = 'xNONE' ; then LDNS_TRUST_ANCHOR_FILE="/etc/unbound/root.key" else LDNS_TRUST_ANCHOR_FILE="${prefix}/etc/unbound/root.key" fi else LDNS_TRUST_ANCHOR_FILE="${sysconfdir}/unbound/root.key" fi fi ]) AC_DEFINE_UNQUOTED([LDNS_TRUST_ANCHOR_FILE], ["$LDNS_TRUST_ANCHOR_FILE"], [Default trust anchor file]) AC_SUBST(LDNS_TRUST_ANCHOR_FILE) AC_MSG_NOTICE([Default trust anchor: $LDNS_TRUST_ANCHOR_FILE]) AC_ARG_WITH(ca-file, AC_HELP_STRING([--with-ca-file=CAFILE], [File containing CA certificates for ldns-dane]), [ AC_DEFINE([HAVE_DANE_CA_FILE], [1], [Is a CAFILE given at configure time]) AC_DEFINE_UNQUOTED([LDNS_DANE_CA_FILE], ["$withval"], [Is a CAFILE given at configure time]) AC_MSG_NOTICE([Using CAfile: $withval]) AC_SUBST(DEFAULT_CAFILE, ["Default is $withval"]) ],[ AC_DEFINE([HAVE_DANE_CA_FILE], [0], [Is a CAFILE given at configure time]) AC_SUBST(DEFAULT_CAFILE, []) ]) AC_ARG_WITH(ca-path, AC_HELP_STRING([--with-ca-path=CAPATH], [Directory containing CA certificate files for ldns-dane]), [ AC_DEFINE([HAVE_DANE_CA_PATH], [1], [Is a CAPATH given at configure time]) AC_DEFINE_UNQUOTED([LDNS_DANE_CA_PATH], ["$withval"], [Is a CAPATH given at configure time]) AC_MSG_NOTICE([Using CApath: $withval]) AC_SUBST(DEFAULT_CAPATH, ["Default is $withval"]) ],[ AC_DEFINE([HAVE_DANE_CA_PATH], [0], [Is a CAPATH given at configure time]) AC_SUBST(DEFAULT_CAPATH, []) ]) AH_BOTTOM([ #include #include #include #include #if STDC_HEADERS #include #include #endif #ifdef HAVE_STDINT_H #include #endif #ifdef HAVE_SYS_SOCKET_H #include #endif #ifdef HAVE_NETINET_IN_H #include #endif #ifdef HAVE_ARPA_INET_H #include #endif #ifdef HAVE_NETINET_UDP_H #include #endif #ifdef HAVE_TIME_H #include #endif #ifdef HAVE_PCAP_H #include #endif #ifdef HAVE_NETINET_IN_SYSTM_H #include #endif #ifdef HAVE_NETINET_IP_H #include #endif #ifdef HAVE_NET_IF_H #include #endif #ifdef HAVE_NETINET_IF_ETHER_H #include #endif #ifdef HAVE_WINSOCK2_H #define USE_WINSOCK 1 #include #endif #ifdef HAVE_WS2TCPIP_H #include #endif #ifndef HAVE_GETADDRINFO #include #endif #ifndef HAVE_RANDOM /* random can be replaced by rand for ldnsexamples */ #define random rand #endif #ifndef HAVE_SRANDOM /* srandom can be replaced by srand for ldnsexamples */ #define srandom srand #endif extern char *optarg; extern int optind, opterr; #ifndef EXIT_FAILURE #define EXIT_FAILURE 1 #endif #ifndef EXIT_SUCCESS #define EXIT_SUCCESS 0 #endif #ifdef S_SPLINT_S #define FD_ZERO(a) /* a */ #define FD_SET(a,b) /* a, b */ #endif ]) AC_CONFIG_FILES([Makefile ldns-dane.1 ldns-verify-zone.1]) AC_CONFIG_HEADER([config.h]) AC_OUTPUT ldns-1.6.17/examples/ldns-resolver.10000664000175100017510000000141712264060151016615 0ustar willemwillem.TH ldns-resolver 1 "27 Apr 2005" .SH NAME ldns-resolver \- tries to create a resolver from a resolv.conf file. .SH SYNOPSIS .B ldns-resolver .IR file .SH DESCRIPTION \fBldns-resolver\fR tries to create a resolver from a resolv.conf file. This is only useful to test the library for robusteness with input data. .SH OPTIONS \fBldns-resolver\fR takes a filename of the resolv.conf file as input. For example \fIldns-resolver /etc/resolv.conf\fR will show if the file can be parsed successfully. .SH AUTHOR Written by the ldns team as an example for ldns usage. .SH REPORTING BUGS Report bugs to . .SH COPYRIGHT Copyright (C) 2005 NLnet Labs. This is free software. There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. ldns-1.6.17/examples/ldns-zcat.c0000664000175100017510000001007112264060151015773 0ustar willemwillem/* * read a zone that is split up with ldns-zsplit and re-create * the original zone * * From: * zone1: SOA a b c d e f * zone2: SOA f g h i k l * * Go back to: * zone: SOA a b c d e f g h i j k l * * This is useful in combination with ldns-zsplit * * See the file LICENSE for the license */ #include "config.h" #include #include #define FIRST_ZONE 0 #define MIDDLE_ZONE 1 #define LAST_ZONE 2 static void usage(FILE *f, char *progname) { fprintf(f, "Usage: %s [OPTIONS] \n", progname); fprintf(f, " Concatenate signed zone snippets created with ldns-zsplit\n"); fprintf(f, " back together. The generate zone file is printed to stdout\n"); fprintf(f, " The new zone should be equal to the original zone (before splitting)\n"); fprintf(f, "OPTIONS:\n"); fprintf(f, "-o ORIGIN\tUse this as initial origin, for zones starting with @\n"); fprintf(f, "-v\t\tShow the version number and exit\n"); } int main(int argc, char **argv) { char *progname; FILE *fp; int c; ldns_rdf *origin; size_t i, j; int where; ldns_zone *z; ldns_rr_list *zrr; ldns_rr *current_rr; ldns_rr *soa; ldns_rdf *last_owner; ldns_rr *last_rr; ldns_rr *pop_rr; progname = strdup(argv[0]); origin = NULL; while ((c = getopt(argc, argv, "o:v")) != -1) { switch(c) { case 'o': origin = ldns_dname_new_frm_str(strdup(optarg)); if (!origin) { fprintf(stderr, "Cannot convert the origin %s to a domainname\n", optarg); exit(EXIT_FAILURE); } break; case 'v': printf("zone file concatenator version %s (ldns version %s)\n", LDNS_VERSION, ldns_version()); exit(EXIT_SUCCESS); break; default: fprintf(stderr, "Unrecognized option\n"); usage(stdout, progname); exit(EXIT_FAILURE); } } argc -= optind; argv += optind; if (argc < 1) { usage(stdout, progname); exit(EXIT_FAILURE); } for (i = 0; i < (size_t)argc; i++) { if (!(fp = fopen(argv[i], "r"))) { fprintf(stderr, "Error opening key file %s: %s\n", argv[i], strerror(errno)); exit(EXIT_FAILURE); } if (ldns_zone_new_frm_fp(&z, fp, origin, 0, 0) != LDNS_STATUS_OK) { fprintf(stderr, "Zone file %s could not be parsed correctly\n", argv[i]); exit(EXIT_FAILURE); } zrr = ldns_zone_rrs(z); soa = ldns_zone_soa(z); /* SOA is stored separately */ fprintf(stderr, "%s\n", argv[i]); if (0 == i) { where = FIRST_ZONE; /* remove the last equal named RRs */ last_rr = ldns_rr_list_pop_rr(zrr); last_owner = ldns_rr_owner(last_rr); /* remove until no match */ do { pop_rr = ldns_rr_list_pop_rr(zrr); } while(ldns_rdf_compare(last_owner, ldns_rr_owner(pop_rr)) == 0) ; /* we popped one to many, put it back */ ldns_rr_list_push_rr(zrr, pop_rr); } else if ((size_t)(argc - 1) == i) { where = LAST_ZONE; } else { where = MIDDLE_ZONE; /* remove the last equal named RRs */ last_rr = ldns_rr_list_pop_rr(zrr); last_owner = ldns_rr_owner(last_rr); /* remove until no match */ do { pop_rr = ldns_rr_list_pop_rr(zrr); } while(ldns_rdf_compare(last_owner, ldns_rr_owner(pop_rr)) == 0) ; /* we popped one to many, put it back */ ldns_rr_list_push_rr(zrr, pop_rr); } /* printing the RRs */ for (j = 0; j < ldns_rr_list_rr_count(zrr); j++) { current_rr = ldns_rr_list_rr(zrr, j); switch(where) { case FIRST_ZONE: if (soa) { ldns_rr_print(stdout, soa); soa = NULL; } break; case MIDDLE_ZONE: /* rm SOA */ /* SOA isn't printed by default */ /* rm SOA aux records * this also takes care of the DNSKEYs + RRSIGS */ if (ldns_rdf_compare(ldns_rr_owner(current_rr), ldns_rr_owner(soa)) == 0) { continue; } break; case LAST_ZONE: /* rm SOA */ /* SOA isn't printed by default */ /* rm SOA aux records * this also takes care of the DNSKEYs + RRSIGS */ if (ldns_rdf_compare(ldns_rr_owner(current_rr), ldns_rr_owner(soa)) == 0) { continue; } break; } ldns_rr_print(stdout, current_rr); } } exit(EXIT_SUCCESS); } ldns-1.6.17/examples/ldns-read-zone.10000664000175100017510000000534512264060151016644 0ustar willemwillem.TH ldns-read-zone 1 "30 May 2005" .SH NAME ldns-read-zone \- read a zonefile and print it .SH SYNOPSIS .B ldns-read-zone .IR ZONEFILE .SH DESCRIPTION \fBldns-read-zone\fR reads a DNS zone file and prints it. The output has 1 resource record per line, and no pretty-printing makeup. .SH OPTIONS .TP \fB-c\fR Canonicalize all resource records in the zone before printing .TP \fB-d\fR Only print DNSSEC data from the zone. This option skips every record that is not of type NSEC, NSEC3, RRSIG or DNSKEY. DS records are not printed. .TP \fB-b\fR Include Bubble Babble encoding of DS's. .TP \fB-0\fR Print a (null) for the RRSIG inception, expiry and key data. This option can be used when comparing different signing systems that use the same DNSKEYs for signing but would have a slightly different timings/jitter. .TP \fB-h\fR Show usage and exit .TP \fB-n\fR Do not print the SOA record .TP \fB-p\fR Pad the SOA serial number with spaces so the number and the spaces together take ten characters. This is useful for in file serial number increments. .TP \fB-s\fR Strip DNSSEC data from the zone. This option skips every record that is of type NSEC, NSEC3, RRSIG or DNSKEY. DS records are still printed. .TP \fB-S\fR \fI[[+|0]number | YYYYMMDDxx | unixtime ]\fR Set serial number to the given \fInumber\fR, or when preceded by a sign, offset the exisiting number with it. When giving the literal strings \fIYYYYMMDDxx\fR or \fIunixtime\fR, the serial number is tried to be reset in datecounter or in unixtime format respectively. Though is the updated serial number is smaller than the original one, the original one is simply increased by one. When updating a serial number, records of type NSEC, NSEC3, RRSIG and DNSKEY will be skipped when printing the zone. .TP \fB-u\fR \fIRR type\fR Mark \fIRR type\fR for printing in unknown type format. \fB-u\fR is not meant to be used together with \fB-U\fR. .TP \fB-U\fR \fIRR type\fR Mark \fIRR type\fR for \fBnot\fR printing in unknown type format. The first occurrence of the \fB-U\fR option marks all RR types for printing in unknown type format except for the given \fIRR type\fR. Subsequent \fB-U\fR options will clear the mark for those \fIRR type\fRs too, so that only the given \fIRR type\fRs will be printed in the presentation format specific for those \fIRR type\fRs. \fB-U\fR is not meant to be used together with \fB-u\fR. .TP \fB-v\fR Show the version and exit .TP \fB-z\fR Sort the zone before printing (this implies -c) .SH AUTHOR Written by the ldns team as an example for ldns usage. .SH REPORTING BUGS Report bugs to . .SH COPYRIGHT Copyright (C) 2005 NLnet Labs. This is free software. There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. ldns-1.6.17/examples/ldns-signzone.10000664000175100017510000001136012264060151016606 0ustar willemwillem.TH ldns-signzone 1 "30 May 2005" .SH NAME ldns-signzone \- sign a zonefile with DNSSEC data .SH SYNOPSIS .B ldns-signzone [ .IR OPTIONS ] .IR ZONEFILE .IR KEY [KEY [KEY] ... ] .SH DESCRIPTION \fBldns-signzone\fR is used to generate a DNSSEC signed zone. When run it will create a new zonefile that contains RRSIG and NSEC resource records, as specified in RFC 4033, RFC 4034 and RFC 4035. Keys must be specified by their base name (i.e. without .private). If the DNSKEY that belongs to the key in the .private file is not present in the zone, it will be read from the file .key. If that file does not exist, the DNSKEY value will be generated from the private key. Multiple keys can be specified, Key Signing Keys are used as such when they are either already present in the zone, or specified in a .key file, and have the KSK bit set. .SH OPTIONS .TP \fB-b\fR Augments the zone and the RR's with extra comment texts for a more readable layout, easier to debug. DS records will have a bubblebabble version of the data in the comment text, NSEC3 records will have the original NSEC3 in the comment text. Without this option, only DNSKEY RR's will have their Key Tag annotated in the comment text. .TP \fB-d\fR Normally, if the DNSKEY RR for a key that is used to sign the zone is not found in the zone file, it will be read from .key, or derived from the private key (in that order). This option turns that feature off, so that only the signatures are added to the zone. .TP \fB-e\fR \fIdate\fR Set expiration date of the signatures to this date, the format can be YYYYMMDD[hhmmss], or a timestamp. .TP \fB-f\fR \fIfile\fR Use this file to store the signed zone in (default .signed) .TP \fB-i\fR \fIdate\fR Set inception date of the signatures to this date, the format can be YYYYMMDD[hhmmss], or a timestamp. .TP \fB-o\fR \fIorigin\fR Use this as the origin of the zone .TP \fB-v\fR Print the version and exit .TP \fB-A\fR Sign the DNSKEY record with all keys. By default it is signed with a minimal number of keys, to keep the response size for the DNSKEY query small, and only the SEP keys that are passed are used. If there are no SEP keys, the DNSKEY RRset is signed with the non\-SEP keys. This option turns off the default and all keys are used to sign the DNSKEY RRset. .TP \fB-E\fR \fIname\fR Use the EVP cryptographic engine with the given name for signing. This can have some extra options; see ENGINE OPTIONS for more information. .TP \fB-k\fR \fIid,int\fR Use the key with the given id as the signing key for algorithm int as a Zone signing key. This option is used when you use an OpenSSL engine, see ENGINE OPTIONS for more information. .TP \fB-K\fR \fIid,int\fR Use the key with the given id as the signing key for algorithm int as a Key signing key. This options is used when you use an OpenSSL engine, see ENGINE OPTIONS for more information. .TP \fB-n\fR Use NSEC3 instead of NSEC. .TP If you use NSEC3, you can specify the following extra options: .TP \fB-a\fR \fIalgorithm\fR Algorithm used to create the hashed NSEC3 owner names .TP \fB-p\fR Opt-out. All NSEC3 records in the zone will have the Opt-out flag set. After signing, you can add insecure delegations to the signed zone. .TP \fB-s\fR \fIstring\fR Salt .TP \fB-t\fR \fInumber\fR Number of hash iterations .SH ENGINE OPTIONS You can modify the possible engines, if supported, by setting an OpenSSL configuration file. This is done through the environment variable OPENSSL_CONF. If you use -E with a non-existent engine name, ldns-signzone will print a list of engines supported by your configuration. The key options (-k and -K) work as follows; you specify a key id, and a DNSSEC algorithm number (for instance, 5 for RSASHA1). The key id can be any of the following: : id_ slot_-id_ label_