19 #ifdef HAVE_SYS_SOCKET_H
20 #include <sys/socket.h>
22 #ifdef HAVE_ARPA_INET_H
23 #include <arpa/inet.h>
32 #include <openssl/bn.h>
33 #include <openssl/rsa.h>
35 #include <openssl/dsa.h>
39 #ifndef INET_ADDRSTRLEN
40 #define INET_ADDRSTRLEN 16
42 #ifndef INET6_ADDRSTRLEN
43 #define INET6_ADDRSTRLEN 46
69 { LDNS_ED25519,
"ED25519"},
72 { LDNS_ED448,
"ED448"},
200 if (lt && lt->
name) {
205 return ldns_buffer_status(output);
212 if (lt && lt->
name) {
217 return ldns_buffer_status(output);
226 if (lt && lt->
name) {
231 return ldns_buffer_status(output);
240 if (lt && lt->
name) {
246 return ldns_buffer_status(output);
357 for(i = 0; i < len; i++) {
361 c = (
unsigned char) data[src_pos];
362 if(c ==
'.' || c ==
';' ||
363 c ==
'(' || c ==
')' ||
367 }
else if (!(isascii(c) && isgraph(c))) {
382 return ldns_buffer_status(output);
390 return ldns_buffer_status(output);
398 return ldns_buffer_status(output);
406 return ldns_buffer_status(output);
416 memset(&tm, 0,
sizeof(tm));
418 && strftime(date_buf, 15,
"%Y%m%d%H%M%S", &tm)) {
421 return ldns_buffer_status(output);
432 return ldns_buffer_status(output);
444 return ldns_buffer_status(output);
449 size_t amount,
const uint8_t* characters)
454 if (isprint((
int)ch) || ch ==
'\t') {
455 if (ch ==
'\"' || ch ==
'\\')
461 (
unsigned)(uint8_t) ch);
477 ldns_characters2buffer_str(output,
480 return ldns_buffer_status(output);
491 return ldns_buffer_status(output);
502 return ldns_buffer_status(output);
523 return ldns_buffer_status(output);
534 return ldns_buffer_status(output);
543 if (! ldns_output_format_covers_type(fmt, data) &&
551 return ldns_buffer_status(output);
557 return ldns_rdf2buffer_str_type_fmt(output,
573 return ldns_buffer_status(output);
587 return ldns_buffer_status(output);
597 loc_cm_print(
ldns_buffer *output, uint8_t mantissa, uint8_t exponent)
609 for(i=0; i<exponent-2; i++)
637 if (descriptor && descriptor->
_name) {
643 return ldns_buffer_status(output);
679 return ldns_buffer_status(output);
707 uint8_t horizontal_precision;
708 uint8_t vertical_precision;
718 uint32_t equator = (uint32_t) ldns_power(2, 31);
736 if (latitude > equator) {
738 latitude = latitude - equator;
741 latitude = equator - latitude;
743 h = latitude / (1000 * 60 * 60);
744 latitude = latitude % (1000 * 60 * 60);
745 m = latitude / (1000 * 60);
746 latitude = latitude % (1000 * 60);
747 s = (double) latitude / 1000.0;
749 h, m, s, northerness);
751 if (longitude > equator) {
753 longitude = longitude - equator;
756 longitude = equator - longitude;
758 h = longitude / (1000 * 60 * 60);
759 longitude = longitude % (1000 * 60 * 60);
760 m = longitude / (1000 * 60);
761 longitude = longitude % (1000 * 60);
762 s = (double) longitude / (1000.0);
764 h, m, s, easterness);
767 s = ((double) altitude) / 100;
770 if(altitude%100 != 0)
777 loc_cm_print(output, (size & 0xf0) >> 4, size & 0x0f);
780 loc_cm_print(output, (horizontal_precision & 0xf0) >> 4,
781 horizontal_precision & 0x0f);
784 loc_cm_print(output, (vertical_precision & 0xf0) >> 4,
785 vertical_precision & 0x0f);
788 return ldns_buffer_status(output);
818 struct protoent *protocol;
819 char *proto_name = NULL;
821 struct servent *service;
822 uint16_t current_service;
828 protocol = getprotobynumber((
int) protocol_nr);
829 if (protocol && (protocol->p_name != NULL)) {
830 proto_name = protocol->p_name;
836 #ifdef HAVE_ENDPROTOENT
840 for (current_service = 0;
841 current_service < (
ldns_rdf_size(rdf)-1)*8; current_service++) {
843 service = getservbyport((
int) htons(current_service),
845 if (service && service->s_name) {
850 #ifdef HAVE_ENDSERVENT
855 return ldns_buffer_status(output);
865 uint8_t window_block_nr;
866 uint8_t bitmap_length;
873 window_block_nr = data[pos];
874 bitmap_length = data[pos + 1];
879 for (bit_pos = 0; bit_pos < (bitmap_length) * 8; bit_pos++) {
883 type = 256 * (uint16_t) window_block_nr + bit_pos;
885 if (! ldns_output_format_covers_type(fmt, type) &&
895 pos += (uint16_t) bitmap_length;
897 return ldns_buffer_status(output);
903 return ldns_rdf2buffer_str_nsec_fmt(output,
918 salt_length = data[0];
920 if (salt_length == 0 || ((
size_t)salt_length)+1 >
ldns_rdf_size(rdf)) {
923 for (salt_pos = 0; salt_pos < salt_length; salt_pos++) {
929 return ldns_buffer_status(output);
940 return ldns_buffer_status(output);
947 uint64_t tsigtime = 0;
949 uint64_t d0, d1, d2, d3, d4, d5;
960 tsigtime = (d0<<40) | (d1<<32) | (d2<<24) | (d3<<16) | (d4<<8) | d5;
964 return ldns_buffer_status(output);
971 uint16_t address_family;
981 address_family = ldns_read_uint16(&data[pos]);
982 prefix = data[pos + 2];
992 for (i = 0; i < 4; i++) {
996 if (i < (
unsigned short) adf_length) {
1013 for (i = 0; i < 16; i++) {
1014 if (i % 2 == 0 && i > 0) {
1017 if (i < (
unsigned short) adf_length) {
1031 "Unknown address family: %u data: ",
1033 for (i = 1; i < (
unsigned short) (4 + adf_length); i++) {
1039 pos += 4 + adf_length;
1041 return ldns_buffer_status(output);
1053 size = ldns_b64_ntop_calculate_size(
ldns_rdf_size(rdf) - 2);
1068 return ldns_buffer_status(output);
1079 uint8_t gateway_type;
1083 uint8_t *gateway_data;
1085 size_t public_key_size;
1086 uint8_t *public_key_data;
1095 precedence = data[0];
1096 gateway_type = data[1];
1097 algorithm = data[2];
1100 switch (gateway_type) {
1153 public_key_data =
LDNS_XMALLOC(uint8_t, public_key_size);
1154 if(!public_key_data) {
1158 memcpy(public_key_data, &data[offset], public_key_size);
1160 public_key_size, public_key_data);
1178 return ldns_buffer_status(output);
1192 return ldns_buffer_status(output);
1205 return ldns_buffer_status(output);
1219 return ldns_buffer_status(output);
1226 const uint8_t* chars;
1237 while (nchars > 0) {
1238 ch = (char)*chars++;
1239 if (! isalnum((
unsigned char)ch)) {
1245 return ldns_buffer_status(output);
1253 ldns_characters2buffer_str(output,
1256 return ldns_buffer_status(output);
1271 if ((hit_size = data[0]) == 0 ||
1272 (pk_size = ldns_read_uint16(data + 2)) == 0 ||
1273 rdf_size < (
size_t) hit_size + pk_size + 4) {
1280 for (data += 4; hit_size > 0; hit_size--, data++) {
1284 ldns_buffer_write_u8(output, (uint8_t)
' ');
1287 ldns_b64_ntop_calculate_size(pk_size))) {
1290 (
char *) ldns_buffer_current(output),
1291 ldns_buffer_remaining(output));
1294 written < (
int) ldns_buffer_remaining(output)) {
1299 return ldns_buffer_status(output);
1311 uint8_t discovery_optional;
1315 uint8_t *relay_data;
1323 precedence = data[0];
1324 discovery_optional = ((data[1] & 0x80) >> 7);
1325 relay_type = data[1] & 0x7F;
1328 switch (relay_type) {
1381 precedence, discovery_optional, relay_type);
1386 return ldns_buffer_status(output);
1445 res = ldns_rdf2buffer_str_nsec_fmt(buffer, fmt, rdf);
1451 res = ldns_rdf2buffer_str_type_fmt(buffer, fmt, rdf);
1524 ldns_b32_ext2dname(
const ldns_rdf *rdf)
1532 size = ldns_b32_ntop_calculate_size(
ldns_rdf_size(rdf) - 1);
1553 size_t total_rdfsize = 0;
1560 if (total_rdfsize == 0) {
1562 return ldns_buffer_status(output);
1572 return ldns_buffer_status(output);
1583 if (fmt_st == NULL) {
1591 return ldns_buffer_status(output);
1613 return ldns_rr2buffer_str_rfc3597(output, rr);
1641 status = ldns_buffer_status(output);
1648 (
unsigned long) ldns_read_uint32(
1650 status = ldns_buffer_status(output);
1652 status = ldns_rdf2buffer_str_fmt(output,
1689 }
else if (fmt_st->
flags
1763 key = ldns_b32_ext2dname(
1791 return ldns_buffer_status(output);
1810 return ldns_buffer_status(output);
1869 return ldns_buffer_status(output);
1879 struct timeval time;
1887 if (ldns_buffer_status_ok(output)) {
1948 ";; EDNS: version %u; flags:",
1981 time_tt = (time_t)time.tv_sec;
1983 (
char*)ctime(&time_tt));
1988 return ldns_buffer_status(output);
2019 #if defined(HAVE_SSL) && defined(USE_GOST)
2021 ldns_gost_key2buffer_str(
ldns_buffer *output, EVP_PKEY *p)
2023 unsigned char* pp = NULL;
2030 ret = i2d_PrivateKey(p, &pp);
2041 #if defined(HAVE_SSL) && defined(USE_ED25519)
2043 ldns_ed25519_key2buffer_str(
ldns_buffer *output, EVP_PKEY *p)
2045 unsigned char* pp = NULL;
2052 ret = i2d_PrivateKey(p, &pp);
2054 if(ret != 16 + 32) {
2059 (
size_t)ret-16, pp+16);
2069 #if defined(HAVE_SSL) && defined(USE_ED448)
2071 ldns_ed448_key2buffer_str(
ldns_buffer *output, EVP_PKEY *p)
2073 unsigned char* pp = NULL;
2080 ret = i2d_PrivateKey(p, &pp);
2082 if(ret != 16 + 57) {
2087 (
size_t)ret-16, pp+16);
2097 #if defined(HAVE_SSL)
2100 ldns_print_bignum_b64_line(
ldns_buffer* output,
const char* label,
const BIGNUM* num)
2103 if(!bignumbuf)
return 0;
2108 int i = BN_bn2bin(num, bignumbuf);
2133 unsigned char *bignum;
2148 if (ldns_buffer_status_ok(output)) {
2164 "Algorithm: %u (RSA)\n",
2169 "Algorithm: %u (RSASHA1)\n",
2174 "Algorithm: %u (RSASHA1_NSEC3)\n",
2180 "Algorithm: %u (RSASHA256)\n",
2185 "Algorithm: %u (RSASHA512)\n",
2191 fprintf(stderr,
"Warning: unknown signature ");
2193 "algorithm type %u\n",
2197 "Algorithm: %u (Unknown)\n",
2207 const BIGNUM *n=NULL, *e=NULL, *d=NULL,
2208 *p=NULL, *q=NULL, *dmp1=NULL,
2209 *dmq1=NULL, *iqmp=NULL;
2210 #if OPENSSL_VERSION_NUMBER < 0x10100000 || defined(HAVE_LIBRESSL)
2220 RSA_get0_key(rsa, &n, &e, &d);
2221 RSA_get0_factors(rsa, &p, &q);
2222 RSA_get0_crt_params(rsa, &dmp1,
2225 if(!ldns_print_bignum_b64_line(output,
"Modulus", n))
2227 if(!ldns_print_bignum_b64_line(output,
"PublicExponent", e))
2229 if(!ldns_print_bignum_b64_line(output,
"PrivateExponent", d))
2231 if(!ldns_print_bignum_b64_line(output,
"Prime1", p))
2233 if(!ldns_print_bignum_b64_line(output,
"Prime2", q))
2235 if(!ldns_print_bignum_b64_line(output,
"Exponent1", dmp1))
2237 if(!ldns_print_bignum_b64_line(output,
"Exponent2", dmq1))
2239 if(!ldns_print_bignum_b64_line(output,
"Coefficient", iqmp))
2260 const BIGNUM *p=NULL, *q=NULL, *g=NULL,
2261 *priv_key=NULL, *pub_key=NULL;
2262 #if OPENSSL_VERSION_NUMBER < 0x10100000 || defined(HAVE_LIBRESSL)
2267 priv_key = dsa->priv_key;
2268 pub_key = dsa->pub_key;
2271 DSA_get0_pqg(dsa, &p, &q, &g);
2272 DSA_get0_key(dsa, &pub_key, &priv_key);
2274 if(!ldns_print_bignum_b64_line(output,
"Prime(p)", p))
2276 if(!ldns_print_bignum_b64_line(output,
"Subprime(q)", q))
2278 if(!ldns_print_bignum_b64_line(output,
"Base(g)", g))
2280 if(!ldns_print_bignum_b64_line(output,
"Private_value(x)", priv_key))
2282 if(!ldns_print_bignum_b64_line(output,
"Public_value(y)", pub_key))
2288 #if defined(HAVE_SSL) && defined(USE_GOST)
2291 status = ldns_gost_key2buffer_str(output,
2311 EC_KEY* ec = EVP_PKEY_get1_EC_KEY(k->
_key.
key);
2312 const BIGNUM* b = EC_KEY_get0_private_key(ec);
2313 if(!ldns_print_bignum_b64_line(output,
"PrivateKey", b))
2325 case LDNS_SIGN_ED25519:
2331 status = ldns_ed25519_key2buffer_str(output,
2336 case LDNS_SIGN_ED448:
2342 status = ldns_ed448_key2buffer_str(output,
2351 status = ldns_hmac_key2buffer_str(output, k);
2356 status = ldns_hmac_key2buffer_str(output, k);
2361 status = ldns_hmac_key2buffer_str(output, k);
2366 status = ldns_hmac_key2buffer_str(output, k);
2371 status = ldns_hmac_key2buffer_str(output, k);
2376 status = ldns_hmac_key2buffer_str(output, k);
2382 return ldns_buffer_status(output);
2406 if (*(ldns_buffer_at(buffer, ldns_buffer_position(buffer))) != 0) {
2410 ldns_buffer_write_u8(buffer, (uint8_t)
'\0');
2416 str = strdup((
const char *)ldns_buffer_begin(buffer));
2433 ldns_buffer_write_u8(buffer, 0);
2443 char *result = NULL;
2460 char *result = NULL;
2484 char *result = NULL;
2509 char *result = NULL;
2526 char *result = NULL;
2534 tmp_buffer, fmt, list)
2563 fprintf(output,
"%s", str);
2565 fprintf(output,
";Unable to convert rdf to string\n");
2576 fprintf(output,
"%s", str);
2578 fprintf(output,
";Unable to convert rr to string\n");
2595 fprintf(output,
"%s", str);
2597 fprintf(output,
";Unable to convert packet to string\n");
2654 fprintf(output,
"trust anchors (%d listed):\n",
2657 fprintf(output,
"tsig: %s %s\n",
2662 fprintf(output,
"default domain: ");
2664 fprintf(output,
"\n");
2669 fprintf(output,
"\t");
2671 fprintf(output,
"\n");
2677 fprintf(output,
"\t");
2680 switch ((
int)rtt[i]) {
2682 fprintf(output,
" - reachable\n");
2685 fprintf(output,
" - unreachable\n");
void ldns_buffer_free(ldns_buffer *buffer)
frees the buffer.
bool ldns_buffer_set_capacity(ldns_buffer *buffer, size_t capacity)
changes the buffer's capacity.
bool ldns_buffer_reserve(ldns_buffer *buffer, size_t amount)
ensures BUFFER can contain at least AMOUNT more bytes.
ldns_buffer * ldns_buffer_new(size_t capacity)
creates a new buffer with the specified capacity.
int ldns_buffer_printf(ldns_buffer *buffer, const char *format,...)
prints to the buffer, increasing the capacity if required using buffer_reserve().
void * ldns_buffer_export(ldns_buffer *buffer)
Makes the buffer fixed and returns a pointer to the data.
int ldns_b64_ntop(uint8_t const *src, size_t srclength, char *target, size_t targsize)
ldns_rdf * ldns_dname_label(const ldns_rdf *rdf, uint8_t labelpos)
look inside the rdf and if it is an LDNS_RDF_TYPE_DNAME try and retrieve a specific label.
uint16_t ldns_calc_keytag(const ldns_rr *key)
calculates a keytag of a key for use in DNSSEC.
bool ldns_nsec_bitmap_covers_type(const ldns_rdf *bitmap, ldns_rr_type type)
Check if RR type t is enumerated and set in the RR type bitmap rdf.
bool ldns_nsec3_optout(const ldns_rr *nsec3_rr)
Returns true if the opt-out flag has been set in the given NSEC3 RR.
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 sets the bit.
ldns_status ldns_nsec_bitmap_clear_type(ldns_rdf *bitmap, ldns_rr_type type)
Checks if RR type t is enumerated in the type bitmap rdf and clears the bit.
ldns_rdf * ldns_nsec3_next_owner(const ldns_rr *nsec3_rr)
Returns the first label of the next ownername in the NSEC3 chain (ie.
ldns_rdf * ldns_dnssec_name_name(const ldns_dnssec_name *name)
Returns the domain name of the given dnssec_name structure.
@ LDNS_STATUS_WIRE_RDATA_ERR
@ LDNS_STATUS_DOMAINNAME_OVERFLOW
enum ldns_enum_status ldns_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 giv...
ldns_status ldns_rdf2buffer_str_hip(ldns_buffer *output, const ldns_rdf *rdf)
Converts an LDNS_RDF_TYPE_HIP rdata element to presentation format for the algorithm,...
ldns_status ldns_rdf2buffer_str_wks(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.
const ldns_output_format * ldns_output_format_nocomments
Standard output format record that disables commenting in the textual representation of Resource Reco...
char * ldns_rr_class2str(const ldns_rr_class klass)
Converts an ldns_rr_class value to its string representation, and returns that string.
char * ldns_rr2str_fmt(const ldns_output_format *fmt, const ldns_rr *rr)
Converts the data in the resource record to presentation format and returns that as a char *.
char * ldns_key2str(const ldns_key *k)
Converts a private key to the test presentation fmt and returns that as a char *.
ldns_status ldns_key2buffer_str(ldns_buffer *output, const ldns_key *k)
Converts the data in the DNS packet to presentation format (as char *) and appends it to the given bu...
ldns_status ldns_rdf2buffer_str_int32(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.
char * ldns_pkt2str_fmt(const ldns_output_format *fmt, const ldns_pkt *pkt)
Converts the data in the DNS packet to presentation format and returns that as a char *.
ldns_status ldns_rdf2buffer_str_hex(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.
char * ldns_pkt_rcode2str(ldns_pkt_rcode rcode)
Converts a packet rcode to its mnemonic and returns that as an allocated null-terminated string.
ldns_status ldns_rdf2buffer_str_str(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.
ldns_status ldns_pkt_rcode2buffer_str(ldns_buffer *output, ldns_pkt_rcode rcode)
Converts an ldns packet rcode value to its mnemonic, and adds that to the output buffer.
ldns_status ldns_rdf2buffer_str_loc(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.
ldns_status ldns_rdf2buffer_str_apl(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.
char * ldns_rr_type2str(const ldns_rr_type type)
Converts an ldns_rr_type value to its string representation, and returns that string.
ldns_status ldns_rdf2buffer_str_nsap(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.
void ldns_rr_list_print_fmt(FILE *output, const ldns_output_format *fmt, const ldns_rr_list *lst)
print a rr_list to output
ldns_lookup_table ldns_rcodes[]
Response codes.
ldns_status ldns_rdf2buffer_str_b64(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.
ldns_status ldns_rdf2buffer_str_type(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.
ldns_status ldns_rdf2buffer_str(ldns_buffer *buffer, const ldns_rdf *rdf)
Converts the data in the rdata field to presentation format (as char *) and appends it to the given b...
void ldns_pkt_print_fmt(FILE *output, const ldns_output_format *fmt, const ldns_pkt *pkt)
Prints the data in the DNS packet to the given file stream (in presentation format)
char * ldns_pkt_algorithm2str(ldns_algorithm algorithm)
Converts a signing algorithms to its mnemonic and returns that as an allocated null-terminated string...
ldns_status ldns_pkt2buffer_str_fmt(ldns_buffer *output, const ldns_output_format *fmt, const ldns_pkt *pkt)
Converts the data in the DNS packet to presentation format (as char *) and appends it to the given bu...
char * ldns_rr_list2str(const ldns_rr_list *list)
Converts a list of resource records to presentation format and returns that as a char *.
ldns_status ldns_rr2buffer_str_fmt(ldns_buffer *output, const ldns_output_format *fmt, const ldns_rr *rr)
Converts the data in the resource record to presentation format (as char *) and appends it to the giv...
const ldns_output_format ldns_output_format_nocomments_record
void ldns_zone_print_fmt(FILE *output, const ldns_output_format *fmt, const ldns_zone *z)
Print a zone structure * to output.
ldns_status ldns_pktheader2buffer_str(ldns_buffer *output, const ldns_pkt *pkt)
Converts the header of a packet to presentation format and appends it to the output buffer.
const ldns_output_format * ldns_output_format_onlykeyids
Standard output format record that annotated only DNSKEY RR's with commenti text.
ldns_status ldns_rdf2buffer_str_tag(ldns_buffer *output, const ldns_rdf *rdf)
Adds the LDNS_RDF_TYPE_TAG rdata to the output buffer, provided it contains only alphanumeric charact...
const ldns_output_format ldns_output_format_onlykeyids_record
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.
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 places it in the given buffer.
char * ldns_pkt_cert_algorithm2str(ldns_cert_algorithm cert_algorithm)
Converts a cert algorithm to its mnemonic and returns that as an allocated null-terminated string.
void ldns_rdf_print(FILE *output, const ldns_rdf *rdf)
Prints the data in the rdata field to the given file stream (in presentation format)
ldns_lookup_table ldns_algorithms[]
Taken from RFC 2535, section 7.
ldns_status ldns_algorithm2buffer_str(ldns_buffer *output, ldns_algorithm algorithm)
Converts an ldns algorithm type to its mnemonic, and adds that to the output buffer.
ldns_status ldns_rdf2buffer_str_time(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.
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)
char * ldns_buffer_export2str(ldns_buffer *buffer)
Exports and returns the data in the buffer as a null terminated char * string.
ldns_status ldns_cert_algorithm2buffer_str(ldns_buffer *output, ldns_cert_algorithm cert_algorithm)
Converts an ldns certificate algorithm type to its mnemonic, and adds that to the output buffer.
char * ldns_buffer2str(ldns_buffer *buffer)
Returns a copy of the data in the buffer as a null terminated char * string.
char * ldns_pkt2str(const ldns_pkt *pkt)
Converts the data in the DNS packet to presentation format and returns that as a char *.
void ldns_resolver_print_fmt(FILE *output, const ldns_output_format *fmt, const ldns_resolver *r)
Print a resolver (in sofar that is possible) state to output.
char * ldns_pkt_opcode2str(ldns_pkt_opcode opcode)
Converts a packet opcode to its mnemonic and returns that as an allocated null-terminated string.
ldns_lookup_table ldns_opcodes[]
Operation codes.
ldns_status ldns_rdf2buffer_str_tsigtime(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.
ldns_status ldns_rdf2buffer_str_eui48(ldns_buffer *output, const ldns_rdf *rdf)
Converts an LDNS_RDF_TYPE_EUI48 rdata element to 6 hexadecimal numbers separated by dashes and adds i...
ldns_status ldns_rdf2buffer_str_int8(ldns_buffer *output, const ldns_rdf *rdf)
Converts an LDNS_RDF_TYPE_INT8 rdata element to string format and adds it to the output buffer.
ldns_status ldns_rdf2buffer_str_alg(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.
char * ldns_rr2str(const ldns_rr *rr)
Converts the data in the resource record to presentation format and returns that as a char *.
ldns_status ldns_rdf2buffer_str_eui64(ldns_buffer *output, const ldns_rdf *rdf)
Converts an LDNS_RDF_TYPE_EUI64 rdata element to 8 hexadecimal numbers separated by dashes and adds i...
ldns_status ldns_rdf2buffer_str_amtrelay(ldns_buffer *output, const ldns_rdf *rdf)
Converts an LDNS_RDF_TYPE_AMTRELAY rdata element to presentation format for the precedence,...
ldns_status ldns_rdf2buffer_str_ilnp64(ldns_buffer *output, const ldns_rdf *rdf)
Converts an LDNS_RDF_TYPE_ILNP64 rdata element to 4 hexadecimal numbers separated by colons and adds ...
ldns_status ldns_rdf2buffer_str_nsec(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.
void ldns_resolver_print(FILE *output, const ldns_resolver *r)
Print a resolver (in sofar that is possible) state to output.
ldns_status ldns_rdf2buffer_str_long_str(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 prin...
ldns_status ldns_output_format_clear_type(ldns_output_format *fmt, ldns_rr_type t)
Makes sure the LDNS_FMT_RFC3597 is set in the output format.
ldns_status ldns_rdf2buffer_str_b32_ext(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.
ldns_status ldns_rdf2buffer_str_unknown(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.
void ldns_zone_print(FILE *output, const ldns_zone *z)
Print a zone structure * to output.
ldns_status ldns_rdf2buffer_str_cert_alg(ldns_buffer *output, const ldns_rdf *rdf)
Converts an LDNS_RDF_TYPE_CERT rdata element to string format and adds it to the output buffer.
void ldns_rr_list_print(FILE *output, const ldns_rr_list *lst)
print a rr_list to output
ldns_status ldns_rdf2buffer_str_class(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.
ldns_lookup_table ldns_rr_classes[]
rr types
ldns_status ldns_rdf2buffer_str_int16(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.
ldns_status ldns_rdf2buffer_str_ipseckey(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.
ldns_status ldns_pkt_opcode2buffer_str(ldns_buffer *output, ldns_pkt_opcode opcode)
Converts an ldns packet opcode value to its mnemonic, and adds that to the output buffer.
const ldns_output_format * ldns_output_format_default
The default output format record.
ldns_status ldns_rdf2buffer_str_period(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.
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)
ldns_status ldns_rr_list2buffer_str_fmt(ldns_buffer *output, const ldns_output_format *fmt, const ldns_rr_list *list)
Converts a rr_list to presentation format and appends it to the output buffer.
ldns_status ldns_rdf2buffer_str_dname(ldns_buffer *output, const ldns_rdf *dname)
Print the ldns_rdf containing a dname to the buffer.
ldns_lookup_table ldns_cert_algorithms[]
Taken from RFC 2538.
ldns_status ldns_rdf2buffer_str_a(ldns_buffer *output, const ldns_rdf *rdf)
Converts an LDNS_RDF_TYPE_A rdata element to string format and adds it to the output buffer.
ldns_status ldns_output_format_set_type(ldns_output_format *fmt, ldns_rr_type t)
Makes sure the LDNS_FMT_RFC3597 is set in the output format.
char * ldns_rdf2str(const ldns_rdf *rdf)
Converts the data in the rdata field to presentation format and returns that as a char *.
ldns_status ldns_rdf2buffer_str_nsec3_salt(ldns_buffer *output, const ldns_rdf *rdf)
Converts an LDNS_RDF_TYPE_NSEC3_SALT rdata element to string format and adds it to the output buffer.
const ldns_output_format ldns_output_format_bubblebabble_record
const ldns_output_format * ldns_output_format_bubblebabble
Standard output format record that shows all DNSKEY related information in the comment text,...
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 places it in the given buffer.
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 bu...
char * ldns_rr_list2str_fmt(const ldns_output_format *fmt, const ldns_rr_list *list)
Converts a list of resource records to presentation format and returns that as a char *.
ldns_status ldns_rdf2buffer_str_int16_data(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.
ldns_status ldns_rdf2buffer_str_aaaa(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.
ldns_status ldns_rdf2buffer_str_atma(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.
void ldns_rr_print_fmt(FILE *output, const ldns_output_format *fmt, const ldns_rr *rr)
Prints the data in the resource record to the given file stream (in presentation format)
#define LDNS_COMMENT_KEY_SIZE
Show DNSKEY key size as comment.
#define LDNS_COMMENT_RRSIGS
Also comment KEY_ID with RRSIGS.
#define LDNS_FMT_PAD_SOA_SERIAL
#define LDNS_COMMENT_BUBBLEBABBLE
Provide bubblebabble representation for DS RR's as comment.
#define LDNS_FMT_ZEROIZE_RRSIGS
#define LDNS_COMMENT_FLAGS
Show when a NSEC3 RR has the optout flag set as comment.
#define LDNS_COMMENT_NULLS
Represent a NULL pointer (instead of a pointer to a ldns_rr as "; (null)" as opposed to outputting no...
#define LDNS_COMMENT_KEY_ID
Show key id with DNSKEY RR's as comment.
#define LDNS_APL_NEGATION
#define LDNS_COMMENT_KEY_TYPE
Show if a DNSKEY is a ZSK or KSK as comment.
#define LDNS_COMMENT_KEY
Show key id, type and size as comment for DNSKEY RR's.
#define LDNS_COMMENT_NSEC3_CHAIN
Show the unhashed owner and next owner names for NSEC3 RR's as comment.
unsigned char * ldns_key_hmac_key(const ldns_key *k)
return the hmac key data
size_t ldns_key_hmac_size(const ldns_key *k)
return the hmac key size
ldns_signing_algorithm ldns_key_algorithm(const ldns_key *k)
return the signing alg of the key
RSA * ldns_key_rsa_key(const ldns_key *k)
returns the (openssl) RSA struct contained in the key
DSA * ldns_key_dsa_key(const ldns_key *k)
returns the (openssl) DSA struct contained in the key
@ LDNS_SIGN_ECDSAP256SHA256
@ LDNS_SIGN_RSASHA1_NSEC3
@ LDNS_SIGN_ECDSAP384SHA384
#define LDNS_KEY_ZONE_KEY
enum ldns_enum_algorithm ldns_algorithm
Including this file will include all ldns files, and define some lookup tables.
uint8_t ldns_pkt_edns_version(const ldns_pkt *packet)
return the packet's edns version
ldns_rdf * ldns_pkt_answerfrom(const ldns_pkt *packet)
Return the packet's answerfrom.
ldns_pkt_opcode ldns_pkt_get_opcode(const ldns_pkt *packet)
Read the packet's code.
ldns_rr_list * ldns_pkt_question(const ldns_pkt *packet)
Return the packet's question section.
uint16_t ldns_pkt_id(const ldns_pkt *packet)
Read the packet id.
uint16_t ldns_pkt_arcount(const ldns_pkt *packet)
Return the packet's ar count.
struct timeval ldns_pkt_timestamp(const ldns_pkt *packet)
Return the packet's timestamp.
bool ldns_pkt_qr(const ldns_pkt *packet)
Read the packet's qr bit.
bool ldns_pkt_edns(const ldns_pkt *pkt)
returns true if this packet needs and EDNS rr to be sent.
ldns_rr_list * ldns_pkt_authority(const ldns_pkt *packet)
Return the packet's authority section.
uint16_t ldns_pkt_ancount(const ldns_pkt *packet)
Return the packet's an count.
bool ldns_pkt_cd(const ldns_pkt *packet)
Read the packet's cd bit.
ldns_rr_list * ldns_pkt_additional(const ldns_pkt *packet)
Return the packet's additional section.
size_t ldns_pkt_size(const ldns_pkt *packet)
Return the packet's size in bytes.
bool ldns_pkt_ad(const ldns_pkt *packet)
Read the packet's ad bit.
uint32_t ldns_pkt_querytime(const ldns_pkt *packet)
Return the packet's querytime.
bool ldns_pkt_rd(const ldns_pkt *packet)
Read the packet's rd bit.
uint8_t ldns_pkt_edns_extended_rcode(const ldns_pkt *packet)
return the packet's edns extended rcode
bool ldns_pkt_ra(const ldns_pkt *packet)
Read the packet's ra bit.
ldns_rr_list * ldns_pkt_answer(const ldns_pkt *packet)
Return the packet's answer section.
uint16_t ldns_pkt_nscount(const ldns_pkt *packet)
Return the packet's ns count.
uint16_t ldns_pkt_qdcount(const ldns_pkt *packet)
Return the packet's qd count.
ldns_rdf * ldns_pkt_edns_data(const ldns_pkt *packet)
return the packet's edns data
ldns_rr * ldns_pkt_tsig(const ldns_pkt *pkt)
Return the packet's tsig pseudo rr's.
bool ldns_pkt_edns_do(const ldns_pkt *packet)
return the packet's edns do bit
bool ldns_pkt_aa(const ldns_pkt *packet)
Read the packet's aa bit.
ldns_pkt_rcode ldns_pkt_get_rcode(const ldns_pkt *packet)
Return the packet's respons code.
bool ldns_pkt_tc(const ldns_pkt *packet)
Read the packet's tc bit.
uint16_t ldns_pkt_edns_udp_size(const ldns_pkt *packet)
return the packet's edns udp size
#define LDNS_MAX_PACKETLEN
enum ldns_enum_pkt_rcode ldns_pkt_rcode
enum ldns_enum_pkt_opcode ldns_pkt_opcode
ldns_rbnode_t * ldns_rbtree_search(ldns_rbtree_t *rbtree, const void *key)
Find key in tree.
ldns_rdf_type ldns_rdf_get_type(const ldns_rdf *rd)
returns the type of the rdf.
void ldns_rdf_deep_free(ldns_rdf *rd)
frees a rdf structure and frees the data.
ldns_rdf * ldns_rdf_new(ldns_rdf_type type, size_t size, void *data)
allocates a new rdf structure and fills it.
uint32_t ldns_rdf2native_int32(const ldns_rdf *rd)
returns the native uint32_t representation from the rdf.
uint16_t ldns_rdf2native_int16(const ldns_rdf *rd)
returns the native uint16_t representation from the rdf.
size_t ldns_rdf_size(const ldns_rdf *rd)
returns the size of the rdf.
uint8_t * ldns_rdf_data(const ldns_rdf *rd)
returns the data of the rdf.
void ldns_rdf_free(ldns_rdf *rd)
frees a rdf structure, leaving the data pointer intact.
ldns_rdf * ldns_rdf_new_frm_data(ldns_rdf_type type, size_t size, const void *data)
allocates a new rdf structure and fills it.
enum ldns_enum_cert_algorithm ldns_cert_algorithm
@ LDNS_RDF_TYPE_INT32
32 bits
@ LDNS_RDF_TYPE_TAG
A non-zero sequence of US-ASCII letters and numbers in lower case.
@ LDNS_RDF_TYPE_NSAP
NSAP.
@ LDNS_RDF_TYPE_HIP
Represents the Public Key Algorithm, HIT and Public Key fields for the HIP RR types.
@ LDNS_RDF_TYPE_B32_EXT
b32 string
@ LDNS_RDF_TYPE_NSEC3_NEXT_OWNER
nsec3 base32 string (with length byte on wire
@ LDNS_RDF_TYPE_CERT_ALG
certificate algorithm
@ LDNS_RDF_TYPE_EUI48
6 * 8 bit hex numbers separated by dashes.
@ LDNS_RDF_TYPE_SERVICE
protocol and port bitmaps
@ LDNS_RDF_TYPE_EUI64
8 * 8 bit hex numbers separated by dashes.
@ LDNS_RDF_TYPE_PERIOD
period
@ LDNS_RDF_TYPE_B64
b64 string
@ LDNS_RDF_TYPE_AAAA
AAAA record.
@ LDNS_RDF_TYPE_UNKNOWN
unknown types
@ LDNS_RDF_TYPE_WKS
well known services
@ LDNS_RDF_TYPE_DNAME
domain name
@ LDNS_RDF_TYPE_TIME
time (32 bits)
@ LDNS_RDF_TYPE_NSEC
nsec type codes
@ LDNS_RDF_TYPE_NSEC3_SALT
nsec3 hash salt
@ LDNS_RDF_TYPE_APL
apl data
@ LDNS_RDF_TYPE_A
A record.
@ LDNS_RDF_TYPE_LONG_STR
A <character-string> encoding of the value field as specified [RFC1035], Section 5....
@ LDNS_RDF_TYPE_LOC
location data
@ LDNS_RDF_TYPE_INT16_DATA
variable length any type rdata where the length is specified by the first 2 bytes
@ LDNS_RDF_TYPE_ILNP64
4 shorts represented as 4 * 16 bit hex numbers separated by colons.
@ LDNS_RDF_TYPE_ATMA
ATMA.
@ LDNS_RDF_TYPE_HEX
hex string
@ LDNS_RDF_TYPE_CLASS
a class
@ LDNS_RDF_TYPE_INT8
8 bits
@ LDNS_RDF_TYPE_MATCHING_TYPE
@ LDNS_RDF_TYPE_IPSECKEY
IPSECKEY.
@ LDNS_RDF_TYPE_CERTIFICATE_USAGE
Since RFC7218 TLSA records can be given with mnemonics, hence these rdata field types.
@ LDNS_RDF_TYPE_STR
txt string
@ LDNS_RDF_TYPE_INT16
16 bits
@ LDNS_RDF_TYPE_ALG
a key algorithm
@ LDNS_RDF_TYPE_AMTRELAY
draft-ietf-mboned-driad-amt-discovery
@ LDNS_RDF_TYPE_TSIGTIME
tsig time 48 bits
@ LDNS_RDF_TYPE_TYPE
a RR type
const char * ldns_resolver_tsig_algorithm(const ldns_resolver *r)
Return the tsig algorithm as used by the nameserver.
bool ldns_resolver_dnssec(const ldns_resolver *r)
Does the resolver do DNSSEC.
bool ldns_resolver_usevc(const ldns_resolver *r)
Does the resolver use tcp or udp.
bool ldns_resolver_debug(const ldns_resolver *r)
Get the debug status of the resolver.
size_t ldns_resolver_searchlist_count(const ldns_resolver *r)
Return the resolver's searchlist count.
ldns_rr_list * ldns_resolver_dnssec_anchors(const ldns_resolver *r)
Get the resolver's DNSSEC anchors.
size_t ldns_resolver_nameserver_count(const ldns_resolver *r)
How many nameserver are configured in the resolver.
uint8_t ldns_resolver_retrans(const ldns_resolver *r)
Get the retransmit interval.
bool ldns_resolver_dnssec_cd(const ldns_resolver *r)
Does the resolver set the CD bit.
bool ldns_resolver_recursive(const ldns_resolver *r)
Is the resolver set to recurse.
bool ldns_resolver_dnsrch(const ldns_resolver *r)
Does the resolver apply search list.
bool ldns_resolver_igntc(const ldns_resolver *r)
Does the resolver ignore the TC bit (truncated)
bool ldns_resolver_defnames(const ldns_resolver *r)
Does the resolver apply default domain name.
ldns_rdf * ldns_resolver_domain(const ldns_resolver *r)
What is the default dname to add to relative queries.
uint16_t ldns_resolver_edns_udp_size(const ldns_resolver *r)
Get the resolver's udp size.
bool ldns_resolver_random(const ldns_resolver *r)
Does the resolver randomize the nameserver before usage.
struct timeval ldns_resolver_timeout(const ldns_resolver *r)
What is the timeout on socket connections.
size_t * ldns_resolver_rtt(const ldns_resolver *r)
Return the used round trip times for the nameservers.
bool ldns_resolver_fallback(const ldns_resolver *r)
Get the truncation fallback status.
uint8_t ldns_resolver_ip6(const ldns_resolver *r)
Does the resolver use ip6 or ip4.
uint8_t ldns_resolver_retry(const ldns_resolver *r)
Get the number of retries.
ldns_rdf ** ldns_resolver_searchlist(const ldns_resolver *r)
What is the searchlist as used by the resolver.
bool ldns_resolver_fail(const ldns_resolver *r)
Does the resolver only try the first nameserver.
const char * ldns_resolver_tsig_keyname(const ldns_resolver *r)
Return the tsig keyname as used by the nameserver.
ldns_rdf ** ldns_resolver_nameservers(const ldns_resolver *r)
Return the configured nameserver ip address.
uint16_t ldns_resolver_port(const ldns_resolver *r)
Get the port the resolver should use.
#define LDNS_RESOLV_RTT_MIN
#define LDNS_RESOLV_RTT_INF
ldns_rr * ldns_rr_list_rr(const ldns_rr_list *rr_list, size_t nr)
returns a specific rr of an rrlist.
uint32_t ldns_rr_ttl(const ldns_rr *rr)
returns the ttl of an rr structure.
ldns_rdf * ldns_rr_owner(const ldns_rr *rr)
returns the owner name of an rr structure.
const ldns_rr_descriptor * ldns_rr_descript(uint16_t type)
returns the resource record descriptor for the given rr type.
size_t ldns_rr_rd_count(const ldns_rr *rr)
returns the rd_count of an rr structure.
size_t ldns_rr_list_rr_count(const ldns_rr_list *rr_list)
returns the number of rr's in an rr_list.
ldns_rr_type ldns_rr_get_type(const ldns_rr *rr)
returns the type of the rr.
ldns_rr_class ldns_rr_get_class(const ldns_rr *rr)
returns the class of the rr.
bool ldns_rr_is_question(const ldns_rr *rr)
returns the question flag of an rr structure.
ldns_status ldns_rdf_bitmap_known_rr_types_space(ldns_rdf **rdf)
Create a rr type bitmap rdf providing enough space to set all known (to ldns) rr types.
ldns_rdf * ldns_rr_rdf(const ldns_rr *rr, size_t nr)
returns the rdata field member counter.
ldns_status ldns_rdf_bitmap_known_rr_types(ldns_rdf **rdf)
Create a rr type bitmap rdf with at least all known (to ldns) rr types set.
enum ldns_enum_rr_type ldns_rr_type
@ LDNS_RR_TYPE_RRSIG
DNSSEC.
@ LDNS_RR_TYPE_SOA
marks the start of a zone of authority
@ LDNS_RR_TYPE_DS
RFC4034, RFC3658.
@ LDNS_RR_TYPE_MAILA
A request for mail agent RRs (Obsolete - see MX)
@ LDNS_RR_TYPE_ANY
any type (wildcard)
@ LDNS_RR_TYPE_MAILB
A request for mailbox-related records (MB, MG or MR)
enum ldns_enum_rr_class ldns_rr_class
#define LDNS_MAX_DOMAINLEN
Maximum length of a complete dname.
@ LDNS_RR_CLASS_NONE
None class, dynamic update.
@ LDNS_RR_CLASS_IN
the Internet
@ LDNS_RR_CLASS_CH
Chaos class.
@ LDNS_RR_CLASS_HS
Hesiod (Dyer 87)
@ LDNS_RR_CLASS_ANY
Any class.
size_t ldns_rr_dnskey_key_size(const ldns_rr *key)
get the length of the keydata in bits
ldns_status ldns_str2rdf_dname(ldns_rdf **d, const char *str)
convert a dname string into wireformat
The rbnode_t struct definition.
const void * data
pointer to data
implementation of buffers to ease operations
size_t _position
The current position used for reading/writing.
General key structure, can contain all types of keys that are used in DNSSEC.
struct ldns_struct_key::@0 _key
Storage pointers for the types of keys supported.
A general purpose lookup table.
Resource record data field.
DNS stub resolver structure.
Contains all information about resource record types.
const char * _name
Textual name of the RR type.
List or Set of Resource Records.
struct tm * ldns_serial_arithmitics_gmtime_r(int32_t time, time_t now, struct tm *result)
The function interprets time as the number of seconds since epoch with respect to now using serial ar...
int ldns_b32_ntop_extended_hex(const uint8_t *src, size_t src_sz, char *dst, size_t dst_sz)
ldns_lookup_table * ldns_lookup_by_id(ldns_lookup_table *table, int id)
int ldns_get_bit(uint8_t bits[], size_t index)
Returns the value of the specified bit The bits are counted from left to right, so bit #0 is the left...
char * ldns_bubblebabble(uint8_t *data, size_t len)
Encode data as BubbleBabble.
#define LDNS_XMALLOC(type, count)
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 a DNS dname rdata field.
ldns_rr_list * ldns_zone_rrs(const ldns_zone *z)
Get a list of a zone's content.
ldns_rr * ldns_zone_soa(const ldns_zone *z)
Return the soa record of a zone.