19 #ifdef HAVE_SYS_SOCKET_H
20 #include <sys/socket.h>
22 #ifdef HAVE_ARPA_INET_H
23 #include <arpa/inet.h>
31 #ifndef INET_ADDRSTRLEN
32 #define INET_ADDRSTRLEN 16
34 #ifndef INET6_ADDRSTRLEN
35 #define INET6_ADDRSTRLEN 46
137 if (lt && lt->
name) {
142 return ldns_buffer_status(output);
149 if (lt && lt->
name) {
154 return ldns_buffer_status(output);
163 if (lt && lt->
name) {
168 return ldns_buffer_status(output);
177 if (lt && lt->
name) {
183 return ldns_buffer_status(output);
294 for(i = 0; i < len; i++) {
298 c = (
unsigned char) data[src_pos];
299 if(c ==
'.' || c ==
';' ||
300 c ==
'(' || c ==
')' ||
304 }
else if (!(isascii(c) && isgraph(c))) {
319 return ldns_buffer_status(output);
327 return ldns_buffer_status(output);
335 return ldns_buffer_status(output);
343 return ldns_buffer_status(output);
353 memset(&tm, 0,
sizeof(tm));
355 && strftime(date_buf, 15,
"%Y%m%d%H%M%S", &tm)) {
358 return ldns_buffer_status(output);
369 return ldns_buffer_status(output);
381 return ldns_buffer_status(output);
388 uint8_t length = data[0];
392 for (i = 1; i <= length; ++i) {
393 char ch = (char) data[i];
394 if (isprint((
int)ch) || ch==
'\t') {
395 if (ch==
'\"'||ch==
'\\')
401 (
unsigned)(uint8_t) ch);
405 return ldns_buffer_status(output);
411 size_t size = ldns_b64_ntop_calculate_size(
ldns_rdf_size(rdf));
418 return ldns_buffer_status(output);
439 return ldns_buffer_status(output);
450 return ldns_buffer_status(output);
460 if (descriptor && descriptor->
_name) {
465 return ldns_buffer_status(output);
480 return ldns_buffer_status(output);
494 return ldns_buffer_status(output);
504 return ldns_buffer_status(output);
508 loc_cm_print(
ldns_buffer *output, uint8_t mantissa, uint8_t exponent)
520 for(i=0; i<exponent-2; i++)
531 if (descriptor && descriptor->
_name) {
555 return ldns_buffer_status(output);
591 return ldns_buffer_status(output);
619 uint8_t horizontal_precision;
620 uint8_t vertical_precision;
630 uint32_t equator = (uint32_t) ldns_power(2, 31);
641 if (latitude > equator) {
643 latitude = latitude - equator;
646 latitude = equator - latitude;
648 h = latitude / (1000 * 60 * 60);
649 latitude = latitude % (1000 * 60 * 60);
650 m = latitude / (1000 * 60);
651 latitude = latitude % (1000 * 60);
652 s = (double) latitude / 1000.0;
654 h, m, s, northerness);
656 if (longitude > equator) {
658 longitude = longitude - equator;
661 longitude = equator - longitude;
663 h = longitude / (1000 * 60 * 60);
664 longitude = longitude % (1000 * 60 * 60);
665 m = longitude / (1000 * 60);
666 longitude = longitude % (1000 * 60);
667 s = (double) longitude / (1000.0);
669 h, m, s, easterness);
672 s = ((double) altitude) / 100;
675 if(altitude%100 != 0)
682 loc_cm_print(output, (size & 0xf0) >> 4, size & 0x0f);
685 loc_cm_print(output, (horizontal_precision & 0xf0) >> 4,
686 horizontal_precision & 0x0f);
689 loc_cm_print(output, (vertical_precision & 0xf0) >> 4,
690 vertical_precision & 0x0f);
693 return ldns_buffer_status(output);
723 struct protoent *protocol;
724 char *proto_name = NULL;
726 struct servent *service;
727 uint16_t current_service;
730 protocol = getprotobynumber((
int) protocol_nr);
731 if (protocol && (protocol->p_name != NULL)) {
732 proto_name = protocol->p_name;
738 #ifdef HAVE_ENDPROTOENT
742 for (current_service = 0;
743 current_service <
ldns_rdf_size(rdf) * 7; current_service++) {
745 service = getservbyport((
int) htons(current_service),
747 if (service && service->s_name) {
752 #ifdef HAVE_ENDSERVENT
757 return ldns_buffer_status(output);
766 uint8_t window_block_nr;
767 uint8_t bitmap_length;
775 window_block_nr = data[pos];
776 bitmap_length = data[pos + 1];
779 for (bit_pos = 0; bit_pos < (bitmap_length) * 8; bit_pos++) {
781 type = 256 * (uint16_t) window_block_nr + bit_pos;
784 if (descriptor && descriptor->
_name) {
793 pos += (uint16_t) bitmap_length;
796 return ldns_buffer_status(output);
809 return ldns_buffer_status(output);
811 salt_length = data[0];
813 if (salt_length == 0 || ((
size_t)salt_length)+1 >
ldns_rdf_size(rdf)) {
816 for (salt_pos = 0; salt_pos < salt_length; salt_pos++) {
822 return ldns_buffer_status(output);
831 return ldns_buffer_status(output);
838 uint64_t tsigtime = 0;
845 tsigtime = ldns_read_uint16(data);
847 tsigtime += ldns_read_uint16(data+2);
852 return ldns_buffer_status(output);
859 uint16_t address_family;
869 address_family = ldns_read_uint16(&data[pos]);
870 prefix = data[pos + 2];
880 for (i = 0; i < 4; i++) {
884 if (i < (
unsigned short) adf_length) {
901 for (i = 0; i < 16; i++) {
902 if (i % 2 == 0 && i > 0) {
905 if (i < (
unsigned short) adf_length) {
920 for (i = 1; i < (
unsigned short) (4 + adf_length); i++) {
926 pos += 4 + adf_length;
928 return ldns_buffer_status(output);
935 size_t size = ldns_b64_ntop_calculate_size(
ldns_rdf_size(rdf) - 2);
949 return ldns_buffer_status(output);
960 uint8_t gateway_type;
964 uint8_t *gateway_data;
966 size_t public_key_size;
967 uint8_t *public_key_data;
973 precedence = data[0];
974 gateway_type = data[1];
978 switch (gateway_type) {
1018 public_key_data =
LDNS_XMALLOC(uint8_t, public_key_size);
1019 if(!public_key_data) {
1023 memcpy(public_key_data, &data[offset], public_key_size);
1042 return ldns_buffer_status(output);
1169 size = ldns_b32_ntop_calculate_size(
ldns_rdf_size(rdf) - 1);
1201 return ldns_buffer_status(output);
1248 status = ldns_buffer_status(output);
1255 (
unsigned long) ldns_read_uint32(
1257 status = ldns_buffer_status(output);
1301 }
else if (fmt->
flags
1334 ,
" ;{%s}", babble);
1354 && fmt->
data != NULL) {
1359 && fmt->
data != NULL) {
1409 return ldns_buffer_status(output);
1428 return ldns_buffer_status(output);
1487 return ldns_buffer_status(output);
1497 struct timeval time;
1505 if (ldns_buffer_status_ok(output)) {
1566 ";; EDNS: version %u; flags:",
1599 time_tt = (time_t)time.tv_sec;
1601 (
char*)ctime(&time_tt));
1606 return ldns_buffer_status(output);
1637 #if defined(HAVE_SSL) && defined(USE_GOST)
1639 ldns_gost_key2buffer_str(
ldns_buffer *output, EVP_PKEY *p)
1641 unsigned char* pp = NULL;
1648 ret = i2d_PrivateKey(p, &pp);
1663 unsigned char *bignum;
1685 if (ldns_buffer_status_ok(output)) {
1701 "Algorithm: %u (RSA)\n",
1706 "Algorithm: %u (RSASHA1)\n",
1711 "Algorithm: %u (RSASHA1_NSEC3)\n",
1717 "Algorithm: %u (RSASHA256)\n",
1722 "Algorithm: %u (RSASHA512)\n",
1727 fprintf(stderr,
"Warning: unknown signature ");
1729 "algorithm type %u\n",
1732 "Algorithm: %u (Unknown)\n",
1741 i = (uint16_t)BN_bn2bin(rsa->n, bignum);
1753 i = (uint16_t)BN_bn2bin(rsa->e, bignum);
1767 i = (uint16_t)BN_bn2bin(rsa->d, bignum);
1784 i = (uint16_t)BN_bn2bin(rsa->p, bignum);
1801 i = (uint16_t)BN_bn2bin(rsa->q, bignum);
1818 i = (uint16_t)BN_bn2bin(rsa->dmp1, bignum);
1835 i = (uint16_t)BN_bn2bin(rsa->dmq1, bignum);
1852 i = (uint16_t)BN_bn2bin(rsa->iqmp, bignum);
1886 i = (uint16_t)BN_bn2bin(dsa->p, bignum);
1898 printf(
"(Not available)\n");
1903 i = (uint16_t)BN_bn2bin(dsa->q, bignum);
1915 printf(
"(Not available)\n");
1920 i = (uint16_t)BN_bn2bin(dsa->g, bignum);
1932 printf(
"(Not available)\n");
1936 if (dsa->priv_key) {
1937 i = (uint16_t)BN_bn2bin(dsa->priv_key, bignum);
1949 printf(
"(Not available)\n");
1954 i = (uint16_t)BN_bn2bin(dsa->pub_key, bignum);
1966 printf(
"(Not available)\n");
1972 #if defined(HAVE_SSL) && defined(USE_GOST)
1975 status = ldns_gost_key2buffer_str(output,
1995 EC_KEY* ec = EVP_PKEY_get1_EC_KEY(k->
_key.
key);
1996 const BIGNUM* b = EC_KEY_get0_private_key(ec);
1998 i = (uint16_t)BN_bn2bin(b, bignum);
2023 status = ldns_hmac_key2buffer_str(output, k);
2028 status = ldns_hmac_key2buffer_str(output, k);
2033 status = ldns_hmac_key2buffer_str(output, k);
2039 return ldns_buffer_status(output);
2063 if (*(ldns_buffer_at(buffer, ldns_buffer_position(buffer))) != 0) {
2067 ldns_buffer_write_u8(buffer, (uint8_t)
'\0');
2073 str = strdup((
const char *)ldns_buffer_begin(buffer));
2090 ldns_buffer_write_u8(buffer, 0);
2100 char *result = NULL;
2117 char *result = NULL;
2141 char *result = NULL;
2166 char *result = NULL;
2183 char *result = NULL;
2191 tmp_buffer, fmt, list)
2220 fprintf(output,
"%s", str);
2222 fprintf(output,
";Unable to convert rdf to string\n");
2233 fprintf(output,
"%s", str);
2235 fprintf(output,
";Unable to convert rr to string\n");
2252 fprintf(output,
"%s", str);
2254 fprintf(output,
";Unable to convert packet to string\n");
2311 fprintf(output,
"trust anchors (%d listed):\n",
2314 fprintf(output,
"tsig: %s %s\n",
2319 fprintf(output,
"default domain: ");
2321 fprintf(output,
"\n");
2326 fprintf(output,
"\t");
2328 fprintf(output,
"\n");
2334 fprintf(output,
"\t");
2337 switch ((
int)rtt[i]) {
2339 fprintf(output,
" - reachable\n");
2342 fprintf(output,
" - unreachable\n");