host2str.c

Go to the documentation of this file.
00001 /*
00002  * host2str.c
00003  *
00004  * conversion routines from the host format
00005  * to the presentation format (strings)
00006  *
00007  * a Net::DNS like library for C
00008  * 
00009  * (c) NLnet Labs, 2004-2006
00010  *
00011  * See the file LICENSE for the license
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 /* lookup tables for standard DNS stuff  */
00033 
00034 /* Taken from RFC 2535, section 7.  */
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 /* Taken from RFC 2538  */
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 /* classes  */
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 /* if these are used elsewhere */
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 /* do NOT pass compressed data here :p */
00092 ldns_status
00093 ldns_rdf2buffer_str_dname(ldns_buffer *output, const ldns_rdf *dname)
00094 {
00095         /* can we do with 1 pos var? or without at all? */
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                 /* too large, return */
00106                 return LDNS_STATUS_DOMAINNAME_OVERFLOW;
00107         }
00108 
00109         /* special case: root label */
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                                 /* paranoia check for various 'strange' 
00117                                    characters in dnames
00118                                 */
00119                                 if (data[src_pos] == '.' ||
00120                                     data[src_pos] == '(' || data[src_pos] == ')') {
00121                                         ldns_buffer_printf(output, "\\%c", 
00122                                                         data[src_pos]);
00123                                         /* isprint!? */
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         /* create a YYYYMMDDHHMMSS string if possible */
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         ldns_lookup_table *lt;
00303 
00304         lt = ldns_lookup_by_id(ldns_algorithms, (int) data);
00305         if (lt) {
00306                 ldns_buffer_printf(output, "%s", lt->name);
00307         } else {
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         /* is it 0.<two digits> ? */
00321         if(exponent < 2) {
00322                 if(exponent == 1)
00323                         mantissa *= 10;
00324                 ldns_buffer_printf(output, "0.%02ld", (long)mantissa);
00325                 return;
00326         }
00327         /* always <digit><string of zeros> */
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         /* we could do checking (ie degrees < 90 etc)? */
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         /* protocol, followed by bitmap of services */
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         /* Note: this code is duplicated in higher.c in 
00468          * ldns_nsec_type_check() function
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         /* period is the number of seconds */
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         /* tsigtime is 48 bits network order unsigned integer */
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                         /* check if prefix < 32? */
00551                         if (negation) {
00552                                 ldns_buffer_printf(output, "!");
00553                         }
00554                         ldns_buffer_printf(output, "%u:", address_family);
00555                         /* address is variable length 0 - 4 */
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                         /* check if prefix < 128? */
00570                         if (negation) {
00571                                 ldns_buffer_printf(output, "!");
00572                         }
00573                         ldns_buffer_printf(output, "%u:", address_family);
00574                         /* address is variable length 0 - 16 */
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                         /* unknown address family */
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         /* Subtract the size (2) of the number that specifies the length */
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         /* wire format from 
00622            http://www.ietf.org/internet-drafts/draft-ietf-ipseckey-rr-12.txt
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                         /* no gateway */
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                         /* error? */
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         /* TSIG RRs have no presentation format, make them #size <data> */
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         /*ldns_buffer_printf(buffer, "%u:", ldns_rdf_get_type(rdf));*/
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                 /* TTL should NOT be printed if it is a question, 
00804                  * but we don't know that anymore... (do we?)
00805                  * if the rd count is 0 we deal with a question sec. RR 
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                         /* exceptions for qtype */
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                 /* per RR special comments - handy for DNSSEC types */
00851                 /* check to prevent question sec. rr from
00852                  * getting here */
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 /* HAVE_SSL */
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                 /* last */
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                 /* add some futher fields */
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         /* not used when ssl is not defined */
01070         ldns_rdf *b64_bignum = NULL;
01071         uint16_t i;
01072 #endif /* HAVE_SSL */
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                                 /* copied by looking at dnssec-keygen output */
01089                                 /* header */
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                                 /* print to buf, convert to bin, convert to b64,
01098                                  * print to buf */
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                                 /* print to buf, convert to bin, convert to b64,
01200                                  * print to buf */
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                                 /* is the filefmt specified for TSIG.. don't know */
01263                                 goto error;
01264                 }
01265 #endif /* HAVE_SSL */
01266         } else {
01267 #ifdef HAVE_SSL
01268                 LDNS_FREE(b64_bignum);
01269 #endif
01270                 LDNS_FREE(bignum);
01271                 return ldns_buffer_status(output);
01272         }
01273         LDNS_FREE(bignum);
01274         return status;
01275 
01276 #ifdef HAVE_SSL
01277         /* compiles warn the label isn't used */
01278 error:
01279         LDNS_FREE(bignum);
01280         return LDNS_STATUS_ERR;
01281 #endif /* HAVE_SSL */
01282         
01283 }
01284 
01285 /*
01286  * Zero terminate the buffer and fix it to the size of the string.
01287  */
01288 char *
01289 buffer2str(ldns_buffer *buffer)
01290 {
01291         char *tmp_str;
01292         char *str;
01293         
01294         /* check if buffer ends with \0, if not, and 
01295            if there is space, add it */
01296         if (*(ldns_buffer_at(buffer, ldns_buffer_position(buffer))) != 0) {
01297                 if (!ldns_buffer_reserve(buffer, 1)) {
01298                         return NULL;
01299                 }
01300                 ldns_buffer_write_u8(buffer, (uint8_t) '\0');
01301                 if (!ldns_buffer_set_capacity(buffer, ldns_buffer_position(buffer))) {
01302                         return NULL;
01303                 }
01304         }
01305 
01306         tmp_str = ldns_buffer_export(buffer);
01307         str = LDNS_XMALLOC(char, strlen(tmp_str) + 1);
01308         memcpy(str, tmp_str, strlen(tmp_str) + 1);
01309 
01310         return str;
01311 }
01312 
01313 char *
01314 ldns_rdf2str(const ldns_rdf *rdf)
01315 {
01316         char *result = NULL;
01317         ldns_buffer *tmp_buffer = ldns_buffer_new(LDNS_MIN_BUFLEN);
01318 
01319         if (ldns_rdf2buffer_str(tmp_buffer, rdf) == LDNS_STATUS_OK) {
01320                 /* export and return string, destroy rest */
01321                 result = buffer2str(tmp_buffer);
01322         }
01323         
01324         ldns_buffer_free(tmp_buffer);
01325         return result;
01326 }
01327 
01328 char *
01329 ldns_rr2str(const ldns_rr *rr)
01330 {
01331         char *result = NULL;
01332         ldns_buffer *tmp_buffer = ldns_buffer_new(LDNS_MIN_BUFLEN);
01333 
01334         if (ldns_rr2buffer_str(tmp_buffer, rr) == LDNS_STATUS_OK) {
01335                 /* export and return string, destroy rest */
01336                 result = buffer2str(tmp_buffer);
01337         }
01338         
01339         ldns_buffer_free(tmp_buffer);
01340         return result;
01341 }
01342 
01343 char *
01344 ldns_pkt2str(const ldns_pkt *pkt)
01345 {
01346         char *result = NULL;
01347         ldns_buffer *tmp_buffer = ldns_buffer_new(LDNS_MIN_BUFLEN);
01348 
01349         if (ldns_pkt2buffer_str(tmp_buffer, pkt) == LDNS_STATUS_OK) {
01350                 /* export and return string, destroy rest */
01351                 result = buffer2str(tmp_buffer);
01352         }
01353 
01354         ldns_buffer_free(tmp_buffer);
01355         return result;
01356 }
01357 
01358 char *
01359 ldns_key2str(const ldns_key *k)
01360 {
01361         char *result = NULL;
01362         ldns_buffer *tmp_buffer = ldns_buffer_new(LDNS_MIN_BUFLEN);
01363         if (ldns_key2buffer_str(tmp_buffer, k) == LDNS_STATUS_OK) {
01364                 /* export and return string, destroy rest */
01365                 result = buffer2str(tmp_buffer);
01366         }
01367         ldns_buffer_free(tmp_buffer);
01368         return result;
01369 }
01370 
01371 char *
01372 ldns_rr_list2str(const ldns_rr_list *list)
01373 {
01374         char *result = NULL;
01375         ldns_buffer *tmp_buffer = ldns_buffer_new(LDNS_MIN_BUFLEN); 
01376 
01377         if (list) {
01378                 if (ldns_rr_list2buffer_str(tmp_buffer, list) == LDNS_STATUS_OK) {
01379                 }
01380         } else {
01381                 ldns_buffer_printf(tmp_buffer, "(null)\n");
01382         }
01383 
01384         /* export and return string, destroy rest */
01385         result = buffer2str(tmp_buffer);
01386         ldns_buffer_free(tmp_buffer);
01387         return result;
01388 }
01389 
01390 void
01391 ldns_rdf_print(FILE *output, const ldns_rdf *rdf)
01392 {
01393         char *str = ldns_rdf2str(rdf);
01394         if (str) {
01395                 fprintf(output, "%s", str);
01396         } else {
01397                 fprintf(output, "Unable to convert rdf to string\n");
01398         }
01399         LDNS_FREE(str);
01400 }
01401 
01402 void
01403 ldns_rr_print(FILE *output, const ldns_rr *rr)
01404 {
01405         char *str = ldns_rr2str(rr);
01406         if (str) {
01407                 fprintf(output, "%s", str);
01408         } else {
01409                 fprintf(output, "Unable to convert rr to string\n");
01410         }
01411         LDNS_FREE(str);
01412 }
01413 
01414 void
01415 ldns_pkt_print(FILE *output, const ldns_pkt *pkt)
01416 {
01417         char *str = ldns_pkt2str(pkt);
01418         if (str) {
01419                 fprintf(output, "%s", str);
01420         } else {
01421                 fprintf(output, "Unable to convert packet to string\n");
01422         }
01423         LDNS_FREE(str);
01424 }
01425 
01426 void
01427 ldns_rr_list_print(FILE *output, const ldns_rr_list *lst)
01428 {
01429         size_t i;
01430         for (i = 0; i < ldns_rr_list_rr_count(lst); i++) {
01431                 ldns_rr_print(output, ldns_rr_list_rr(lst, i));
01432         }
01433 }
01434 
01435 void
01436 ldns_resolver_print(FILE *output, const ldns_resolver *r)
01437 {
01438         uint16_t i;
01439         ldns_rdf **n;
01440         ldns_rdf **s;
01441         size_t *rtt;
01442         if (!r) {
01443                 return;
01444         }
01445         n = ldns_resolver_nameservers(r);
01446         s = ldns_resolver_searchlist(r);
01447         rtt = ldns_resolver_rtt(r);
01448 
01449         fprintf(output, "port: %d\n", (int)ldns_resolver_port(r));
01450         fprintf(output, "edns0 size: %d\n", (int)ldns_resolver_edns_udp_size(r));
01451         fprintf(output, "use ip6: %d\n", (int)ldns_resolver_ip6(r));
01452 
01453         fprintf(output, "recursive: %d\n", ldns_resolver_recursive(r));
01454         fprintf(output, "usevc: %d\n", ldns_resolver_usevc(r));
01455         fprintf(output, "igntc: %d\n", ldns_resolver_igntc(r));
01456         fprintf(output, "fail: %d\n", ldns_resolver_fail(r));
01457         fprintf(output, "retry: %d\n", (int)ldns_resolver_retry(r));
01458         fprintf(output, "timeout: %d\n", (int)ldns_resolver_timeout(r).tv_sec);
01459         
01460         fprintf(output, "default domain: ");
01461         ldns_rdf_print(output, ldns_resolver_domain(r)); 
01462         fprintf(output, "\n");
01463 
01464         fprintf(output, "searchlist:\n");
01465         for (i = 0; i < ldns_resolver_searchlist_count(r); i++) {
01466                 fprintf(output, "\t");
01467                 ldns_rdf_print(output, s[i]);
01468                 fprintf(output, "\n");
01469         }
01470 
01471         fprintf(output, "nameservers:\n");
01472         for (i = 0; i < ldns_resolver_nameserver_count(r); i++) {
01473                 fprintf(output, "\t");
01474                 ldns_rdf_print(output, n[i]);
01475 
01476                 switch ((int)rtt[i]) {
01477                         case LDNS_RESOLV_RTT_MIN:
01478                         fprintf(output, " - reachable\n");
01479                         break;
01480                         case LDNS_RESOLV_RTT_INF:
01481                         fprintf(output, " - unreachable\n");
01482                         break;
01483                 }
01484         }
01485 }
01486 
01487 void
01488 ldns_zone_print(FILE *output, const ldns_zone *z)
01489 {
01490         ldns_rr_print(output, ldns_zone_soa(z));
01491         ldns_rr_list_print(output, ldns_zone_rrs(z));
01492 }

Generated on Tue Nov 20 07:14:14 2007 for ldns by  doxygen 1.5.3-20071008