00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013 #include <ldns/config.h>
00014
00015 #include <ldns/ldns.h>
00016
00017 #include <limits.h>
00018
00019 #include <sys/socket.h>
00020 #include <arpa/inet.h>
00021 #include <netdb.h>
00022 #include <time.h>
00023 #include <sys/time.h>
00024
00025 #ifndef INET_ADDRSTRLEN
00026 #define INET_ADDRSTRLEN 16
00027 #endif
00028 #ifndef INET6_ADDRSTRLEN
00029 #define INET6_ADDRSTRLEN 46
00030 #endif
00031
00032
00033
00034
00035 ldns_lookup_table ldns_algorithms[] = {
00036 { LDNS_RSAMD5, "RSAMD5" },
00037 { LDNS_DH, "DH" },
00038 { LDNS_DSA, "DSA" },
00039 { LDNS_ECC, "ECC" },
00040 { LDNS_RSASHA1, "RSASHA1" },
00041 { LDNS_INDIRECT, "INDIRECT" },
00042 { LDNS_PRIVATEDNS, "PRIVATEDNS" },
00043 { LDNS_PRIVATEOID, "PRIVATEOID" },
00044 { 0, NULL }
00045 };
00046
00047
00048 ldns_lookup_table ldns_cert_algorithms[] = {
00049 { LDNS_CERT_PKIX, "PKIX" },
00050 { LDNS_CERT_SPKI, "SPKI" },
00051 { LDNS_CERT_PGP, "PGP" },
00052 { LDNS_CERT_URI, "URI" },
00053 { LDNS_CERT_OID, "OID" },
00054 { 0, NULL }
00055 };
00056
00057
00058 ldns_lookup_table ldns_rr_classes[] = {
00059 { LDNS_RR_CLASS_IN, "IN" },
00060 { LDNS_RR_CLASS_CH, "CH" },
00061 { LDNS_RR_CLASS_HS, "HS" },
00062 { LDNS_RR_CLASS_ANY, "ANY" },
00063 { 0, NULL }
00064 };
00065
00066
00067 ldns_lookup_table ldns_rcodes[] = {
00068 { LDNS_RCODE_NOERROR, "NOERROR" },
00069 { LDNS_RCODE_FORMERR, "FORMERR" },
00070 { LDNS_RCODE_SERVFAIL, "SERVFAIL" },
00071 { LDNS_RCODE_NXDOMAIN, "NXDOMAIN" },
00072 { LDNS_RCODE_NOTIMPL, "NOTIMPL" },
00073 { LDNS_RCODE_REFUSED, "REFUSED" },
00074 { LDNS_RCODE_YXDOMAIN, "YXDOMAIN" },
00075 { LDNS_RCODE_YXRRSET, "YXRRSET" },
00076 { LDNS_RCODE_NXRRSET, "NXRRSET" },
00077 { LDNS_RCODE_NOTAUTH, "NOTAUTH" },
00078 { LDNS_RCODE_NOTZONE, "NOTZONE" },
00079 { 0, NULL }
00080 };
00081
00082 ldns_lookup_table ldns_opcodes[] = {
00083 { LDNS_PACKET_QUERY, "QUERY" },
00084 { LDNS_PACKET_IQUERY, "IQUERY" },
00085 { LDNS_PACKET_STATUS, "STATUS" },
00086 { LDNS_PACKET_NOTIFY, "NOTIFY" },
00087 { LDNS_PACKET_UPDATE, "UPDATE" },
00088 { 0, NULL }
00089 };
00090
00091
00092 ldns_status
00093 ldns_rdf2buffer_str_dname(ldns_buffer *output, const ldns_rdf *dname)
00094 {
00095
00096 uint8_t src_pos = 0;
00097 uint8_t len;
00098 uint8_t *data;
00099 uint8_t i;
00100
00101 data = (uint8_t*)ldns_rdf_data(dname);
00102 len = data[src_pos];
00103
00104 if (ldns_rdf_size(dname) > LDNS_MAX_DOMAINLEN) {
00105
00106 return LDNS_STATUS_DOMAINNAME_OVERFLOW;
00107 }
00108
00109
00110 if (1 == ldns_rdf_size(dname)) {
00111 ldns_buffer_printf(output, ".");
00112 } else {
00113 while ((len > 0) && src_pos < ldns_rdf_size(dname)) {
00114 src_pos++;
00115 for(i = 0; i < len; i++) {
00116
00117
00118
00119 if (data[src_pos] == '.' ||
00120 data[src_pos] == '(' || data[src_pos] == ')') {
00121 ldns_buffer_printf(output, "\\%c",
00122 data[src_pos]);
00123
00124 } else if (!isprint((int) data[src_pos])) {
00125 ldns_buffer_printf(output, "\\%03u",
00126 data[src_pos]);
00127 } else {
00128 ldns_buffer_printf(output, "%c", data[src_pos]);
00129 }
00130 src_pos++;
00131 }
00132
00133 len = data[src_pos];
00134 ldns_buffer_printf(output, ".");
00135 }
00136 }
00137 return ldns_buffer_status(output);
00138 }
00139
00140 ldns_status
00141 ldns_rdf2buffer_str_int8(ldns_buffer *output, const ldns_rdf *rdf)
00142 {
00143 uint8_t data = ldns_rdf_data(rdf)[0];
00144 ldns_buffer_printf(output, "%lu", (unsigned long) data);
00145 return ldns_buffer_status(output);
00146 }
00147
00148 ldns_status
00149 ldns_rdf2buffer_str_int16(ldns_buffer *output, const ldns_rdf *rdf)
00150 {
00151 uint16_t data = ldns_read_uint16(ldns_rdf_data(rdf));
00152 ldns_buffer_printf(output, "%lu", (unsigned long) data);
00153 return ldns_buffer_status(output);
00154 }
00155
00156 ldns_status
00157 ldns_rdf2buffer_str_int32(ldns_buffer *output, const ldns_rdf *rdf)
00158 {
00159 uint32_t data = ldns_read_uint32(ldns_rdf_data(rdf));
00160 ldns_buffer_printf(output, "%lu", (unsigned long) data);
00161 return ldns_buffer_status(output);
00162 }
00163
00164 ldns_status
00165 ldns_rdf2buffer_str_time(ldns_buffer *output, const ldns_rdf *rdf)
00166 {
00167
00168 uint32_t data = ldns_read_uint32(ldns_rdf_data(rdf));
00169 time_t data_time;
00170 struct tm tm;
00171 char date_buf[16];
00172
00173 data_time = 0;
00174 memcpy(&data_time, &data, sizeof(uint32_t));
00175
00176 memset(&tm, 0, sizeof(tm));
00177
00178 if (gmtime_r(&data_time, &tm) && strftime(date_buf, 15, "%Y%m%d%H%M%S", &tm)) {
00179 ldns_buffer_printf(output, "%s", date_buf);
00180 }
00181 return ldns_buffer_status(output);
00182 }
00183
00184 ldns_status
00185 ldns_rdf2buffer_str_a(ldns_buffer *output, const ldns_rdf *rdf)
00186 {
00187 char str[INET_ADDRSTRLEN];
00188
00189 if (inet_ntop(AF_INET, ldns_rdf_data(rdf), str, INET_ADDRSTRLEN)) {
00190 ldns_buffer_printf(output, "%s", str);
00191 }
00192 return ldns_buffer_status(output);
00193 }
00194
00195 ldns_status
00196 ldns_rdf2buffer_str_aaaa(ldns_buffer *output, const ldns_rdf *rdf)
00197 {
00198 char str[INET6_ADDRSTRLEN];
00199
00200 if (inet_ntop(AF_INET6, ldns_rdf_data(rdf), str, INET6_ADDRSTRLEN)) {
00201 ldns_buffer_printf(output, "%s", str);
00202 }
00203
00204 return ldns_buffer_status(output);
00205 }
00206
00207 ldns_status
00208 ldns_rdf2buffer_str_str(ldns_buffer *output, const ldns_rdf *rdf)
00209 {
00210 const uint8_t *data = ldns_rdf_data(rdf);
00211 uint8_t length = data[0];
00212 size_t i;
00213
00214 ldns_buffer_printf(output, "\"");
00215 for (i = 1; i <= length; ++i) {
00216 char ch = (char) data[i];
00217 if (isprint(ch)) {
00218 if (ch == '"' || ch == '\\') {
00219 ldns_buffer_printf(output, "\\");
00220 }
00221 ldns_buffer_printf(output, "%c", ch);
00222 } else {
00223 ldns_buffer_printf(output, "\\%03u", (unsigned) ch);
00224 }
00225 }
00226 ldns_buffer_printf(output, "\"");
00227 return ldns_buffer_status(output);
00228 }
00229
00230 ldns_status
00231 ldns_rdf2buffer_str_b64(ldns_buffer *output, const ldns_rdf *rdf)
00232 {
00233 size_t size = b64_ntop_calculate_size(ldns_rdf_size(rdf));
00234 char *b64 = LDNS_XMALLOC(char, size);
00235 if (b64_ntop(ldns_rdf_data(rdf), ldns_rdf_size(rdf), b64, size)) {
00236 ldns_buffer_printf(output, "%s", b64);
00237 }
00238 LDNS_FREE(b64);
00239 return ldns_buffer_status(output);
00240 }
00241
00242 ldns_status
00243 ldns_rdf2buffer_str_hex(ldns_buffer *output, const ldns_rdf *rdf)
00244 {
00245 size_t i;
00246 for (i = 0; i < ldns_rdf_size(rdf); i++) {
00247 ldns_buffer_printf(output, "%02x", ldns_rdf_data(rdf)[i]);
00248 }
00249
00250 return ldns_buffer_status(output);
00251 }
00252
00253 ldns_status
00254 ldns_rdf2buffer_str_type(ldns_buffer *output, const ldns_rdf *rdf)
00255 {
00256 uint16_t data = ldns_read_uint16(ldns_rdf_data(rdf));
00257 const ldns_rr_descriptor *descriptor;
00258
00259 descriptor = ldns_rr_descript(data);
00260 if (descriptor->_name) {
00261 ldns_buffer_printf(output, "%s", descriptor->_name);
00262 } else {
00263 ldns_buffer_printf(output, "TYPE%u", data);
00264 }
00265 return ldns_buffer_status(output);
00266 }
00267
00268 ldns_status
00269 ldns_rdf2buffer_str_class(ldns_buffer *output, const ldns_rdf *rdf)
00270 {
00271 uint8_t data = ldns_rdf_data(rdf)[0];
00272 ldns_lookup_table *lt;
00273
00274 lt = ldns_lookup_by_id(ldns_rr_classes, (int) data);
00275 if (lt) {
00276 ldns_buffer_printf(output, "\t%s", lt->name);
00277 } else {
00278 ldns_buffer_printf(output, "\tCLASS%d", data);
00279 }
00280 return ldns_buffer_status(output);
00281 }
00282
00283 ldns_status
00284 ldns_rdf2buffer_str_cert_alg(ldns_buffer *output, const ldns_rdf *rdf)
00285 {
00286 uint16_t data = ldns_read_uint16(ldns_rdf_data(rdf));
00287 ldns_lookup_table *lt;
00288 lt = ldns_lookup_by_id(ldns_cert_algorithms, (int) data);
00289 if (lt) {
00290 ldns_buffer_printf(output, "%s", lt->name);
00291 } else {
00292 ldns_buffer_printf(output, "%d", data);
00293 }
00294 return ldns_buffer_status(output);
00295 }
00296
00297 ldns_status
00298 ldns_rdf2buffer_str_alg(ldns_buffer *output, const ldns_rdf *rdf)
00299 {
00300 uint8_t data = ldns_rdf_data(rdf)[0];
00301
00302
00303
00304
00305
00306
00307
00308
00309 ldns_buffer_printf(output, "%d", data);
00310
00311
00312
00313 return ldns_buffer_status(output);
00314 }
00315
00316 static void
00317 loc_cm_print(ldns_buffer *output, uint8_t mantissa, uint8_t exponent)
00318 {
00319 uint8_t i;
00320
00321 if(exponent < 2) {
00322 if(exponent == 1)
00323 mantissa *= 10;
00324 ldns_buffer_printf(output, "0.%02ld", (long)mantissa);
00325 return;
00326 }
00327
00328 ldns_buffer_printf(output, "%d", (int)mantissa);
00329 for(i=0; i<exponent-2; i++)
00330 ldns_buffer_printf(output, "0");
00331 }
00332
00333 ldns_status
00334 ldns_rdf2buffer_str_loc(ldns_buffer *output, const ldns_rdf *rdf)
00335 {
00336
00337 uint8_t version = ldns_rdf_data(rdf)[0];
00338 uint8_t size;
00339 uint8_t horizontal_precision;
00340 uint8_t vertical_precision;
00341 uint32_t longitude;
00342 uint32_t latitude;
00343 uint32_t altitude;
00344 char northerness;
00345 char easterness;
00346 uint32_t h;
00347 uint32_t m;
00348 double s;
00349
00350 uint32_t equator = (uint32_t) ldns_power(2, 31);
00351
00352 if (version == 0) {
00353 size = ldns_rdf_data(rdf)[1];
00354 horizontal_precision = ldns_rdf_data(rdf)[2];
00355 vertical_precision = ldns_rdf_data(rdf)[3];
00356
00357 latitude = ldns_read_uint32(&ldns_rdf_data(rdf)[4]);
00358 longitude = ldns_read_uint32(&ldns_rdf_data(rdf)[8]);
00359 altitude = ldns_read_uint32(&ldns_rdf_data(rdf)[12]);
00360
00361 if (latitude > equator) {
00362 northerness = 'N';
00363 latitude = latitude - equator;
00364 } else {
00365 northerness = 'S';
00366 latitude = equator - latitude;
00367 }
00368 h = latitude / (1000 * 60 * 60);
00369 latitude = latitude % (1000 * 60 * 60);
00370 m = latitude / (1000 * 60);
00371 latitude = latitude % (1000 * 60);
00372 s = (double) latitude / 1000.0;
00373 ldns_buffer_printf(output, "%02u %02u %0.3f %c ",
00374 h, m, s, northerness);
00375
00376 if (longitude > equator) {
00377 easterness = 'E';
00378 longitude = longitude - equator;
00379 } else {
00380 easterness = 'W';
00381 longitude = equator - longitude;
00382 }
00383 h = longitude / (1000 * 60 * 60);
00384 longitude = longitude % (1000 * 60 * 60);
00385 m = longitude / (1000 * 60);
00386 longitude = longitude % (1000 * 60);
00387 s = (double) longitude / (1000.0);
00388 ldns_buffer_printf(output, "%02u %02u %0.3f %c ",
00389 h, m, s, easterness);
00390
00391 ldns_buffer_printf(output, "%ld", altitude/100 - 100000);
00392 if(altitude%100 != 0)
00393 ldns_buffer_printf(output, ".%02ld", altitude%100);
00394 ldns_buffer_printf(output, "m ");
00395
00396 loc_cm_print(output, (size & 0xf0) >> 4, size & 0x0f);
00397 ldns_buffer_printf(output, "m ");
00398
00399 loc_cm_print(output, (horizontal_precision & 0xf0) >> 4,
00400 horizontal_precision & 0x0f);
00401 ldns_buffer_printf(output, "m ");
00402
00403 loc_cm_print(output, (vertical_precision & 0xf0) >> 4,
00404 vertical_precision & 0x0f);
00405 ldns_buffer_printf(output, "m ");
00406
00407 return ldns_buffer_status(output);
00408 } else {
00409 return ldns_rdf2buffer_str_hex(output, rdf);
00410 }
00411 }
00412
00413 ldns_status
00414 ldns_rdf2buffer_str_unknown(ldns_buffer *output, const ldns_rdf *rdf)
00415 {
00416 ldns_buffer_printf(output, "\\# %u ", ldns_rdf_size(rdf));
00417 return ldns_rdf2buffer_str_hex(output, rdf);
00418 }
00419
00420 ldns_status
00421 ldns_rdf2buffer_str_nsap(ldns_buffer *output, const ldns_rdf *rdf)
00422 {
00423 ldns_buffer_printf(output, "0x");
00424 return ldns_rdf2buffer_str_hex(output, rdf);
00425 }
00426
00427 ldns_status
00428 ldns_rdf2buffer_str_wks(ldns_buffer *output, const ldns_rdf *rdf)
00429 {
00430
00431 struct protoent *protocol;
00432 char *proto_name = NULL;
00433 uint8_t protocol_nr;
00434 struct servent *service;
00435 uint16_t current_service;
00436
00437 protocol_nr = ldns_rdf_data(rdf)[0];
00438 protocol = getprotobynumber((int) protocol_nr);
00439 if (protocol && (protocol->p_name != NULL)) {
00440 proto_name = protocol->p_name;
00441 ldns_buffer_printf(output, "%s ", protocol->p_name);
00442 } else {
00443 ldns_buffer_printf(output, "%u ", protocol_nr);
00444 }
00445
00446 endprotoent();
00447
00448 for (current_service = 0;
00449 current_service < ldns_rdf_size(rdf) * 7; current_service++) {
00450 if (ldns_get_bit(&(ldns_rdf_data(rdf)[1]), current_service)) {
00451 service = getservbyport((int) htons(current_service),
00452 proto_name);
00453 if (service && service->s_name) {
00454 ldns_buffer_printf(output, "%s ", service->s_name);
00455 } else {
00456 ldns_buffer_printf(output, "%u ", current_service);
00457 }
00458 endservent();
00459 }
00460 }
00461 return ldns_buffer_status(output);
00462 }
00463
00464 ldns_status
00465 ldns_rdf2buffer_str_nsec(ldns_buffer *output, const ldns_rdf *rdf)
00466 {
00467
00468
00469
00470 uint8_t window_block_nr;
00471 uint8_t bitmap_length;
00472 uint16_t type;
00473 uint16_t pos = 0;
00474 uint16_t bit_pos;
00475 uint8_t *data = ldns_rdf_data(rdf);
00476 const ldns_rr_descriptor *descriptor;
00477
00478 while(pos < ldns_rdf_size(rdf)) {
00479 window_block_nr = data[pos];
00480 bitmap_length = data[pos + 1];
00481 pos += 2;
00482
00483 for (bit_pos = 0; bit_pos < (bitmap_length) * 8; bit_pos++) {
00484 if (ldns_get_bit(&data[pos], bit_pos)) {
00485 type = 256 * (uint16_t) window_block_nr + bit_pos;
00486 descriptor = ldns_rr_descript(type);
00487
00488 if (descriptor->_name) {
00489 ldns_buffer_printf(output, "%s ",
00490 descriptor->_name);
00491 } else {
00492 ldns_buffer_printf(output, "TYPE%d ", type);
00493 }
00494 }
00495 }
00496
00497 pos += (uint16_t) bitmap_length;
00498 }
00499
00500 return ldns_buffer_status(output);
00501 }
00502
00503 ldns_status
00504 ldns_rdf2buffer_str_period(ldns_buffer *output, const ldns_rdf *rdf)
00505 {
00506
00507 uint32_t p = ldns_read_uint32(ldns_rdf_data(rdf));
00508 ldns_buffer_printf(output, "%u", p);
00509 return ldns_buffer_status(output);
00510 }
00511
00512 ldns_status
00513 ldns_rdf2buffer_str_tsigtime(ldns_buffer *output,const ldns_rdf *rdf)
00514 {
00515
00516 uint64_t tsigtime = 0;
00517 uint8_t *data = ldns_rdf_data(rdf);
00518
00519 if (ldns_rdf_size(rdf) != 6) {
00520 return LDNS_STATUS_ERR;
00521 }
00522
00523 tsigtime = ldns_read_uint16(data);
00524 tsigtime *= 65536;
00525 tsigtime += ldns_read_uint16(data+2);
00526 tsigtime *= 65536;
00527
00528 ldns_buffer_printf(output, "%llu ", tsigtime);
00529
00530 return ldns_buffer_status(output);
00531 }
00532
00533 ldns_status
00534 ldns_rdf2buffer_str_apl(ldns_buffer *output, const ldns_rdf *rdf)
00535 {
00536 uint8_t *data = ldns_rdf_data(rdf);
00537 uint16_t address_family = ldns_read_uint16(data);
00538 uint8_t prefix = data[2];
00539 bool negation;
00540 uint8_t adf_length;
00541 unsigned short i;
00542 unsigned int pos = 0;
00543
00544 while (pos < (unsigned int) ldns_rdf_size(rdf)) {
00545 address_family = ldns_read_uint16(&data[pos]);
00546 prefix = data[pos + 2];
00547 negation = data[pos + 3] & LDNS_APL_NEGATION;
00548 adf_length = data[pos + 3] & LDNS_APL_MASK;
00549 if (address_family == LDNS_APL_IP4) {
00550
00551 if (negation) {
00552 ldns_buffer_printf(output, "!");
00553 }
00554 ldns_buffer_printf(output, "%u:", address_family);
00555
00556 for (i = 0; i < 4; i++) {
00557 if (i > 0) {
00558 ldns_buffer_printf(output, ".");
00559 }
00560 if (i < (unsigned short) adf_length) {
00561 ldns_buffer_printf(output, "%d",
00562 data[pos + i + 4]);
00563 } else {
00564 ldns_buffer_printf(output, "0");
00565 }
00566 }
00567 ldns_buffer_printf(output, "/%u ", prefix);
00568 } else if (address_family == LDNS_APL_IP6) {
00569
00570 if (negation) {
00571 ldns_buffer_printf(output, "!");
00572 }
00573 ldns_buffer_printf(output, "%u:", address_family);
00574
00575 for (i = 0; i < 16; i++) {
00576 if (i % 2 == 0 && i > 0) {
00577 ldns_buffer_printf(output, ":");
00578 }
00579 if (i < (unsigned short) adf_length) {
00580 ldns_buffer_printf(output, "%02x",
00581 data[pos + i + 4]);
00582 } else {
00583 ldns_buffer_printf(output, "00");
00584 }
00585 }
00586 ldns_buffer_printf(output, "/%u ", prefix);
00587
00588 } else {
00589
00590 ldns_buffer_printf(output, "Unknown address family: %u data: ",
00591 address_family);
00592 for (i = 1; i < (unsigned short) (4 + adf_length); i++) {
00593 ldns_buffer_printf(output, "%02x", data[i]);
00594 }
00595 }
00596 pos += 4 + adf_length;
00597 }
00598 return ldns_buffer_status(output);
00599 }
00600
00601 ldns_status
00602 ldns_rdf2buffer_str_int16_data(ldns_buffer *output, const ldns_rdf *rdf)
00603 {
00604
00605 size_t size = b64_ntop_calculate_size(ldns_rdf_size(rdf) - 2);
00606 char *b64 = LDNS_XMALLOC(char, size);
00607
00608 ldns_buffer_printf(output, "%u ", ldns_rdf_size(rdf) - 2);
00609
00610 if (ldns_rdf_size(rdf) > 2 &&
00611 b64_ntop(ldns_rdf_data(rdf) + 2, ldns_rdf_size(rdf) - 2, b64, size)) {
00612 ldns_buffer_printf(output, "%s", b64);
00613 }
00614 LDNS_FREE(b64);
00615 return ldns_buffer_status(output);
00616 }
00617
00618 ldns_status
00619 ldns_rdf2buffer_str_ipseckey(ldns_buffer *output, const ldns_rdf *rdf)
00620 {
00621
00622
00623
00624 uint8_t *data = ldns_rdf_data(rdf);
00625 uint8_t precedence;
00626 uint8_t gateway_type;
00627 uint8_t algorithm;
00628
00629 ldns_rdf *gateway;
00630 uint8_t *gateway_data;
00631
00632 size_t public_key_size;
00633 uint8_t *public_key_data;
00634 ldns_rdf *public_key;
00635
00636 size_t offset = 0;
00637 ldns_status status;
00638
00639
00640 precedence = data[0];
00641 gateway_type = data[1];
00642 algorithm = data[2];
00643 offset = 3;
00644
00645 switch (gateway_type) {
00646 case 0:
00647
00648 break;
00649 case 1:
00650 gateway_data = LDNS_XMALLOC(uint8_t, LDNS_IP4ADDRLEN);
00651 memcpy(gateway_data, &data[offset], LDNS_IP4ADDRLEN);
00652 gateway = ldns_rdf_new(LDNS_RDF_TYPE_A, LDNS_IP4ADDRLEN , gateway_data);
00653 break;
00654 case 2:
00655 gateway_data = LDNS_XMALLOC(uint8_t, LDNS_IP6ADDRLEN);
00656 memcpy(gateway_data, &data[offset], LDNS_IP6ADDRLEN);
00657 gateway =
00658 ldns_rdf_new(LDNS_RDF_TYPE_AAAA, LDNS_IP6ADDRLEN, gateway_data);
00659 break;
00660 case 3:
00661 status = ldns_wire2dname(&gateway, data, ldns_rdf_size(rdf), &offset);
00662 break;
00663 default:
00664
00665 break;
00666 }
00667
00668 public_key_size = ldns_rdf_size(rdf) - offset;
00669 public_key_data = LDNS_XMALLOC(uint8_t, public_key_size);
00670 memcpy(public_key_data, &data[offset], public_key_size);
00671 public_key = ldns_rdf_new(LDNS_RDF_TYPE_B64, public_key_size, public_key_data);
00672
00673 ldns_buffer_printf(output, "%u %u %u ", precedence, gateway_type, algorithm);
00674 (void) ldns_rdf2buffer_str(output, gateway);
00675 ldns_buffer_printf(output, " ");
00676 (void) ldns_rdf2buffer_str(output, public_key);
00677
00678 ldns_rdf_free(gateway);
00679 ldns_rdf_free(public_key);
00680
00681 return ldns_buffer_status(output);
00682 }
00683
00684 ldns_status
00685 ldns_rdf2buffer_str_tsig(ldns_buffer *output, const ldns_rdf *rdf)
00686 {
00687
00688 return ldns_rdf2buffer_str_unknown(output, rdf);
00689 }
00690
00691
00692 ldns_status
00693 ldns_rdf2buffer_str(ldns_buffer *buffer, const ldns_rdf *rdf)
00694 {
00695 ldns_status res;
00696
00697
00698 if (rdf) {
00699 switch(ldns_rdf_get_type(rdf)) {
00700 case LDNS_RDF_TYPE_NONE:
00701 break;
00702 case LDNS_RDF_TYPE_DNAME:
00703 res = ldns_rdf2buffer_str_dname(buffer, rdf);
00704 break;
00705 case LDNS_RDF_TYPE_INT8:
00706 res = ldns_rdf2buffer_str_int8(buffer, rdf);
00707 break;
00708 case LDNS_RDF_TYPE_INT16:
00709 res = ldns_rdf2buffer_str_int16(buffer, rdf);
00710 break;
00711 case LDNS_RDF_TYPE_INT32:
00712 res = ldns_rdf2buffer_str_int32(buffer, rdf);
00713 break;
00714 case LDNS_RDF_TYPE_PERIOD:
00715 res = ldns_rdf2buffer_str_period(buffer, rdf);
00716 break;
00717 case LDNS_RDF_TYPE_TSIGTIME:
00718 res = ldns_rdf2buffer_str_tsigtime(buffer, rdf);
00719 break;
00720 case LDNS_RDF_TYPE_A:
00721 res = ldns_rdf2buffer_str_a(buffer, rdf);
00722 break;
00723 case LDNS_RDF_TYPE_AAAA:
00724 res = ldns_rdf2buffer_str_aaaa(buffer, rdf);
00725 break;
00726 case LDNS_RDF_TYPE_STR:
00727 res = ldns_rdf2buffer_str_str(buffer, rdf);
00728 break;
00729 case LDNS_RDF_TYPE_APL:
00730 res = ldns_rdf2buffer_str_apl(buffer, rdf);
00731 break;
00732 case LDNS_RDF_TYPE_B64:
00733 res = ldns_rdf2buffer_str_b64(buffer, rdf);
00734 break;
00735 case LDNS_RDF_TYPE_HEX:
00736 res = ldns_rdf2buffer_str_hex(buffer, rdf);
00737 break;
00738 case LDNS_RDF_TYPE_NSEC:
00739 res = ldns_rdf2buffer_str_nsec(buffer, rdf);
00740 break;
00741 case LDNS_RDF_TYPE_TYPE:
00742 res = ldns_rdf2buffer_str_type(buffer, rdf);
00743 break;
00744 case LDNS_RDF_TYPE_CLASS:
00745 res = ldns_rdf2buffer_str_class(buffer, rdf);
00746 break;
00747 case LDNS_RDF_TYPE_CERT_ALG:
00748 res = ldns_rdf2buffer_str_cert_alg(buffer, rdf);
00749 break;
00750 case LDNS_RDF_TYPE_ALG:
00751 res = ldns_rdf2buffer_str_alg(buffer, rdf);
00752 break;
00753 case LDNS_RDF_TYPE_UNKNOWN:
00754 res = ldns_rdf2buffer_str_unknown(buffer, rdf);
00755 break;
00756 case LDNS_RDF_TYPE_TIME:
00757 res = ldns_rdf2buffer_str_time(buffer, rdf);
00758 break;
00759 case LDNS_RDF_TYPE_LOC:
00760 res = ldns_rdf2buffer_str_loc(buffer, rdf);
00761 break;
00762 case LDNS_RDF_TYPE_WKS:
00763 case LDNS_RDF_TYPE_SERVICE:
00764 res = ldns_rdf2buffer_str_wks(buffer, rdf);
00765 break;
00766 case LDNS_RDF_TYPE_NSAP:
00767 res = ldns_rdf2buffer_str_nsap(buffer, rdf);
00768 break;
00769 case LDNS_RDF_TYPE_IPSECKEY:
00770 res = ldns_rdf2buffer_str_ipseckey(buffer, rdf);
00771 break;
00772 case LDNS_RDF_TYPE_TSIG:
00773 res = ldns_rdf2buffer_str_tsig(buffer, rdf);
00774 break;
00775 case LDNS_RDF_TYPE_INT16_DATA:
00776 res = ldns_rdf2buffer_str_int16_data(buffer, rdf);
00777 break;
00778 }
00779 } else {
00780 ldns_buffer_printf(buffer, "(null) ");
00781 }
00782 return LDNS_STATUS_OK;
00783 }
00784
00785 ldns_status
00786 ldns_rr2buffer_str(ldns_buffer *output, const ldns_rr *rr)
00787 {
00788 uint16_t i;
00789 ldns_status status = LDNS_STATUS_OK;
00790 ldns_lookup_table *lt;
00791 const ldns_rr_descriptor *descriptor;
00792
00793 if (!rr) {
00794 ldns_buffer_printf(output, "(null)\n");
00795 } else {
00796 if (ldns_rr_owner(rr)) {
00797 status = ldns_rdf2buffer_str_dname(output, ldns_rr_owner(rr));
00798 }
00799 if (status != LDNS_STATUS_OK) {
00800 return status;
00801 }
00802
00803
00804
00805
00806
00807 if (ldns_rr_rd_count(rr) > 0) {
00808 ldns_buffer_printf(output, "\t%d", ldns_rr_ttl(rr));
00809 }
00810
00811 lt = ldns_lookup_by_id(ldns_rr_classes, ldns_rr_get_class(rr));
00812 if (lt) {
00813 ldns_buffer_printf(output, "\t%s\t", lt->name);
00814 } else {
00815 ldns_buffer_printf(output, "\tCLASS%d\t",
00816 ldns_rr_get_class(rr));
00817 }
00818
00819 descriptor = ldns_rr_descript(ldns_rr_get_type(rr));
00820
00821 if (descriptor->_name) {
00822 ldns_buffer_printf(output, "%s", descriptor->_name);
00823 } else {
00824
00825 if (ldns_rr_get_type(rr) == 251) {
00826 ldns_buffer_printf(output, "IXFR ");
00827 } else if (ldns_rr_get_type(rr) == 252) {
00828 ldns_buffer_printf(output, "AXFR ");
00829 } else if (ldns_rr_get_type(rr) == 253) {
00830 ldns_buffer_printf(output, "MAILB ");
00831 } else if (ldns_rr_get_type(rr) == 254) {
00832 ldns_buffer_printf(output, "MAILA ");
00833 } else if (ldns_rr_get_type(rr) == 255) {
00834 ldns_buffer_printf(output, "ANY ");
00835 } else {
00836 ldns_buffer_printf(output, "TYPE%d\t",
00837 ldns_rr_get_type(rr));
00838 }
00839 }
00840
00841 if (ldns_rr_rd_count(rr) > 0) {
00842 ldns_buffer_printf(output, "\t");
00843 }
00844 for (i = 0; i < ldns_rr_rd_count(rr); i++) {
00845 status = ldns_rdf2buffer_str(output, ldns_rr_rdf(rr, i));
00846 if (i < ldns_rr_rd_count(rr) - 1) {
00847 ldns_buffer_printf(output, " ");
00848 }
00849 }
00850
00851
00852
00853 if (ldns_rr_rd_count(rr) > 0) {
00854 switch (ldns_rr_get_type(rr)) {
00855 case LDNS_RR_TYPE_DNSKEY:
00856 #ifdef HAVE_SSL
00857 if (ldns_rdf2native_int16(ldns_rr_rdf(rr, 0)) == 256) {
00858 ldns_buffer_printf(output,
00859 " ;{id = %d (zsk), size = %db}",
00860 ldns_calc_keytag(rr),
00861 ldns_rr_dnskey_key_size(rr));
00862 break;
00863 }
00864 if (ldns_rdf2native_int16(ldns_rr_rdf(rr, 0)) == 257) {
00865 ldns_buffer_printf(output,
00866 " ;{id = %d (ksk), size = %db}",
00867 ldns_calc_keytag(rr),
00868 ldns_rr_dnskey_key_size(rr));
00869 break;
00870 }
00871 ldns_buffer_printf(output, " ;{id = %d, size = %db}",
00872 ldns_calc_keytag(rr),
00873 ldns_rr_dnskey_key_size(rr));
00874 #endif
00875 break;
00876 case LDNS_RR_TYPE_RRSIG:
00877 ldns_buffer_printf(output, " ;{id = %d}",
00878 ldns_rdf2native_int16(ldns_rr_rdf(rr, 6)));
00879 break;
00880 default:
00881 break;
00882
00883 }
00884 }
00885
00886 ldns_buffer_printf(output, "\n");
00887 }
00888 return ldns_buffer_status(output);
00889 }
00890
00891 ldns_status
00892 ldns_rr_list2buffer_str(ldns_buffer *output, const ldns_rr_list *list)
00893 {
00894 uint16_t i;
00895
00896 for(i = 0; i < ldns_rr_list_rr_count(list); i++) {
00897 (void) ldns_rr2buffer_str(output, ldns_rr_list_rr(list, i));
00898 }
00899 return ldns_buffer_status(output);
00900 }
00901
00902 ldns_status
00903 ldns_pktheader2buffer_str(ldns_buffer *output, const ldns_pkt *pkt)
00904 {
00905 ldns_lookup_table *opcode = ldns_lookup_by_id(ldns_opcodes,
00906 (int) ldns_pkt_get_opcode(pkt));
00907 ldns_lookup_table *rcode = ldns_lookup_by_id(ldns_rcodes,
00908 (int) ldns_pkt_get_rcode(pkt));
00909
00910 ldns_buffer_printf(output, ";; ->>HEADER<<- ");
00911 if (opcode) {
00912 ldns_buffer_printf(output, "opcode: %s, ", opcode->name);
00913 } else {
00914 ldns_buffer_printf(output, "opcode: ?? (%u), ",
00915 ldns_pkt_get_opcode(pkt));
00916 }
00917 if (rcode) {
00918 ldns_buffer_printf(output, "rcode: %s, ", rcode->name);
00919 } else {
00920 ldns_buffer_printf(output, "rcode: ?? (%u), ", ldns_pkt_get_rcode(pkt));
00921 }
00922 ldns_buffer_printf(output, "id: %d\n", ldns_pkt_id(pkt));
00923 ldns_buffer_printf(output, ";; flags: ");
00924
00925 if (ldns_pkt_qr(pkt)) {
00926 ldns_buffer_printf(output, "qr ");
00927 }
00928 if (ldns_pkt_aa(pkt)) {
00929 ldns_buffer_printf(output, "aa ");
00930 }
00931 if (ldns_pkt_tc(pkt)) {
00932 ldns_buffer_printf(output, "tc ");
00933 }
00934 if (ldns_pkt_rd(pkt)) {
00935 ldns_buffer_printf(output, "rd ");
00936 }
00937 if (ldns_pkt_cd(pkt)) {
00938 ldns_buffer_printf(output, "cd ");
00939 }
00940 if (ldns_pkt_ra(pkt)) {
00941 ldns_buffer_printf(output, "ra ");
00942 }
00943 if (ldns_pkt_ad(pkt)) {
00944 ldns_buffer_printf(output, "ad ");
00945 }
00946 ldns_buffer_printf(output, "; ");
00947 ldns_buffer_printf(output, "QUERY: %u, ", ldns_pkt_qdcount(pkt));
00948 ldns_buffer_printf(output, "ANSWER: %u, ", ldns_pkt_ancount(pkt));
00949 ldns_buffer_printf(output, "AUTHORITY: %u, ", ldns_pkt_nscount(pkt));
00950 ldns_buffer_printf(output, "ADDITIONAL: %u ", ldns_pkt_arcount(pkt));
00951 return ldns_buffer_status(output);
00952 }
00953
00954 ldns_status
00955 ldns_pkt2buffer_str(ldns_buffer *output, const ldns_pkt *pkt)
00956 {
00957 uint16_t i;
00958 ldns_status status = LDNS_STATUS_OK;
00959 char *tmp;
00960 struct timeval time;
00961 time_t time_tt;
00962
00963 if (!pkt) {
00964 ldns_buffer_printf(output, "null");
00965 return LDNS_STATUS_OK;
00966 }
00967
00968 if (ldns_buffer_status_ok(output)) {
00969 status = ldns_pktheader2buffer_str(output, pkt);
00970 if (status != LDNS_STATUS_OK) {
00971 return status;
00972 }
00973
00974 ldns_buffer_printf(output, "\n");
00975
00976 ldns_buffer_printf(output, ";; QUESTION SECTION:\n;; ");
00977
00978
00979 for (i = 0; i < ldns_pkt_qdcount(pkt); i++) {
00980 status = ldns_rr2buffer_str(output,
00981 ldns_rr_list_rr(ldns_pkt_question(pkt), i));
00982 if (status != LDNS_STATUS_OK) {
00983 return status;
00984 }
00985 }
00986 ldns_buffer_printf(output, "\n");
00987
00988 ldns_buffer_printf(output, ";; ANSWER SECTION:\n");
00989 for (i = 0; i < ldns_pkt_ancount(pkt); i++) {
00990 status = ldns_rr2buffer_str(output,
00991 ldns_rr_list_rr(ldns_pkt_answer(pkt), i));
00992 if (status != LDNS_STATUS_OK) {
00993 return status;
00994 }
00995
00996 }
00997 ldns_buffer_printf(output, "\n");
00998
00999 ldns_buffer_printf(output, ";; AUTHORITY SECTION:\n");
01000
01001 for (i = 0; i < ldns_pkt_nscount(pkt); i++) {
01002 status = ldns_rr2buffer_str(output,
01003 ldns_rr_list_rr(ldns_pkt_authority(pkt), i));
01004 if (status != LDNS_STATUS_OK) {
01005 return status;
01006 }
01007 }
01008 ldns_buffer_printf(output, "\n");
01009
01010 ldns_buffer_printf(output, ";; ADDITIONAL SECTION:\n");
01011 for (i = 0; i < ldns_pkt_arcount(pkt); i++) {
01012 status = ldns_rr2buffer_str(output,
01013 ldns_rr_list_rr(ldns_pkt_additional(pkt), i));
01014 if (status != LDNS_STATUS_OK) {
01015 return status;
01016 }
01017
01018 }
01019 ldns_buffer_printf(output, "\n");
01020
01021 ldns_buffer_printf(output, ";; Query time: %d msec\n",
01022 ldns_pkt_querytime(pkt));
01023 if (ldns_pkt_edns(pkt)) {
01024 ldns_buffer_printf(output,
01025 ";; EDNS: version %u; flags:",
01026 ldns_pkt_edns_version(pkt));
01027 if (ldns_pkt_edns_do(pkt)) {
01028 ldns_buffer_printf(output, " do");
01029 }
01030 ldns_buffer_printf(output, " ; udp: %u\n",
01031 ldns_pkt_edns_udp_size(pkt));
01032
01033 if (ldns_pkt_edns_data(pkt)) {
01034 ldns_buffer_printf(output, ";; Data: ");
01035 (void)ldns_rdf2buffer_str(output,
01036 ldns_pkt_edns_data(pkt));
01037 ldns_buffer_printf(output, "\n");
01038 }
01039 }
01040 if (ldns_pkt_tsig(pkt)) {
01041 ldns_buffer_printf(output, ";; TSIG:\n;; ");
01042 (void) ldns_rr2buffer_str(output, ldns_pkt_tsig(pkt));
01043 ldns_buffer_printf(output, "\n");
01044 }
01045 if (ldns_pkt_answerfrom(pkt)) {
01046 tmp = ldns_rdf2str(ldns_pkt_answerfrom(pkt));
01047 ldns_buffer_printf(output, ";; SERVER: %s\n", tmp);
01048 LDNS_FREE(tmp);
01049 }
01050 time = ldns_pkt_timestamp(pkt);
01051 time_tt = (time_t)time.tv_sec;
01052 ldns_buffer_printf(output, ";; WHEN: %s",
01053 (char*)ctime(&time_tt));
01054
01055 ldns_buffer_printf(output, ";; MSG SIZE rcvd: %d\n",
01056 (int)ldns_pkt_size(pkt));
01057 } else {
01058 return ldns_buffer_status(output);
01059 }
01060 return status;
01061 }
01062
01063 ldns_status
01064 ldns_key2buffer_str(ldns_buffer *output, const ldns_key *k)
01065 {
01066 ldns_status status = LDNS_STATUS_OK;
01067 unsigned char *bignum;
01068 #ifdef HAVE_SSL
01069
01070 ldns_rdf *b64_bignum = NULL;
01071 uint16_t i;
01072 #endif
01073
01074 if (!k) {
01075 return LDNS_STATUS_ERR;
01076 }
01077
01078 bignum = LDNS_XMALLOC(unsigned char, LDNS_MAX_KEYLEN);
01079 if (!bignum) {
01080 return LDNS_STATUS_ERR;
01081 }
01082
01083 if (ldns_buffer_status_ok(output)) {
01084 #ifdef HAVE_SSL
01085 switch(ldns_key_algorithm(k)) {
01086 case LDNS_SIGN_RSASHA1:
01087 case LDNS_SIGN_RSAMD5:
01088
01089
01090 ldns_buffer_printf(output,"Private-key-format: v1.2\n");
01091 if (ldns_key_algorithm(k) == LDNS_SIGN_RSAMD5) {
01092 ldns_buffer_printf(output,"Algorithm: 1 (RSA)\n");
01093 } else if (ldns_key_algorithm(k) == LDNS_SIGN_RSASHA1) {
01094 ldns_buffer_printf(output,"Algorithm: 5 (RSASHA1)\n");
01095 }
01096
01097
01098
01099 ldns_buffer_printf(output, "Modulus: ");
01100 i = (uint16_t)BN_bn2bin(ldns_key_rsa_key(k)->n, bignum);
01101 if (i > LDNS_MAX_KEYLEN) {
01102 goto error;
01103 }
01104 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
01105 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
01106 goto error;
01107 }
01108 ldns_rdf_deep_free(b64_bignum);
01109 ldns_buffer_printf(output, "\n");
01110
01111 ldns_buffer_printf(output, "PublicExponent: ");
01112 i = (uint16_t)BN_bn2bin(ldns_key_rsa_key(k)->e, bignum);
01113 if (i > LDNS_MAX_KEYLEN) {
01114 goto error;
01115 }
01116 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
01117 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
01118 goto error;
01119 }
01120 ldns_rdf_deep_free(b64_bignum);
01121 ldns_buffer_printf(output, "\n");
01122
01123 ldns_buffer_printf(output, "PrivateExponent: ");
01124 i = (uint16_t)BN_bn2bin(ldns_key_rsa_key(k)->d, bignum);
01125 if (i > LDNS_MAX_KEYLEN) {
01126 goto error;
01127 }
01128 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
01129 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
01130 goto error;
01131 }
01132 ldns_rdf_deep_free(b64_bignum);
01133 ldns_buffer_printf(output, "\n");
01134
01135 ldns_buffer_printf(output, "Prime1: ");
01136 i = (uint16_t)BN_bn2bin(ldns_key_rsa_key(k)->p, bignum);
01137 if (i > LDNS_MAX_KEYLEN) {
01138 goto error;
01139 }
01140 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
01141 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
01142 goto error;
01143 }
01144 ldns_rdf_deep_free(b64_bignum);
01145 ldns_buffer_printf(output, "\n");
01146
01147 ldns_buffer_printf(output, "Prime2: ");
01148 i = (uint16_t)BN_bn2bin(ldns_key_rsa_key(k)->q, bignum);
01149 if (i > LDNS_MAX_KEYLEN) {
01150 goto error;
01151 }
01152 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
01153 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
01154 goto error;
01155 }
01156 ldns_rdf_deep_free(b64_bignum);
01157 ldns_buffer_printf(output, "\n");
01158
01159 ldns_buffer_printf(output, "Exponent1: ");
01160 i = (uint16_t)BN_bn2bin(ldns_key_rsa_key(k)->dmp1, bignum);
01161 if (i > LDNS_MAX_KEYLEN) {
01162 goto error;
01163 }
01164 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
01165 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
01166 goto error;
01167 }
01168 ldns_rdf_deep_free(b64_bignum);
01169 ldns_buffer_printf(output, "\n");
01170
01171 ldns_buffer_printf(output, "Exponent2: ");
01172 i = (uint16_t)BN_bn2bin(ldns_key_rsa_key(k)->dmq1, bignum);
01173 if (i > LDNS_MAX_KEYLEN) {
01174 goto error;
01175 }
01176 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
01177 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
01178 goto error;
01179 }
01180 ldns_rdf_deep_free(b64_bignum);
01181 ldns_buffer_printf(output, "\n");
01182
01183 ldns_buffer_printf(output, "Coefficient: ");
01184 i = (uint16_t)BN_bn2bin(ldns_key_rsa_key(k)->iqmp, bignum);
01185 if (i > LDNS_MAX_KEYLEN) {
01186 goto error;
01187 }
01188 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
01189 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
01190 goto error;
01191 }
01192 ldns_rdf_deep_free(b64_bignum);
01193 ldns_buffer_printf(output, "\n");
01194 break;
01195 case LDNS_SIGN_DSA:
01196 ldns_buffer_printf(output,"Private-key-format: v1.2\n");
01197 ldns_buffer_printf(output,"Algorithm: 3 (DSA)\n");
01198
01199
01200
01201 ldns_buffer_printf(output, "Prime(p): ");
01202 i = (uint16_t)BN_bn2bin(ldns_key_dsa_key(k)->p, bignum);
01203 if (i > LDNS_MAX_KEYLEN) {
01204 goto error;
01205 }
01206 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
01207 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
01208 goto error;
01209 }
01210 ldns_rdf_deep_free(b64_bignum);
01211 ldns_buffer_printf(output, "\n");
01212
01213 ldns_buffer_printf(output, "Subprime(q): ");
01214 i = (uint16_t)BN_bn2bin(ldns_key_dsa_key(k)->q, bignum);
01215 if (i > LDNS_MAX_KEYLEN) {
01216 goto error;
01217 }
01218 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
01219 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
01220 goto error;
01221 }
01222 ldns_rdf_deep_free(b64_bignum);
01223 ldns_buffer_printf(output, "\n");
01224
01225 ldns_buffer_printf(output, "Base(g): ");
01226 i = (uint16_t)BN_bn2bin(ldns_key_dsa_key(k)->g, bignum);
01227 if (i > LDNS_MAX_KEYLEN) {
01228 goto error;
01229 }
01230 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
01231 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
01232 goto error;
01233 }
01234 ldns_rdf_deep_free(b64_bignum);
01235 ldns_buffer_printf(output, "\n");
01236
01237 ldns_buffer_printf(output, "Private_value(x): ");
01238 i = (uint16_t)BN_bn2bin(ldns_key_dsa_key(k)->priv_key, bignum);
01239 if (i > LDNS_MAX_KEYLEN) {
01240 goto error;
01241 }
01242 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
01243 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
01244 goto error;
01245 }
01246 ldns_rdf_deep_free(b64_bignum);
01247 ldns_buffer_printf(output, "\n");
01248
01249 ldns_buffer_printf(output, "Public_value(y): ");
01250 i = (uint16_t)BN_bn2bin(ldns_key_dsa_key(k)->pub_key, bignum);
01251 if (i > LDNS_MAX_KEYLEN) {
01252 goto error;
01253 }
01254 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
01255 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
01256 goto error;
01257 }
01258 ldns_rdf_deep_free(b64_bignum);
01259 ldns_buffer_printf(output, "\n");
01260 break;
01261 case LDNS_SIGN_HMACMD5:
01262
01263 ldns_buffer_printf(output, "Private-key-format: v1.2\n");
01264 ldns_buffer_printf(output, "Algorithm: 157 (HMAC_MD5)\n");
01265 ldns_buffer_printf(output, "Key: ");
01266 i = ldns_key_hmac_size(k);
01267 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, ldns_key_hmac_key(k));
01268 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
01269 goto error;
01270 }
01271 ldns_rdf_deep_free(b64_bignum);
01272 ldns_buffer_printf(output, "\n");
01273 break;
01274 }
01275 #endif
01276 } else {
01277 #ifdef HAVE_SSL
01278 LDNS_FREE(b64_bignum);
01279 #endif
01280 LDNS_FREE(bignum);
01281 return ldns_buffer_status(output);
01282 }
01283 LDNS_FREE(bignum);
01284 return status;
01285
01286 #ifdef HAVE_SSL
01287
01288 error:
01289 LDNS_FREE(bignum);
01290 return LDNS_STATUS_ERR;
01291 #endif
01292
01293 }
01294
01295
01296
01297
01298 char *
01299 buffer2str(ldns_buffer *buffer)
01300 {
01301 char *tmp_str;
01302 char *str;
01303
01304
01305
01306 if (*(ldns_buffer_at(buffer, ldns_buffer_position(buffer))) != 0) {
01307 if (!ldns_buffer_reserve(buffer, 1)) {
01308 return NULL;
01309 }
01310 ldns_buffer_write_u8(buffer, (uint8_t) '\0');
01311 if (!ldns_buffer_set_capacity(buffer, ldns_buffer_position(buffer))) {
01312 return NULL;
01313 }
01314 }
01315
01316 tmp_str = ldns_buffer_export(buffer);
01317 str = LDNS_XMALLOC(char, strlen(tmp_str) + 1);
01318 memcpy(str, tmp_str, strlen(tmp_str) + 1);
01319
01320 return str;
01321 }
01322
01323 char *
01324 ldns_rdf2str(const ldns_rdf *rdf)
01325 {
01326 char *result = NULL;
01327 ldns_buffer *tmp_buffer = ldns_buffer_new(LDNS_MIN_BUFLEN);
01328
01329 if (ldns_rdf2buffer_str(tmp_buffer, rdf) == LDNS_STATUS_OK) {
01330
01331 result = buffer2str(tmp_buffer);
01332 }
01333
01334 ldns_buffer_free(tmp_buffer);
01335 return result;
01336 }
01337
01338 char *
01339 ldns_rr2str(const ldns_rr *rr)
01340 {
01341 char *result = NULL;
01342 ldns_buffer *tmp_buffer = ldns_buffer_new(LDNS_MIN_BUFLEN);
01343
01344 if (ldns_rr2buffer_str(tmp_buffer, rr) == LDNS_STATUS_OK) {
01345
01346 result = buffer2str(tmp_buffer);
01347 }
01348
01349 ldns_buffer_free(tmp_buffer);
01350 return result;
01351 }
01352
01353 char *
01354 ldns_pkt2str(const ldns_pkt *pkt)
01355 {
01356 char *result = NULL;
01357 ldns_buffer *tmp_buffer = ldns_buffer_new(LDNS_MIN_BUFLEN);
01358
01359 if (ldns_pkt2buffer_str(tmp_buffer, pkt) == LDNS_STATUS_OK) {
01360
01361 result = buffer2str(tmp_buffer);
01362 }
01363
01364 ldns_buffer_free(tmp_buffer);
01365 return result;
01366 }
01367
01368 char *
01369 ldns_key2str(const ldns_key *k)
01370 {
01371 char *result = NULL;
01372 ldns_buffer *tmp_buffer = ldns_buffer_new(LDNS_MIN_BUFLEN);
01373 if (ldns_key2buffer_str(tmp_buffer, k) == LDNS_STATUS_OK) {
01374
01375 result = buffer2str(tmp_buffer);
01376 }
01377 ldns_buffer_free(tmp_buffer);
01378 return result;
01379 }
01380
01381 char *
01382 ldns_rr_list2str(const ldns_rr_list *list)
01383 {
01384 char *result = NULL;
01385 ldns_buffer *tmp_buffer = ldns_buffer_new(LDNS_MIN_BUFLEN);
01386
01387 if (list) {
01388 if (ldns_rr_list2buffer_str(tmp_buffer, list) == LDNS_STATUS_OK) {
01389 }
01390 } else {
01391 ldns_buffer_printf(tmp_buffer, "(null)\n");
01392 }
01393
01394
01395 result = buffer2str(tmp_buffer);
01396 ldns_buffer_free(tmp_buffer);
01397 return result;
01398 }
01399
01400 void
01401 ldns_rdf_print(FILE *output, const ldns_rdf *rdf)
01402 {
01403 char *str = ldns_rdf2str(rdf);
01404 if (str) {
01405 fprintf(output, "%s", str);
01406 } else {
01407 fprintf(output, "Unable to convert rdf to string\n");
01408 }
01409 LDNS_FREE(str);
01410 }
01411
01412 void
01413 ldns_rr_print(FILE *output, const ldns_rr *rr)
01414 {
01415 char *str = ldns_rr2str(rr);
01416 if (str) {
01417 fprintf(output, "%s", str);
01418 } else {
01419 fprintf(output, "Unable to convert rr to string\n");
01420 }
01421 LDNS_FREE(str);
01422 }
01423
01424 void
01425 ldns_pkt_print(FILE *output, const ldns_pkt *pkt)
01426 {
01427 char *str = ldns_pkt2str(pkt);
01428 if (str) {
01429 fprintf(output, "%s", str);
01430 } else {
01431 fprintf(output, "Unable to convert packet to string\n");
01432 }
01433 LDNS_FREE(str);
01434 }
01435
01436 void
01437 ldns_rr_list_print(FILE *output, const ldns_rr_list *lst)
01438 {
01439 size_t i;
01440 for (i = 0; i < ldns_rr_list_rr_count(lst); i++) {
01441 ldns_rr_print(output, ldns_rr_list_rr(lst, i));
01442 }
01443 }
01444
01445 void
01446 ldns_resolver_print(FILE *output, const ldns_resolver *r)
01447 {
01448 uint16_t i;
01449 ldns_rdf **n;
01450 ldns_rdf **s;
01451 size_t *rtt;
01452 if (!r) {
01453 return;
01454 }
01455 n = ldns_resolver_nameservers(r);
01456 s = ldns_resolver_searchlist(r);
01457 rtt = ldns_resolver_rtt(r);
01458
01459 fprintf(output, "port: %d\n", (int)ldns_resolver_port(r));
01460 fprintf(output, "edns0 size: %d\n", (int)ldns_resolver_edns_udp_size(r));
01461 fprintf(output, "use ip6: %d\n", (int)ldns_resolver_ip6(r));
01462
01463 fprintf(output, "recursive: %d\n", ldns_resolver_recursive(r));
01464 fprintf(output, "usevc: %d\n", ldns_resolver_usevc(r));
01465 fprintf(output, "igntc: %d\n", ldns_resolver_igntc(r));
01466 fprintf(output, "fail: %d\n", ldns_resolver_fail(r));
01467 fprintf(output, "retry: %d\n", (int)ldns_resolver_retry(r));
01468 fprintf(output, "timeout: %d\n", (int)ldns_resolver_timeout(r).tv_sec);
01469
01470 fprintf(output, "default domain: ");
01471 ldns_rdf_print(output, ldns_resolver_domain(r));
01472 fprintf(output, "\n");
01473
01474 fprintf(output, "searchlist:\n");
01475 for (i = 0; i < ldns_resolver_searchlist_count(r); i++) {
01476 fprintf(output, "\t");
01477 ldns_rdf_print(output, s[i]);
01478 fprintf(output, "\n");
01479 }
01480
01481 fprintf(output, "nameservers:\n");
01482 for (i = 0; i < ldns_resolver_nameserver_count(r); i++) {
01483 fprintf(output, "\t");
01484 ldns_rdf_print(output, n[i]);
01485
01486 switch ((int)rtt[i]) {
01487 case LDNS_RESOLV_RTT_MIN:
01488 fprintf(output, " - reachable\n");
01489 break;
01490 case LDNS_RESOLV_RTT_INF:
01491 fprintf(output, " - unreachable\n");
01492 break;
01493 }
01494 }
01495 }
01496
01497 void
01498 ldns_zone_print(FILE *output, const ldns_zone *z)
01499 {
01500 ldns_rr_print(output, ldns_zone_soa(z));
01501 ldns_rr_list_print(output, ldns_zone_rrs(z));
01502 }