1 /** 2 * host2str.h - txt presentation of RRs 3 * 4 * a Net::DNS like library for C 5 * 6 * (c) NLnet Labs, 2005-2006 7 * 8 * See the file LICENSE for the license 9 */ 10 11 /** 12 * \file 13 * 14 * Contains functions to translate the main structures to their text 15 * representation, as well as functions to print them. 16 */ 17 18 #ifndef LDNS_HOST2STR_H 19 #define LDNS_HOST2STR_H 20 21 #include <ldns/common.h> 22 #include <ldns/error.h> 23 #include <ldns/rr.h> 24 #include <ldns/rdata.h> 25 #include <ldns/packet.h> 26 #include <ldns/buffer.h> 27 #include <ldns/resolver.h> 28 #include <ldns/zone.h> 29 #include <ctype.h> 30 31 #include "ldns/util.h" 32 33 #ifdef __cplusplus 34 extern "C" { 35 #endif 36 37 #define LDNS_APL_IP4 1 38 #define LDNS_APL_IP6 2 39 #define LDNS_APL_MASK 0x7f 40 #define LDNS_APL_NEGATION 0x80 41 42 /** 43 * Represent a NULL pointer (instead of a pointer to a ldns_rr as "; (null)" 44 * as opposed to outputting nothing at all in such a case. 45 */ 46 /* Flag Name Flag Nr. Has data associated 47 ---------------------------------------------------------------------*/ 48 #define LDNS_COMMENT_NULLS (1 << 0) 49 /** Show key id with DNSKEY RR's as comment */ 50 #define LDNS_COMMENT_KEY_ID (1 << 1) 51 /** Show if a DNSKEY is a ZSK or KSK as comment */ 52 #define LDNS_COMMENT_KEY_TYPE (1 << 2) 53 /** Show DNSKEY key size as comment */ 54 #define LDNS_COMMENT_KEY_SIZE (1 << 3) 55 /** Provide bubblebabble representation for DS RR's as comment */ 56 #define LDNS_COMMENT_BUBBLEBABBLE (1 << 4) 57 /** Show when a NSEC3 RR has the optout flag set as comment */ 58 #define LDNS_COMMENT_FLAGS (1 << 5) 59 /** Show the unhashed owner and next owner names for NSEC3 RR's as comment */ 60 #define LDNS_COMMENT_NSEC3_CHAIN (1 << 6) /* yes */ 61 /** Print mark up */ 62 #define LDNS_COMMENT_LAYOUT (1 << 7) 63 /** Also comment KEY_ID with RRSIGS **/ 64 #define LDNS_COMMENT_RRSIGS (1 << 8) 65 #define LDNS_FMT_ZEROIZE_RRSIGS (1 << 9) 66 #define LDNS_FMT_PAD_SOA_SERIAL (1 << 10) 67 #define LDNS_FMT_RFC3597 (1 << 11) /* yes */ 68 /** Prints only answer section of packets and only rdata of RRs **/ 69 #define LDNS_FMT_SHORT (1 << 12) 70 71 #define LDNS_FMT_FLAGS_WITH_DATA 2 72 73 /** Show key id, type and size as comment for DNSKEY RR's */ 74 #define LDNS_COMMENT_KEY (LDNS_COMMENT_KEY_ID \ 75 |LDNS_COMMENT_KEY_TYPE\ 76 |LDNS_COMMENT_KEY_SIZE) 77 78 /** 79 * Output format specifier 80 * 81 * Determines how Packets, Resource Records and Resource record data field are 82 * formatted when printing or converting to string. 83 * Currently it is only used to specify what aspects of a Resource Record are 84 * annotated in the comment section of the textual representation the record. 85 * This is specified with flags and potential extra data (such as for example 86 * a lookup map of hashes to real names for annotation NSEC3 records). 87 */ 88 struct ldns_struct_output_format 89 { 90 /** Specification of how RR's should be formatted in text */ 91 int flags; 92 /** Potential extra data to be used with formatting RR's in text */ 93 void *data; 94 }; 95 typedef struct ldns_struct_output_format ldns_output_format; 96 97 /** 98 * Output format struct with additional data for flags that use them. 99 * This struct may not be initialized directly. Use ldns_output_format_init 100 * to initialize. 101 */ 102 struct ldns_struct_output_format_storage 103 { int flags; 104 ldns_rbtree_t* hashmap; /* for LDNS_COMMENT_NSEC3_CHAIN */ 105 ldns_rdf* bitmap; /* for LDNS_FMT_RFC3597 */ 106 }; 107 typedef struct ldns_struct_output_format_storage ldns_output_format_storage; 108 109 /** 110 * Standard output format record that disables commenting in the textual 111 * representation of Resource Records completely. 112 */ 113 extern const ldns_output_format *ldns_output_format_nocomments; 114 /** 115 * Standard output format record that annotated only DNSKEY RR's with comment 116 * text. 117 */ 118 extern const ldns_output_format *ldns_output_format_onlykeyids; 119 /** 120 * The default output format record. Same as ldns_output_format_onlykeyids. 121 */ 122 extern const ldns_output_format *ldns_output_format_default; 123 /** 124 * Standard output format record that shows all DNSKEY related information in 125 * the comment text, plus the optout flag when set with NSEC3's, plus the 126 * bubblebabble representation of DS RR's. 127 */ 128 extern const ldns_output_format *ldns_output_format_bubblebabble; 129 130 /** 131 * Initialize output format storage to the default value. 132 * \param[in] fmt A reference to an output_format_ storage struct 133 * \return The initialized storage struct typecasted to ldns_output_format 134 */ 135 INLINE 136 ldns_output_format* ldns_output_format_init(ldns_output_format_storage* fmt) { 137 fmt->flags = ldns_output_format_default->flags; 138 fmt->hashmap = NULL; 139 fmt->bitmap = NULL; 140 return (ldns_output_format*)fmt; 141 } 142 143 /** 144 * Set an output format flag. 145 */ 146 INLINE void ldns_output_format_set(ldns_output_format* fmt, int flag) { 147 fmt->flags |= flag; 148 } 149 150 /** 151 * Clear an output format flag. 152 */ 153 INLINE void ldns_output_format_clear(ldns_output_format* fmt, int flag) { 154 fmt->flags &= !flag; 155 } 156 157 /** 158 * Makes sure the LDNS_FMT_RFC3597 is set in the output format. 159 * Marks the type to be printed in RFC3597 format. 160 * /param[in] fmt the output format to update 161 * /param[in] the type to be printed in RFC3597 format 162 * /return LDNS_STATUS_OK on success 163 */ 164 ldns_status 165 ldns_output_format_set_type(ldns_output_format* fmt, ldns_rr_type type); 166 167 /** 168 * Makes sure the LDNS_FMT_RFC3597 is set in the output format. 169 * Marks the type to not be printed in RFC3597 format. When no other types 170 * have been marked before, all known types (except the given one) will be 171 * marked for printing in RFC3597 format. 172 * /param[in] fmt the output format to update 173 * /param[in] the type not to be printed in RFC3597 format 174 * /return LDNS_STATUS_OK on success 175 */ 176 ldns_status 177 ldns_output_format_clear_type(ldns_output_format* fmt, ldns_rr_type type); 178 179 /** 180 * Converts an ldns packet opcode value to its mnemonic, and adds that 181 * to the output buffer 182 * \param[in] *output the buffer to add the data to 183 * \param[in] opcode to find the string representation of 184 * \return LDNS_STATUS_OK on success, or a buffer failure mode on error 185 */ 186 ldns_status 187 ldns_pkt_opcode2buffer_str(ldns_buffer *output, ldns_pkt_opcode opcode); 188 189 /** 190 * Converts an ldns packet rcode value to its mnemonic, and adds that 191 * to the output buffer 192 * \param[in] *output the buffer to add the data to 193 * \param[in] rcode to find the string representation of 194 * \return LDNS_STATUS_OK on success, or a buffer failure mode on error 195 */ 196 ldns_status 197 ldns_pkt_rcode2buffer_str(ldns_buffer *output, ldns_pkt_rcode rcode); 198 199 /** 200 * Converts an ldns algorithm type to its mnemonic, and adds that 201 * to the output buffer 202 * \param[in] *output the buffer to add the data to 203 * \param[in] algorithm to find the string representation of 204 * \return LDNS_STATUS_OK on success, or a buffer failure mode on error 205 */ 206 ldns_status 207 ldns_algorithm2buffer_str(ldns_buffer *output, 208 ldns_algorithm algorithm); 209 210 /** 211 * Converts an ldns certificate algorithm type to its mnemonic, 212 * and adds that to the output buffer 213 * \param[in] *output the buffer to add the data to 214 * \param[in] cert_algorithm to find the string representation of 215 * \return LDNS_STATUS_OK on success, or a buffer failure mode on error 216 */ 217 ldns_status 218 ldns_cert_algorithm2buffer_str(ldns_buffer *output, 219 ldns_cert_algorithm cert_algorithm); 220 221 222 /** 223 * Converts a packet opcode to its mnemonic and returns that as 224 * an allocated null-terminated string. 225 * Remember to free it. 226 * 227 * \param[in] opcode the opcode to convert to text 228 * \return null terminated char * data, or NULL on error 229 */ 230 char *ldns_pkt_opcode2str(ldns_pkt_opcode opcode); 231 232 /** 233 * Converts a packet rcode to its mnemonic and returns that as 234 * an allocated null-terminated string. 235 * Remember to free it. 236 * 237 * \param[in] rcode the rcode to convert to text 238 * \return null terminated char * data, or NULL on error 239 */ 240 char *ldns_pkt_rcode2str(ldns_pkt_rcode rcode); 241 242 /** 243 * Converts a signing algorithms to its mnemonic and returns that as 244 * an allocated null-terminated string. 245 * Remember to free it. 246 * 247 * \param[in] algorithm the algorithm to convert to text 248 * \return null terminated char * data, or NULL on error 249 */ 250 char *ldns_pkt_algorithm2str(ldns_algorithm algorithm); 251 252 /** 253 * Converts a cert algorithm to its mnemonic and returns that as 254 * an allocated null-terminated string. 255 * Remember to free it. 256 * 257 * \param[in] cert_algorithm to convert to text 258 * \return null terminated char * data, or NULL on error 259 */ 260 char *ldns_pkt_cert_algorithm2str(ldns_cert_algorithm cert_algorithm); 261 262 /** 263 * Converts an LDNS_RDF_TYPE_A rdata element to string format and adds it to the output buffer 264 * \param[in] *rdf The rdata to convert 265 * \param[in] *output The buffer to add the data to 266 * \return LDNS_STATUS_OK on success, and error status on failure 267 */ 268 ldns_status ldns_rdf2buffer_str_a(ldns_buffer *output, const ldns_rdf *rdf); 269 270 /** 271 * Converts an LDNS_RDF_TYPE_AAAA rdata element to string format and adds it to the output buffer 272 * \param[in] *rdf The rdata to convert 273 * \param[in] *output The buffer to add the data to 274 * \return LDNS_STATUS_OK on success, and error status on failure 275 */ 276 ldns_status ldns_rdf2buffer_str_aaaa(ldns_buffer *output, const ldns_rdf *rdf); 277 278 /** 279 * Converts an LDNS_RDF_TYPE_STR rdata element to string format and adds it to the output buffer 280 * \param[in] *rdf The rdata to convert 281 * \param[in] *output The buffer to add the data to 282 * \return LDNS_STATUS_OK on success, and error status on failure 283 */ 284 ldns_status ldns_rdf2buffer_str_str(ldns_buffer *output, const ldns_rdf *rdf); 285 286 /** 287 * Converts an LDNS_RDF_TYPE_B64 rdata element to string format and adds it to the output buffer 288 * \param[in] *rdf The rdata to convert 289 * \param[in] *output The buffer to add the data to 290 * \return LDNS_STATUS_OK on success, and error status on failure 291 */ 292 ldns_status ldns_rdf2buffer_str_b64(ldns_buffer *output, const ldns_rdf *rdf); 293 294 /** 295 * Converts an LDNS_RDF_TYPE_B32_EXT rdata element to string format and adds it to the output buffer 296 * \param[in] *rdf The rdata to convert 297 * \param[in] *output The buffer to add the data to 298 * \return LDNS_STATUS_OK on success, and error status on failure 299 */ 300 ldns_status ldns_rdf2buffer_str_b32_ext(ldns_buffer *output, const ldns_rdf *rdf); 301 302 /** 303 * Converts an LDNS_RDF_TYPE_HEX rdata element to string format and adds it to the output buffer 304 * \param[in] *rdf The rdata to convert 305 * \param[in] *output The buffer to add the data to 306 * \return LDNS_STATUS_OK on success, and error status on failure 307 */ 308 ldns_status ldns_rdf2buffer_str_hex(ldns_buffer *output, const ldns_rdf *rdf); 309 310 /** 311 * Converts an LDNS_RDF_TYPE_TYPE rdata element to string format and adds it to the output buffer 312 * \param[in] *rdf The rdata to convert 313 * \param[in] *output The buffer to add the data to 314 * \return LDNS_STATUS_OK on success, and error status on failure 315 */ 316 ldns_status ldns_rdf2buffer_str_type(ldns_buffer *output, const ldns_rdf *rdf); 317 318 /** 319 * Converts an LDNS_RDF_TYPE_CLASS rdata element to string format and adds it to the output buffer 320 * \param[in] *rdf The rdata to convert 321 * \param[in] *output The buffer to add the data to 322 * \return LDNS_STATUS_OK on success, and error status on failure 323 */ 324 ldns_status ldns_rdf2buffer_str_class(ldns_buffer *output, const ldns_rdf *rdf); 325 326 /** 327 * Converts an LDNS_RDF_TYPE_ALG rdata element to string format and adds it to the output buffer 328 * \param[in] *rdf The rdata to convert 329 * \param[in] *output The buffer to add the data to 330 * \return LDNS_STATUS_OK on success, and error status on failure 331 */ 332 ldns_status ldns_rdf2buffer_str_alg(ldns_buffer *output, const ldns_rdf *rdf); 333 334 /** 335 * Converts an ldns_rr_type value to its string representation, 336 * and places it in the given buffer 337 * \param[in] *output The buffer to add the data to 338 * \param[in] type the ldns_rr_type to convert 339 * \return LDNS_STATUS_OK on success, and error status on failure 340 */ 341 ldns_status ldns_rr_type2buffer_str(ldns_buffer *output, 342 const ldns_rr_type type); 343 344 /** 345 * Converts an ldns_rr_type value to its string representation, 346 * and returns that string. For unknown types, the string 347 * "TYPE<id>" is returned. This function allocates data that must be 348 * freed by the caller 349 * \param[in] type the ldns_rr_type to convert 350 * \return a newly allocated string 351 */ 352 char *ldns_rr_type2str(const ldns_rr_type type); 353 354 /** 355 * Converts an ldns_rr_class value to its string representation, 356 * and places it in the given buffer 357 * \param[in] *output The buffer to add the data to 358 * \param[in] klass the ldns_rr_class to convert 359 * \return LDNS_STATUS_OK on success, and error status on failure 360 */ 361 ldns_status ldns_rr_class2buffer_str(ldns_buffer *output, 362 const ldns_rr_class klass); 363 364 /** 365 * Converts an ldns_rr_class value to its string representation, 366 * and returns that string. For unknown types, the string 367 * "CLASS<id>" is returned. This function allocates data that must be 368 * freed by the caller 369 * \param[in] klass the ldns_rr_class to convert 370 * \return a newly allocated string 371 */ 372 char *ldns_rr_class2str(const ldns_rr_class klass); 373 374 375 /** 376 * Converts an LDNS_RDF_TYPE_CERT rdata element to string format and adds it to the output buffer 377 * \param[in] *rdf The rdata to convert 378 * \param[in] *output The buffer to add the data to 379 * \return LDNS_STATUS_OK on success, and error status on failure 380 */ 381 ldns_status ldns_rdf2buffer_str_cert_alg(ldns_buffer *output, const ldns_rdf *rdf); 382 383 /** 384 * Converts an LDNS_RDF_TYPE_LOC rdata element to string format and adds it to the output buffer 385 * \param[in] *rdf The rdata to convert 386 * \param[in] *output The buffer to add the data to 387 * \return LDNS_STATUS_OK on success, and error status on failure 388 */ 389 ldns_status ldns_rdf2buffer_str_loc(ldns_buffer *output, const ldns_rdf *rdf); 390 391 /** 392 * Converts an LDNS_RDF_TYPE_UNKNOWN rdata element to string format and adds it to the output buffer 393 * \param[in] *rdf The rdata to convert 394 * \param[in] *output The buffer to add the data to 395 * \return LDNS_STATUS_OK on success, and error status on failure 396 */ 397 ldns_status ldns_rdf2buffer_str_unknown(ldns_buffer *output, const ldns_rdf *rdf); 398 399 /** 400 * Converts an LDNS_RDF_TYPE_NSAP rdata element to string format and adds it to the output buffer 401 * \param[in] *rdf The rdata to convert 402 * \param[in] *output The buffer to add the data to 403 * \return LDNS_STATUS_OK on success, and error status on failure 404 */ 405 ldns_status ldns_rdf2buffer_str_nsap(ldns_buffer *output, const ldns_rdf *rdf); 406 407 /** 408 * Converts an LDNS_RDF_TYPE_ATMA rdata element to string format and adds it to the output buffer 409 * \param[in] *rdf The rdata to convert 410 * \param[in] *output The buffer to add the data to 411 * \return LDNS_STATUS_OK on success, and error status on failure 412 */ 413 ldns_status ldns_rdf2buffer_str_atma(ldns_buffer *output, const ldns_rdf *rdf); 414 415 /** 416 * Converts an LDNS_RDF_TYPE_WKS rdata element to string format and adds it to the output buffer 417 * \param[in] *rdf The rdata to convert 418 * \param[in] *output The buffer to add the data to 419 * \return LDNS_STATUS_OK on success, and error status on failure 420 */ 421 ldns_status ldns_rdf2buffer_str_wks(ldns_buffer *output, const ldns_rdf *rdf); 422 423 /** 424 * Converts an LDNS_RDF_TYPE_NSEC rdata element to string format and adds it to the output buffer 425 * \param[in] *rdf The rdata to convert 426 * \param[in] *output The buffer to add the data to 427 * \return LDNS_STATUS_OK on success, and error status on failure 428 */ 429 ldns_status ldns_rdf2buffer_str_nsec(ldns_buffer *output, const ldns_rdf *rdf); 430 431 /** 432 * Converts an LDNS_RDF_TYPE_PERIOD rdata element to string format and adds it to the output buffer 433 * \param[in] *rdf The rdata to convert 434 * \param[in] *output The buffer to add the data to 435 * \return LDNS_STATUS_OK on success, and error status on failure 436 */ 437 ldns_status ldns_rdf2buffer_str_period(ldns_buffer *output, const ldns_rdf *rdf); 438 439 /** 440 * Converts an LDNS_RDF_TYPE_TSIGTIME rdata element to string format and adds it to the output buffer 441 * \param[in] *rdf The rdata to convert 442 * \param[in] *output The buffer to add the data to 443 * \return LDNS_STATUS_OK on success, and error status on failure 444 */ 445 ldns_status ldns_rdf2buffer_str_tsigtime(ldns_buffer *output, const ldns_rdf *rdf); 446 447 /** 448 * Converts an LDNS_RDF_TYPE_APL rdata element to string format and adds it to the output buffer 449 * \param[in] *rdf The rdata to convert 450 * \param[in] *output The buffer to add the data to 451 * \return LDNS_STATUS_OK on success, and error status on failure 452 */ 453 ldns_status ldns_rdf2buffer_str_apl(ldns_buffer *output, const ldns_rdf *rdf); 454 455 /** 456 * Converts an LDNS_RDF_TYPE_INT16_DATA rdata element to string format and adds it to the output buffer 457 * \param[in] *rdf The rdata to convert 458 * \param[in] *output The buffer to add the data to 459 * \return LDNS_STATUS_OK on success, and error status on failure 460 */ 461 ldns_status ldns_rdf2buffer_str_int16_data(ldns_buffer *output, const ldns_rdf *rdf); 462 463 /** 464 * Converts an LDNS_RDF_TYPE_IPSECKEY rdata element to string format and adds it to the output buffer 465 * \param[in] *rdf The rdata to convert 466 * \param[in] *output The buffer to add the data to 467 * \return LDNS_STATUS_OK on success, and error status on failure 468 */ 469 ldns_status ldns_rdf2buffer_str_ipseckey(ldns_buffer *output, const ldns_rdf *rdf); 470 471 /** 472 * Converts the data in the rdata field to presentation 473 * format (as char *) and appends it to the given buffer 474 * 475 * \param[in] output pointer to the buffer to append the data to 476 * \param[in] rdf the pointer to the rdafa field containing the data 477 * \return status 478 */ 479 ldns_status ldns_rdf2buffer_str(ldns_buffer *output, const ldns_rdf *rdf); 480 481 /** 482 * Converts the data in the resource record to presentation 483 * format (as char *) and appends it to the given buffer. 484 * The presentation format of DNSKEY record is annotated with comments giving 485 * the id, type and size of the key. 486 * 487 * \param[in] output pointer to the buffer to append the data to 488 * \param[in] rr the pointer to the rr field to convert 489 * \return status 490 */ 491 ldns_status ldns_rr2buffer_str(ldns_buffer *output, const ldns_rr *rr); 492 493 /** 494 * Converts the data in the resource record to presentation 495 * format (as char *) and appends it to the given buffer. 496 * The presentation format is annotated with comments giving 497 * additional information on the record. 498 * 499 * \param[in] output pointer to the buffer to append the data to 500 * \param[in] fmt how to format the textual representation of the 501 * resource record. 502 * \param[in] rr the pointer to the rr field to convert 503 * \return status 504 */ 505 ldns_status ldns_rr2buffer_str_fmt(ldns_buffer *output, 506 const ldns_output_format *fmt, const ldns_rr *rr); 507 508 /** 509 * Converts the data in the DNS packet to presentation 510 * format (as char *) and appends it to the given buffer 511 * 512 * \param[in] output pointer to the buffer to append the data to 513 * \param[in] pkt the pointer to the packet to convert 514 * \return status 515 */ 516 ldns_status ldns_pkt2buffer_str(ldns_buffer *output, const ldns_pkt *pkt); 517 518 /** 519 * Converts the list of EDNS options to presentation 520 * format (as char *) and appends it to the given buffer 521 * 522 * \param[in] output pointer to the buffer to append the data to 523 * \param[in] edns_list the list of EDNS options 524 * \return status 525 */ 526 ldns_status ldns_edns_option_list2buffer_str(ldns_buffer *output, 527 ldns_edns_option_list* edns_list); 528 529 /** 530 * Converts the data in the DNS packet to presentation 531 * format (as char *) and appends it to the given buffer 532 * 533 * \param[in] output pointer to the buffer to append the data to 534 * \param[in] fmt how to format the textual representation of the packet 535 * \param[in] pkt the pointer to the packet to convert 536 * \return status 537 */ 538 ldns_status ldns_pkt2buffer_str_fmt(ldns_buffer *output, 539 const ldns_output_format *fmt, const ldns_pkt *pkt); 540 541 /** 542 * Converts an LDNS_RDF_TYPE_NSEC3_SALT rdata element to string format and adds it to the output buffer 543 * \param[in] *rdf The rdata to convert 544 * \param[in] *output The buffer to add the data to 545 * \return LDNS_STATUS_OK on success, and error status on failure 546 */ 547 ldns_status ldns_rdf2buffer_str_nsec3_salt(ldns_buffer *output, const ldns_rdf *rdf); 548 549 550 /** 551 * Converts the data in the DNS packet to presentation 552 * format (as char *) and appends it to the given buffer 553 * 554 * \param[in] output pointer to the buffer to append the data to 555 * \param[in] k the pointer to the private key to convert 556 * \return status 557 */ 558 ldns_status ldns_key2buffer_str(ldns_buffer *output, const ldns_key *k); 559 560 /** 561 * Converts an LDNS_RDF_TYPE_INT8 rdata element to string format and adds it to the output buffer 562 * \param[in] *rdf The rdata to convert 563 * \param[in] *output The buffer to add the data to 564 * \return LDNS_STATUS_OK on success, and error status on failure 565 */ 566 ldns_status ldns_rdf2buffer_str_int8(ldns_buffer *output, const ldns_rdf *rdf); 567 568 /** 569 * Converts an LDNS_RDF_TYPE_INT16 rdata element to string format and adds it to the output buffer 570 * \param[in] *rdf The rdata to convert 571 * \param[in] *output The buffer to add the data to 572 * \return LDNS_STATUS_OK on success, and error status on failure 573 */ 574 ldns_status ldns_rdf2buffer_str_int16(ldns_buffer *output, const ldns_rdf *rdf); 575 576 /** 577 * Converts an LDNS_RDF_TYPE_INT32 rdata element to string format and adds it to the output buffer 578 * \param[in] *rdf The rdata to convert 579 * \param[in] *output The buffer to add the data to 580 * \return LDNS_STATUS_OK on success, and error status on failure 581 */ 582 ldns_status ldns_rdf2buffer_str_int32(ldns_buffer *output, const ldns_rdf *rdf); 583 584 /** 585 * Converts an LDNS_RDF_TYPE_TIME rdata element to string format and adds it to the output buffer 586 * \param[in] *rdf The rdata to convert 587 * \param[in] *output The buffer to add the data to 588 * \return LDNS_STATUS_OK on success, and error status on failure 589 */ 590 ldns_status ldns_rdf2buffer_str_time(ldns_buffer *output, const ldns_rdf *rdf); 591 592 /** 593 * Converts an LDNS_RDF_TYPE_ILNP64 rdata element to 4 hexadecimal numbers 594 * separated by colons and adds it to the output buffer 595 * \param[in] *rdf The rdata to convert 596 * \param[in] *output The buffer to add the data to 597 * \return LDNS_STATUS_OK on success, and error status on failure 598 */ 599 ldns_status ldns_rdf2buffer_str_ilnp64(ldns_buffer *output, 600 const ldns_rdf *rdf); 601 602 /** 603 * Converts an LDNS_RDF_TYPE_EUI48 rdata element to 6 hexadecimal numbers 604 * separated by dashes and adds it to the output buffer 605 * \param[in] *rdf The rdata to convert 606 * \param[in] *output The buffer to add the data to 607 * \return LDNS_STATUS_OK on success, and error status on failure 608 */ 609 ldns_status ldns_rdf2buffer_str_eui48(ldns_buffer *output, 610 const ldns_rdf *rdf); 611 612 /** 613 * Converts an LDNS_RDF_TYPE_EUI64 rdata element to 8 hexadecimal numbers 614 * separated by dashes and adds it to the output buffer 615 * \param[in] *rdf The rdata to convert 616 * \param[in] *output The buffer to add the data to 617 * \return LDNS_STATUS_OK on success, and error status on failure 618 */ 619 ldns_status ldns_rdf2buffer_str_eui64(ldns_buffer *output, 620 const ldns_rdf *rdf); 621 622 /** 623 * Adds the LDNS_RDF_TYPE_TAG rdata to the output buffer, 624 * provided it contains only alphanumeric characters. 625 * \param[in] *rdf The rdata to convert 626 * \param[in] *output The buffer to add the data to 627 * \return LDNS_STATUS_OK on success, and error status on failure 628 */ 629 ldns_status ldns_rdf2buffer_str_tag(ldns_buffer *output, 630 const ldns_rdf *rdf); 631 632 /** 633 * Adds the LDNS_RDF_TYPE_LONG_STR rdata to the output buffer, in-between 634 * double quotes and all non printable characters properly escaped. 635 * \param[in] *rdf The rdata to convert 636 * \param[in] *output The buffer to add the data to 637 * \return LDNS_STATUS_OK on success, and error status on failure 638 */ 639 ldns_status ldns_rdf2buffer_str_long_str(ldns_buffer *output, 640 const ldns_rdf *rdf); 641 642 /** 643 * Converts an LDNS_RDF_TYPE_HIP rdata element to presentation format for 644 * the algorithm, HIT and Public Key and adds it the output buffer . 645 * \param[in] *rdf The rdata to convert 646 * \param[in] *output The buffer to add the data to 647 * \return LDNS_STATUS_OK on success, and error status on failure 648 */ 649 ldns_status ldns_rdf2buffer_str_hip(ldns_buffer *output, 650 const ldns_rdf *rdf); 651 652 /** 653 * Converts an LDNS_RDF_TYPE_AMTRELAY rdata element to presentation format for 654 * the precedence, D-bit, type and relay and adds it to the output buffer 655 * \param[in] *rdf The rdata to convert 656 * \param[in] *output The buffer to add the data to 657 * \return LDNS_STATUS_OK on success, and error status on failure 658 */ 659 ldns_status ldns_rdf2buffer_str_amtrelay(ldns_buffer *output, 660 const ldns_rdf *rdf); 661 662 /** 663 * Converts an LDNS_RDF_TYPE_SVCPARAMS rdata element to presentation format. 664 * \param[in] *rdf The rdata to convert 665 * \param[in] *output The buffer to add the data to 666 * \return LDNS_STATUS_OK on success, and error status on failure 667 */ 668 ldns_status ldns_rdf2buffer_str_svcparams(ldns_buffer *output, 669 const ldns_rdf *rdf); 670 671 /** 672 * Converts the data in the rdata field to presentation format and 673 * returns that as a char *. 674 * Remember to free it. 675 * 676 * \param[in] rdf The rdata field to convert 677 * \return null terminated char * data, or NULL on error 678 */ 679 char *ldns_rdf2str(const ldns_rdf *rdf); 680 681 /** 682 * Converts the data in the resource record to presentation format and 683 * returns that as a char *. 684 * Remember to free it. 685 * 686 * \param[in] rr The rdata field to convert 687 * \return null terminated char * data, or NULL on error 688 */ 689 char *ldns_rr2str(const ldns_rr *rr); 690 691 /** 692 * Converts the data in the resource record to presentation format and 693 * returns that as a char *. 694 * Remember to free it. 695 * 696 * \param[in] fmt how to format the resource record 697 * \param[in] rr The rdata field to convert 698 * \return null terminated char * data, or NULL on error 699 */ 700 char *ldns_rr2str_fmt(const ldns_output_format *fmt, const ldns_rr *rr); 701 702 /** 703 * Converts the data in the DNS packet to presentation format and 704 * returns that as a char *. 705 * Remember to free it. 706 * 707 * \param[in] pkt The rdata field to convert 708 * \return null terminated char * data, or NULL on error 709 */ 710 char *ldns_pkt2str(const ldns_pkt *pkt); 711 712 /** 713 * Converts the data in the DNS packet to presentation format and 714 * returns that as a char *. 715 * Remember to free it. 716 * 717 * \param[in] fmt how to format the packet 718 * \param[in] pkt The rdata field to convert 719 * \return null terminated char * data, or NULL on error 720 */ 721 char *ldns_pkt2str_fmt(const ldns_output_format *fmt, const ldns_pkt *pkt); 722 723 /** 724 * Converts a private key to the test presentation fmt and 725 * returns that as a char *. 726 * Remember to free it. 727 * 728 * \param[in] k the key to convert to text 729 * \return null terminated char * data, or NULL on error 730 */ 731 char *ldns_key2str(const ldns_key *k); 732 733 /** 734 * Converts a list of resource records to presentation format 735 * and returns that as a char *. 736 * Remember to free it. 737 * 738 * \param[in] rr_list the rr_list to convert to text 739 * \return null terminated char * data, or NULL on error 740 */ 741 char *ldns_rr_list2str(const ldns_rr_list *rr_list); 742 743 /** 744 * Converts a list of resource records to presentation format 745 * and returns that as a char *. 746 * Remember to free it. 747 * 748 * \param[in] fmt how to format the list of resource records 749 * \param[in] rr_list the rr_list to convert to text 750 * \return null terminated char * data, or NULL on error 751 */ 752 char *ldns_rr_list2str_fmt( 753 const ldns_output_format *fmt, const ldns_rr_list *rr_list); 754 755 /** 756 * Returns a copy of the data in the buffer as a null terminated 757 * char * string. The returned string must be freed by the caller. 758 * The buffer must be in write modus and may thus not have been flipped. 759 * 760 * \param[in] buffer buffer containing char * data 761 * \return null terminated char * data, or NULL on error 762 */ 763 char *ldns_buffer2str(ldns_buffer *buffer); 764 765 /** 766 * Exports and returns the data in the buffer as a null terminated 767 * char * string. The returned string must be freed by the caller. 768 * The buffer must be in write modus and may thus not have been flipped. 769 * The buffer is fixed after this function returns. 770 * 771 * \param[in] buffer buffer containing char * data 772 * \return null terminated char * data, or NULL on error 773 */ 774 char *ldns_buffer_export2str(ldns_buffer *buffer); 775 776 /** 777 * Prints the data in the rdata field to the given file stream 778 * (in presentation format) 779 * 780 * \param[in] output the file stream to print to 781 * \param[in] rdf the rdata field to print 782 * \return void 783 */ 784 void ldns_rdf_print(FILE *output, const ldns_rdf *rdf); 785 786 /** 787 * Prints the data in the resource record to the given file stream 788 * (in presentation format) 789 * 790 * \param[in] output the file stream to print to 791 * \param[in] rr the resource record to print 792 * \return void 793 */ 794 void ldns_rr_print(FILE *output, const ldns_rr *rr); 795 796 /** 797 * Prints the data in the resource record to the given file stream 798 * (in presentation format) 799 * 800 * \param[in] output the file stream to print to 801 * \param[in] fmt format of the textual representation 802 * \param[in] rr the resource record to print 803 * \return void 804 */ 805 void ldns_rr_print_fmt(FILE *output, 806 const ldns_output_format *fmt, const ldns_rr *rr); 807 808 /** 809 * Prints the data in the DNS packet to the given file stream 810 * (in presentation format) 811 * 812 * \param[in] output the file stream to print to 813 * \param[in] pkt the packet to print 814 * \return void 815 */ 816 void ldns_pkt_print(FILE *output, const ldns_pkt *pkt); 817 818 /** 819 * Prints the data in the DNS packet to the given file stream 820 * (in presentation format) 821 * 822 * \param[in] output the file stream to print to 823 * \param[in] fmt format of the textual representation 824 * \param[in] pkt the packet to print 825 * \return void 826 */ 827 void ldns_pkt_print_fmt(FILE *output, 828 const ldns_output_format *fmt, const ldns_pkt *pkt); 829 830 /** 831 * Converts a rr_list to presentation format and appends it to 832 * the output buffer 833 * \param[in] output the buffer to append output to 834 * \param[in] list the ldns_rr_list to print 835 * \return ldns_status 836 */ 837 ldns_status ldns_rr_list2buffer_str(ldns_buffer *output, const ldns_rr_list *list); 838 839 /** 840 * Converts a rr_list to presentation format and appends it to 841 * the output buffer 842 * \param[in] output the buffer to append output to 843 * \param[in] fmt format of the textual representation 844 * \param[in] list the ldns_rr_list to print 845 * \return ldns_status 846 */ 847 ldns_status ldns_rr_list2buffer_str_fmt(ldns_buffer *output, 848 const ldns_output_format *fmt, const ldns_rr_list *list); 849 850 /** 851 * Converts the header of a packet to presentation format and appends it to 852 * the output buffer 853 * \param[in] output the buffer to append output to 854 * \param[in] pkt the packet to convert the header of 855 * \return ldns_status 856 */ 857 ldns_status ldns_pktheader2buffer_str(ldns_buffer *output, const ldns_pkt *pkt); 858 859 /** 860 * print a rr_list to output 861 * \param[in] output the fd to print to 862 * \param[in] list the rr_list to print 863 */ 864 void ldns_rr_list_print(FILE *output, const ldns_rr_list *list); 865 866 /** 867 * print a rr_list to output 868 * \param[in] output the fd to print to 869 * \param[in] fmt format of the textual representation 870 * \param[in] list the rr_list to print 871 */ 872 void ldns_rr_list_print_fmt(FILE *output, 873 const ldns_output_format *fmt, const ldns_rr_list *list); 874 875 /** 876 * Print a resolver (in sofar that is possible) state 877 * to output. 878 * \param[in] output the fd to print to 879 * \param[in] r the resolver to print 880 */ 881 void ldns_resolver_print(FILE *output, const ldns_resolver *r); 882 883 /** 884 * Print a resolver (in sofar that is possible) state 885 * to output. 886 * \param[in] output the fd to print to 887 * \param[in] fmt format of the textual representation 888 * \param[in] r the resolver to print 889 */ 890 void ldns_resolver_print_fmt(FILE *output, 891 const ldns_output_format *fmt, const ldns_resolver *r); 892 893 /** 894 * Print a zone structure * to output. Note the SOA record 895 * is included in this output 896 * \param[in] output the fd to print to 897 * \param[in] z the zone to print 898 */ 899 void ldns_zone_print(FILE *output, const ldns_zone *z); 900 901 /** 902 * Print a zone structure * to output. Note the SOA record 903 * is included in this output 904 * \param[in] output the fd to print to 905 * \param[in] fmt format of the textual representation 906 * \param[in] z the zone to print 907 */ 908 void ldns_zone_print_fmt(FILE *output, 909 const ldns_output_format *fmt, const ldns_zone *z); 910 911 /** 912 * Print the ldns_rdf containing a dname to the buffer 913 * \param[in] output the buffer to print to 914 * \param[in] dname the dname to print 915 * \return ldns_status message if the printing succeeded 916 */ 917 ldns_status ldns_rdf2buffer_str_dname(ldns_buffer *output, const ldns_rdf *dname); 918 919 #ifdef __cplusplus 920 } 921 #endif 922 923 #endif /* LDNS_HOST2STR_H */ 924