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 (in stead of a pointer to a ldns_rr as "; (null)" 44 * as opposed to outputting nothing at all in such a case. 45 */ 46 #define LDNS_COMMENT_NULLS 0x0001 47 /** Show key id with DNSKEY RR's as comment */ 48 #define LDNS_COMMENT_KEY_ID 0x0002 49 /** Show if a DNSKEY is a ZSK or KSK as comment */ 50 #define LDNS_COMMENT_KEY_TYPE 0x0004 51 /** Show DNSKEY key size as comment */ 52 #define LDNS_COMMENT_KEY_SIZE 0x0008 53 /** Show key id, type and size as comment for DNSKEY RR's */ 54 #define LDNS_COMMENT_KEY (LDNS_COMMENT_KEY_ID \ 55 |LDNS_COMMENT_KEY_TYPE\ 56 |LDNS_COMMENT_KEY_SIZE) 57 /** Provide bubblebabble representation for DS RR's as comment */ 58 #define LDNS_COMMENT_BUBBLEBABBLE 0x0010 59 /** Show when a NSEC3 RR has the optout flag set as comment */ 60 #define LDNS_COMMENT_FLAGS 0x0020 61 /** Show the unhashed owner and next owner names for NSEC3 RR's as comment */ 62 #define LDNS_COMMENT_NSEC3_CHAIN 0x0040 63 /** Print mark up */ 64 #define LDNS_COMMENT_LAYOUT 0x0080 65 /** Also comment KEY_ID with RRSIGS **/ 66 #define LDNS_COMMENT_RRSIGS 0x0100 67 #define LDNS_FMT_ZEROIZE_RRSIGS 0x0200 68 #define LDNS_FMT_PAD_SOA_SERIAL 0x0400 69 70 /** 71 * Output format specifier 72 * 73 * Determines how Packets, Resource Records and Resource record data fiels are 74 * formatted when printing or converting to string. 75 * Currently it is only used to specify what aspects of a Resource Record are 76 * annotated in the comment section of the textual representation the record. 77 * This is speciefed with flags and potential exra data (such as for example 78 * a lookup map of hashes to real names for annotation NSEC3 records). 79 */ 80 struct ldns_struct_output_format 81 { 82 /** Specification of how RR's should be formatted in text */ 83 int flags; 84 /** Potential extra data to be used with formatting RR's in text */ 85 void *data; 86 }; 87 typedef struct ldns_struct_output_format ldns_output_format; 88 89 /** 90 * Standard output format record that disables commenting in the textual 91 * representation of Resource Records completely. 92 */ 93 extern const ldns_output_format *ldns_output_format_nocomments; 94 /** 95 * Standard output format record that annotated only DNSKEY RR's with commenti 96 * text. 97 */ 98 extern const ldns_output_format *ldns_output_format_onlykeyids; 99 /** 100 * The default output format record. Same as ldns_output_format_onlykeyids. 101 */ 102 extern const ldns_output_format *ldns_output_format_default; 103 /** 104 * Standard output format record that shows all DNSKEY related information in 105 * the comment text, plus the optout flag when set with NSEC3's, plus the 106 * bubblebabble representation of DS RR's. 107 */ 108 extern const ldns_output_format *ldns_output_format_bubblebabble; 109 110 /** 111 * Converts an ldns packet opcode value to its mnemonic, and adds that 112 * to the output buffer 113 * \param[in] *output the buffer to add the data to 114 * \param[in] opcode to find the string representation of 115 * \return LDNS_STATUS_OK on success, or a buffer failure mode on error 116 */ 117 ldns_status 118 ldns_pkt_opcode2buffer_str(ldns_buffer *output, ldns_pkt_opcode opcode); 119 120 /** 121 * Converts an ldns packet rcode value to its mnemonic, and adds that 122 * to the output buffer 123 * \param[in] *output the buffer to add the data to 124 * \param[in] rcode to find the string representation of 125 * \return LDNS_STATUS_OK on success, or a buffer failure mode on error 126 */ 127 ldns_status 128 ldns_pkt_rcode2buffer_str(ldns_buffer *output, ldns_pkt_rcode rcode); 129 130 /** 131 * Converts an ldns algorithm type to its mnemonic, and adds that 132 * to the output buffer 133 * \param[in] *output the buffer to add the data to 134 * \param[in] algorithm to find the string representation of 135 * \return LDNS_STATUS_OK on success, or a buffer failure mode on error 136 */ 137 ldns_status 138 ldns_algorithm2buffer_str(ldns_buffer *output, 139 ldns_algorithm algorithm); 140 141 /** 142 * Converts an ldns certificate algorithm type to its mnemonic, 143 * and adds that to the output buffer 144 * \param[in] *output the buffer to add the data to 145 * \param[in] cert_algorithm to find the string representation of 146 * \return LDNS_STATUS_OK on success, or a buffer failure mode on error 147 */ 148 ldns_status 149 ldns_cert_algorithm2buffer_str(ldns_buffer *output, 150 ldns_cert_algorithm cert_algorithm); 151 152 153 /** 154 * Converts a packet opcode to its mnemonic and returns that as 155 * an allocated null-terminated string. 156 * Remember to free it. 157 * 158 * \param[in] opcode the opcode to convert to text 159 * \return null terminated char * data, or NULL on error 160 */ 161 char *ldns_pkt_opcode2str(ldns_pkt_opcode opcode); 162 163 /** 164 * Converts a packet rcode to its mnemonic and returns that as 165 * an allocated null-terminated string. 166 * Remember to free it. 167 * 168 * \param[in] rcode the rcode to convert to text 169 * \return null terminated char * data, or NULL on error 170 */ 171 char *ldns_pkt_rcode2str(ldns_pkt_rcode rcode); 172 173 /** 174 * Converts a signing algorithms to its mnemonic and returns that as 175 * an allocated null-terminated string. 176 * Remember to free it. 177 * 178 * \param[in] algorithm the algorithm to convert to text 179 * \return null terminated char * data, or NULL on error 180 */ 181 char *ldns_pkt_algorithm2str(ldns_algorithm algorithm); 182 183 /** 184 * Converts a cert algorithm to its mnemonic and returns that as 185 * an allocated null-terminated string. 186 * Remember to free it. 187 * 188 * \param[in] cert_algorithm to convert to text 189 * \return null terminated char * data, or NULL on error 190 */ 191 char *ldns_pkt_cert_algorithm2str(ldns_cert_algorithm cert_algorithm); 192 193 /** 194 * Converts an LDNS_RDF_TYPE_A rdata element to string format and adds it to the output buffer 195 * \param[in] *rdf The rdata to convert 196 * \param[in] *output The buffer to add the data to 197 * \return LDNS_STATUS_OK on success, and error status on failure 198 */ 199 ldns_status ldns_rdf2buffer_str_a(ldns_buffer *output, const ldns_rdf *rdf); 200 201 /** 202 * Converts an LDNS_RDF_TYPE_AAAA rdata element to string format and adds it to the output buffer 203 * \param[in] *rdf The rdata to convert 204 * \param[in] *output The buffer to add the data to 205 * \return LDNS_STATUS_OK on success, and error status on failure 206 */ 207 ldns_status ldns_rdf2buffer_str_aaaa(ldns_buffer *output, const ldns_rdf *rdf); 208 209 /** 210 * Converts an LDNS_RDF_TYPE_STR rdata element to string format and adds it to the output buffer 211 * \param[in] *rdf The rdata to convert 212 * \param[in] *output The buffer to add the data to 213 * \return LDNS_STATUS_OK on success, and error status on failure 214 */ 215 ldns_status ldns_rdf2buffer_str_str(ldns_buffer *output, const ldns_rdf *rdf); 216 217 /** 218 * Converts an LDNS_RDF_TYPE_B64 rdata element to string format and adds it to the output buffer 219 * \param[in] *rdf The rdata to convert 220 * \param[in] *output The buffer to add the data to 221 * \return LDNS_STATUS_OK on success, and error status on failure 222 */ 223 ldns_status ldns_rdf2buffer_str_b64(ldns_buffer *output, const ldns_rdf *rdf); 224 225 /** 226 * Converts an LDNS_RDF_TYPE_B32_EXT rdata element to string format and adds it to the output buffer 227 * \param[in] *rdf The rdata to convert 228 * \param[in] *output The buffer to add the data to 229 * \return LDNS_STATUS_OK on success, and error status on failure 230 */ 231 ldns_status ldns_rdf2buffer_str_b32_ext(ldns_buffer *output, const ldns_rdf *rdf); 232 233 /** 234 * Converts an LDNS_RDF_TYPE_HEX rdata element to string format and adds it to the output buffer 235 * \param[in] *rdf The rdata to convert 236 * \param[in] *output The buffer to add the data to 237 * \return LDNS_STATUS_OK on success, and error status on failure 238 */ 239 ldns_status ldns_rdf2buffer_str_hex(ldns_buffer *output, const ldns_rdf *rdf); 240 241 /** 242 * Converts an LDNS_RDF_TYPE_TYPE rdata element to string format and adds it to the output buffer 243 * \param[in] *rdf The rdata to convert 244 * \param[in] *output The buffer to add the data to 245 * \return LDNS_STATUS_OK on success, and error status on failure 246 */ 247 ldns_status ldns_rdf2buffer_str_type(ldns_buffer *output, const ldns_rdf *rdf); 248 249 /** 250 * Converts an LDNS_RDF_TYPE_CLASS rdata element to string format and adds it to the output buffer 251 * \param[in] *rdf The rdata to convert 252 * \param[in] *output The buffer to add the data to 253 * \return LDNS_STATUS_OK on success, and error status on failure 254 */ 255 ldns_status ldns_rdf2buffer_str_class(ldns_buffer *output, const ldns_rdf *rdf); 256 257 /** 258 * Converts an LDNS_RDF_TYPE_ALG rdata element to string format and adds it to the output buffer 259 * \param[in] *rdf The rdata to convert 260 * \param[in] *output The buffer to add the data to 261 * \return LDNS_STATUS_OK on success, and error status on failure 262 */ 263 ldns_status ldns_rdf2buffer_str_alg(ldns_buffer *output, const ldns_rdf *rdf); 264 265 /** 266 * Converts an ldns_rr_type value to its string representation, 267 * and places it in the given buffer 268 * \param[in] *output The buffer to add the data to 269 * \param[in] type the ldns_rr_type to convert 270 * \return LDNS_STATUS_OK on success, and error status on failure 271 */ 272 ldns_status ldns_rr_type2buffer_str(ldns_buffer *output, 273 const ldns_rr_type type); 274 275 /** 276 * Converts an ldns_rr_type value to its string representation, 277 * and returns that string. For unknown types, the string 278 * "TYPE<id>" is returned. This function allocates data that must be 279 * freed by the caller 280 * \param[in] type the ldns_rr_type to convert 281 * \return a newly allocated string 282 */ 283 char *ldns_rr_type2str(const ldns_rr_type type); 284 285 /** 286 * Converts an ldns_rr_class value to its string representation, 287 * and places it in the given buffer 288 * \param[in] *output The buffer to add the data to 289 * \param[in] klass the ldns_rr_class to convert 290 * \return LDNS_STATUS_OK on success, and error status on failure 291 */ 292 ldns_status ldns_rr_class2buffer_str(ldns_buffer *output, 293 const ldns_rr_class klass); 294 295 /** 296 * Converts an ldns_rr_class value to its string representation, 297 * and returns that string. For unknown types, the string 298 * "CLASS<id>" is returned. This function allocates data that must be 299 * freed by the caller 300 * \param[in] klass the ldns_rr_class to convert 301 * \return a newly allocated string 302 */ 303 char *ldns_rr_class2str(const ldns_rr_class klass); 304 305 306 /** 307 * Converts an LDNS_RDF_TYPE_CERT rdata element to string format and adds it to the output buffer 308 * \param[in] *rdf The rdata to convert 309 * \param[in] *output The buffer to add the data to 310 * \return LDNS_STATUS_OK on success, and error status on failure 311 */ 312 ldns_status ldns_rdf2buffer_str_cert_alg(ldns_buffer *output, const ldns_rdf *rdf); 313 314 /** 315 * Converts an LDNS_RDF_TYPE_LOC rdata element to string format and adds it to the output buffer 316 * \param[in] *rdf The rdata to convert 317 * \param[in] *output The buffer to add the data to 318 * \return LDNS_STATUS_OK on success, and error status on failure 319 */ 320 ldns_status ldns_rdf2buffer_str_loc(ldns_buffer *output, const ldns_rdf *rdf); 321 322 /** 323 * Converts an LDNS_RDF_TYPE_UNKNOWN rdata element to string format and adds it to the output buffer 324 * \param[in] *rdf The rdata to convert 325 * \param[in] *output The buffer to add the data to 326 * \return LDNS_STATUS_OK on success, and error status on failure 327 */ 328 ldns_status ldns_rdf2buffer_str_unknown(ldns_buffer *output, const ldns_rdf *rdf); 329 330 /** 331 * Converts an LDNS_RDF_TYPE_NSAP rdata element to string format and adds it to the output buffer 332 * \param[in] *rdf The rdata to convert 333 * \param[in] *output The buffer to add the data to 334 * \return LDNS_STATUS_OK on success, and error status on failure 335 */ 336 ldns_status ldns_rdf2buffer_str_nsap(ldns_buffer *output, const ldns_rdf *rdf); 337 338 /** 339 * Converts an LDNS_RDF_TYPE_ATMA rdata element to string format and adds it to the output buffer 340 * \param[in] *rdf The rdata to convert 341 * \param[in] *output The buffer to add the data to 342 * \return LDNS_STATUS_OK on success, and error status on failure 343 */ 344 ldns_status ldns_rdf2buffer_str_atma(ldns_buffer *output, const ldns_rdf *rdf); 345 346 /** 347 * Converts an LDNS_RDF_TYPE_WKS rdata element to string format and adds it to the output buffer 348 * \param[in] *rdf The rdata to convert 349 * \param[in] *output The buffer to add the data to 350 * \return LDNS_STATUS_OK on success, and error status on failure 351 */ 352 ldns_status ldns_rdf2buffer_str_wks(ldns_buffer *output, const ldns_rdf *rdf); 353 354 /** 355 * Converts an LDNS_RDF_TYPE_NSEC rdata element to string format and adds it to the output buffer 356 * \param[in] *rdf The rdata to convert 357 * \param[in] *output The buffer to add the data to 358 * \return LDNS_STATUS_OK on success, and error status on failure 359 */ 360 ldns_status ldns_rdf2buffer_str_nsec(ldns_buffer *output, const ldns_rdf *rdf); 361 362 /** 363 * Converts an LDNS_RDF_TYPE_PERIOD rdata element to string format and adds it to the output buffer 364 * \param[in] *rdf The rdata to convert 365 * \param[in] *output The buffer to add the data to 366 * \return LDNS_STATUS_OK on success, and error status on failure 367 */ 368 ldns_status ldns_rdf2buffer_str_period(ldns_buffer *output, const ldns_rdf *rdf); 369 370 /** 371 * Converts an LDNS_RDF_TYPE_TSIGTIME rdata element to string format and adds it to the output buffer 372 * \param[in] *rdf The rdata to convert 373 * \param[in] *output The buffer to add the data to 374 * \return LDNS_STATUS_OK on success, and error status on failure 375 */ 376 ldns_status ldns_rdf2buffer_str_tsigtime(ldns_buffer *output, const ldns_rdf *rdf); 377 378 /** 379 * Converts an LDNS_RDF_TYPE_APL rdata element to string format and adds it to the output buffer 380 * \param[in] *rdf The rdata to convert 381 * \param[in] *output The buffer to add the data to 382 * \return LDNS_STATUS_OK on success, and error status on failure 383 */ 384 ldns_status ldns_rdf2buffer_str_apl(ldns_buffer *output, const ldns_rdf *rdf); 385 386 /** 387 * Converts an LDNS_RDF_TYPE_INT16_DATA rdata element to string format and adds it to the output buffer 388 * \param[in] *rdf The rdata to convert 389 * \param[in] *output The buffer to add the data to 390 * \return LDNS_STATUS_OK on success, and error status on failure 391 */ 392 ldns_status ldns_rdf2buffer_str_int16_data(ldns_buffer *output, const ldns_rdf *rdf); 393 394 /** 395 * Converts an LDNS_RDF_TYPE_IPSECKEY rdata element to string format and adds it to the output buffer 396 * \param[in] *rdf The rdata to convert 397 * \param[in] *output The buffer to add the data to 398 * \return LDNS_STATUS_OK on success, and error status on failure 399 */ 400 ldns_status ldns_rdf2buffer_str_ipseckey(ldns_buffer *output, const ldns_rdf *rdf); 401 402 /** 403 * Converts an LDNS_RDF_TYPE_TSIG rdata element to string format and adds it to the output buffer 404 * \param[in] *rdf The rdata to convert 405 * \param[in] *output The buffer to add the data to 406 * \return LDNS_STATUS_OK on success, and error status on failure 407 */ 408 ldns_status ldns_rdf2buffer_str_tsig(ldns_buffer *output, const ldns_rdf *rdf); 409 410 411 /** 412 * Converts the data in the rdata field to presentation 413 * format (as char *) and appends it to the given buffer 414 * 415 * \param[in] output pointer to the buffer to append the data to 416 * \param[in] rdf the pointer to the rdafa field containing the data 417 * \return status 418 */ 419 ldns_status ldns_rdf2buffer_str(ldns_buffer *output, const ldns_rdf *rdf); 420 421 /** 422 * Converts the data in the resource record to presentation 423 * format (as char *) and appends it to the given buffer. 424 * The presentation format of DNSKEY record is annotated with comments giving 425 * the id, type and size of the key. 426 * 427 * \param[in] output pointer to the buffer to append the data to 428 * \param[in] rr the pointer to the rr field to convert 429 * \return status 430 */ 431 ldns_status ldns_rr2buffer_str(ldns_buffer *output, const ldns_rr *rr); 432 433 /** 434 * Converts the data in the resource record to presentation 435 * format (as char *) and appends it to the given buffer. 436 * The presentation format is annotated with comments giving 437 * additional information on the record. 438 * 439 * \param[in] output pointer to the buffer to append the data to 440 * \param[in] fmt how to format the textual representation of the 441 * resource record. 442 * \param[in] rr the pointer to the rr field to convert 443 * \return status 444 */ 445 ldns_status ldns_rr2buffer_str_fmt(ldns_buffer *output, 446 const ldns_output_format *fmt, const ldns_rr *rr); 447 448 /** 449 * Converts the data in the DNS packet to presentation 450 * format (as char *) and appends it to the given buffer 451 * 452 * \param[in] output pointer to the buffer to append the data to 453 * \param[in] pkt the pointer to the packet to convert 454 * \return status 455 */ 456 ldns_status ldns_pkt2buffer_str(ldns_buffer *output, const ldns_pkt *pkt); 457 458 /** 459 * Converts the data in the DNS packet to presentation 460 * format (as char *) and appends it to the given buffer 461 * 462 * \param[in] output pointer to the buffer to append the data to 463 * \param[in] fmt how to format the textual representation of the packet 464 * \param[in] pkt the pointer to the packet to convert 465 * \return status 466 */ 467 ldns_status ldns_pkt2buffer_str_fmt(ldns_buffer *output, 468 const ldns_output_format *fmt, const ldns_pkt *pkt); 469 470 /** 471 * Converts an LDNS_RDF_TYPE_NSEC3_SALT rdata element to string format and adds it to the output buffer 472 * \param[in] *rdf The rdata to convert 473 * \param[in] *output The buffer to add the data to 474 * \return LDNS_STATUS_OK on success, and error status on failure 475 */ 476 ldns_status ldns_rdf2buffer_str_nsec3_salt(ldns_buffer *output, const ldns_rdf *rdf); 477 478 479 /** 480 * Converts the data in the DNS packet to presentation 481 * format (as char *) and appends it to the given buffer 482 * 483 * \param[in] output pointer to the buffer to append the data to 484 * \param[in] k the pointer to the private key to convert 485 * \return status 486 */ 487 ldns_status ldns_key2buffer_str(ldns_buffer *output, const ldns_key *k); 488 489 /** 490 * Converts an LDNS_RDF_TYPE_INT8 rdata element to string format and adds it to the output buffer 491 * \param[in] *rdf The rdata to convert 492 * \param[in] *output The buffer to add the data to 493 * \return LDNS_STATUS_OK on success, and error status on failure 494 */ 495 ldns_status ldns_rdf2buffer_str_int8(ldns_buffer *output, const ldns_rdf *rdf); 496 497 /** 498 * Converts an LDNS_RDF_TYPE_INT16 rdata element to string format and adds it to the output buffer 499 * \param[in] *rdf The rdata to convert 500 * \param[in] *output The buffer to add the data to 501 * \return LDNS_STATUS_OK on success, and error status on failure 502 */ 503 ldns_status ldns_rdf2buffer_str_int16(ldns_buffer *output, const ldns_rdf *rdf); 504 505 /** 506 * Converts an LDNS_RDF_TYPE_INT32 rdata element to string format and adds it to the output buffer 507 * \param[in] *rdf The rdata to convert 508 * \param[in] *output The buffer to add the data to 509 * \return LDNS_STATUS_OK on success, and error status on failure 510 */ 511 ldns_status ldns_rdf2buffer_str_int32(ldns_buffer *output, const ldns_rdf *rdf); 512 513 /** 514 * Converts an LDNS_RDF_TYPE_TIME rdata element to string format and adds it to the output buffer 515 * \param[in] *rdf The rdata to convert 516 * \param[in] *output The buffer to add the data to 517 * \return LDNS_STATUS_OK on success, and error status on failure 518 */ 519 ldns_status ldns_rdf2buffer_str_time(ldns_buffer *output, const ldns_rdf *rdf); 520 521 /** 522 * Converts the data in the rdata field to presentation format and 523 * returns that as a char *. 524 * Remember to free it. 525 * 526 * \param[in] rdf The rdata field to convert 527 * \return null terminated char * data, or NULL on error 528 */ 529 char *ldns_rdf2str(const ldns_rdf *rdf); 530 531 /** 532 * Converts the data in the resource record to presentation format and 533 * returns that as a char *. 534 * Remember to free it. 535 * 536 * \param[in] rr The rdata field to convert 537 * \return null terminated char * data, or NULL on error 538 */ 539 char *ldns_rr2str(const ldns_rr *rr); 540 541 /** 542 * Converts the data in the resource record to presentation format and 543 * returns that as a char *. 544 * Remember to free it. 545 * 546 * \param[in] fmt how to format the resource record 547 * \param[in] rr The rdata field to convert 548 * \return null terminated char * data, or NULL on error 549 */ 550 char *ldns_rr2str_fmt(const ldns_output_format *fmt, const ldns_rr *rr); 551 552 /** 553 * Converts the data in the DNS packet to presentation format and 554 * returns that as a char *. 555 * Remember to free it. 556 * 557 * \param[in] pkt The rdata field to convert 558 * \return null terminated char * data, or NULL on error 559 */ 560 char *ldns_pkt2str(const ldns_pkt *pkt); 561 562 /** 563 * Converts the data in the DNS packet to presentation format and 564 * returns that as a char *. 565 * Remember to free it. 566 * 567 * \param[in] fmt how to format the packet 568 * \param[in] pkt The rdata field to convert 569 * \return null terminated char * data, or NULL on error 570 */ 571 char *ldns_pkt2str_fmt(const ldns_output_format *fmt, const ldns_pkt *pkt); 572 573 /** 574 * Converts a private key to the test presentation fmt and 575 * returns that as a char *. 576 * Remember to free it. 577 * 578 * \param[in] k the key to convert to text 579 * \return null terminated char * data, or NULL on error 580 */ 581 char *ldns_key2str(const ldns_key *k); 582 583 /** 584 * Converts a list of resource records to presentation format 585 * and returns that as a char *. 586 * Remember to free it. 587 * 588 * \param[in] rr_list the rr_list to convert to text 589 * \return null terminated char * data, or NULL on error 590 */ 591 char *ldns_rr_list2str(const ldns_rr_list *rr_list); 592 593 /** 594 * Converts a list of resource records to presentation format 595 * and returns that as a char *. 596 * Remember to free it. 597 * 598 * \param[in] fmt how to format the list of resource records 599 * \param[in] rr_list the rr_list to convert to text 600 * \return null terminated char * data, or NULL on error 601 */ 602 char *ldns_rr_list2str_fmt( 603 const ldns_output_format *fmt, const ldns_rr_list *rr_list); 604 605 /** 606 * Returns a copy of the data in the buffer as a null terminated 607 * char * string. The returned string must be freed by the caller. 608 * The buffer must be in write modus and may thus not have been flipped. 609 * 610 * \param[in] buffer buffer containing char * data 611 * \return null terminated char * data, or NULL on error 612 */ 613 char *ldns_buffer2str(ldns_buffer *buffer); 614 615 /** 616 * Exports and returns the data in the buffer as a null terminated 617 * char * string. The returned string must be freed by the caller. 618 * The buffer must be in write modus and may thus not have been flipped. 619 * The buffer is fixed after this function returns. 620 * 621 * \param[in] buffer buffer containing char * data 622 * \return null terminated char * data, or NULL on error 623 */ 624 char *ldns_buffer_export2str(ldns_buffer *buffer); 625 626 /** 627 * Prints the data in the rdata field to the given file stream 628 * (in presentation format) 629 * 630 * \param[in] output the file stream to print to 631 * \param[in] rdf the rdata field to print 632 * \return void 633 */ 634 void ldns_rdf_print(FILE *output, const ldns_rdf *rdf); 635 636 /** 637 * Prints the data in the resource record to the given file stream 638 * (in presentation format) 639 * 640 * \param[in] output the file stream to print to 641 * \param[in] rr the resource record to print 642 * \return void 643 */ 644 void ldns_rr_print(FILE *output, const ldns_rr *rr); 645 646 /** 647 * Prints the data in the resource record to the given file stream 648 * (in presentation format) 649 * 650 * \param[in] output the file stream to print to 651 * \param[in] fmt format of the textual representation 652 * \param[in] rr the resource record to print 653 * \return void 654 */ 655 void ldns_rr_print_fmt(FILE *output, 656 const ldns_output_format *fmt, const ldns_rr *rr); 657 658 /** 659 * Prints the data in the DNS packet to the given file stream 660 * (in presentation format) 661 * 662 * \param[in] output the file stream to print to 663 * \param[in] pkt the packet to print 664 * \return void 665 */ 666 void ldns_pkt_print(FILE *output, const ldns_pkt *pkt); 667 668 /** 669 * Prints the data in the DNS packet to the given file stream 670 * (in presentation format) 671 * 672 * \param[in] output the file stream to print to 673 * \param[in] fmt format of the textual representation 674 * \param[in] pkt the packet to print 675 * \return void 676 */ 677 void ldns_pkt_print_fmt(FILE *output, 678 const ldns_output_format *fmt, const ldns_pkt *pkt); 679 680 /** 681 * Converts a rr_list to presentation format and appends it to 682 * the output buffer 683 * \param[in] output the buffer to append output to 684 * \param[in] list the ldns_rr_list to print 685 * \return ldns_status 686 */ 687 ldns_status ldns_rr_list2buffer_str(ldns_buffer *output, const ldns_rr_list *list); 688 689 /** 690 * Converts a rr_list to presentation format and appends it to 691 * the output buffer 692 * \param[in] output the buffer to append output to 693 * \param[in] fmt format of the textual representation 694 * \param[in] list the ldns_rr_list to print 695 * \return ldns_status 696 */ 697 ldns_status ldns_rr_list2buffer_str_fmt(ldns_buffer *output, 698 const ldns_output_format *fmt, const ldns_rr_list *list); 699 700 /** 701 * Converts the header of a packet to presentation format and appends it to 702 * the output buffer 703 * \param[in] output the buffer to append output to 704 * \param[in] pkt the packet to convert the header of 705 * \return ldns_status 706 */ 707 ldns_status ldns_pktheader2buffer_str(ldns_buffer *output, const ldns_pkt *pkt); 708 709 /** 710 * print a rr_list to output 711 * \param[in] output the fd to print to 712 * \param[in] list the rr_list to print 713 */ 714 void ldns_rr_list_print(FILE *output, const ldns_rr_list *list); 715 716 /** 717 * print a rr_list to output 718 * \param[in] output the fd to print to 719 * \param[in] fmt format of the textual representation 720 * \param[in] list the rr_list to print 721 */ 722 void ldns_rr_list_print_fmt(FILE *output, 723 const ldns_output_format *fmt, const ldns_rr_list *list); 724 725 /** 726 * Print a resolver (in sofar that is possible) state 727 * to output. 728 * \param[in] output the fd to print to 729 * \param[in] r the resolver to print 730 */ 731 void ldns_resolver_print(FILE *output, const ldns_resolver *r); 732 733 /** 734 * Print a resolver (in sofar that is possible) state 735 * to output. 736 * \param[in] output the fd to print to 737 * \param[in] fmt format of the textual representation 738 * \param[in] r the resolver to print 739 */ 740 void ldns_resolver_print_fmt(FILE *output, 741 const ldns_output_format *fmt, const ldns_resolver *r); 742 743 /** 744 * Print a zone structure * to output. Note the SOA record 745 * is included in this output 746 * \param[in] output the fd to print to 747 * \param[in] z the zone to print 748 */ 749 void ldns_zone_print(FILE *output, const ldns_zone *z); 750 751 /** 752 * Print a zone structure * to output. Note the SOA record 753 * is included in this output 754 * \param[in] output the fd to print to 755 * \param[in] fmt format of the textual representation 756 * \param[in] z the zone to print 757 */ 758 void ldns_zone_print_fmt(FILE *output, 759 const ldns_output_format *fmt, const ldns_zone *z); 760 761 /** 762 * Print the ldns_rdf containing a dname to the buffer 763 * \param[in] output the buffer to print to 764 * \param[in] dname the dname to print 765 * \return ldns_status message if the printing succeeded 766 */ 767 ldns_status ldns_rdf2buffer_str_dname(ldns_buffer *output, const ldns_rdf *dname); 768 769 #ifdef __cplusplus 770 } 771 #endif 772 773 #endif /* LDNS_HOST2STR_H */ 774