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 #define LDNS_APL_IP4 1 34 #define LDNS_APL_IP6 2 35 #define LDNS_APL_MASK 0x7f 36 #define LDNS_APL_NEGATION 0x80 37 38 /** 39 * Converts an ldns packet opcode value to its mnemonic, and adds that 40 * to the output buffer 41 * \param[in] *output the buffer to add the data to 42 * \param[in] opcode to find the string representation of 43 * \return LDNS_STATUS_OK on success, or a buffer failure mode on error 44 */ 45 ldns_status 46 ldns_pkt_opcode2buffer_str(ldns_buffer *output, ldns_pkt_opcode opcode); 47 48 /** 49 * Converts an ldns packet rcode value to its mnemonic, and adds that 50 * to the output buffer 51 * \param[in] *output the buffer to add the data to 52 * \param[in] rcode to find the string representation of 53 * \return LDNS_STATUS_OK on success, or a buffer failure mode on error 54 */ 55 ldns_status 56 ldns_pkt_rcode2buffer_str(ldns_buffer *output, ldns_pkt_rcode rcode); 57 58 /** 59 * Converts an ldns algorithm type to its mnemonic, and adds that 60 * to the output buffer 61 * \param[in] *output the buffer to add the data to 62 * \param[in] algorithm to find the string representation of 63 * \return LDNS_STATUS_OK on success, or a buffer failure mode on error 64 */ 65 ldns_status 66 ldns_algorithm2buffer_str(ldns_buffer *output, 67 ldns_algorithm algorithm); 68 69 /** 70 * Converts an ldns certificate algorithm type to its mnemonic, 71 * and adds that to the output buffer 72 * \param[in] *output the buffer to add the data to 73 * \param[in] cert_algorithm to find the string representation of 74 * \return LDNS_STATUS_OK on success, or a buffer failure mode on error 75 */ 76 ldns_status 77 ldns_cert_algorithm2buffer_str(ldns_buffer *output, 78 ldns_cert_algorithm cert_algorithm); 79 80 81 /** 82 * Converts a packet opcode to its mnemonic and returns that as 83 * an allocated null-terminated string. 84 * Remember to free it. 85 * 86 * \param[in] opcode the opcode to convert to text 87 * \return null terminated char * data, or NULL on error 88 */ 89 char *ldns_pkt_opcode2str(ldns_pkt_opcode opcode); 90 91 /** 92 * Converts a packet rcode to its mnemonic and returns that as 93 * an allocated null-terminated string. 94 * Remember to free it. 95 * 96 * \param[in] rcode the rcode to convert to text 97 * \return null terminated char * data, or NULL on error 98 */ 99 char *ldns_pkt_rcode2str(ldns_pkt_rcode rcode); 100 101 /** 102 * Converts a signing algorithms to its mnemonic and returns that as 103 * an allocated null-terminated string. 104 * Remember to free it. 105 * 106 * \param[in] algorithm the algorithm to convert to text 107 * \return null terminated char * data, or NULL on error 108 */ 109 char *ldns_pkt_algorithm2str(ldns_algorithm algorithm); 110 111 /** 112 * Converts a cert algorithm to its mnemonic and returns that as 113 * an allocated null-terminated string. 114 * Remember to free it. 115 * 116 * \param[in] cert_algorithm to convert to text 117 * \return null terminated char * data, or NULL on error 118 */ 119 char *ldns_pkt_cert_algorithm2str(ldns_cert_algorithm cert_algorithm); 120 121 /** 122 * Converts an LDNS_RDF_TYPE_A rdata element to string format and adds it to the output buffer 123 * \param[in] *rdf The rdata to convert 124 * \param[in] *output The buffer to add the data to 125 * \return LDNS_STATUS_OK on success, and error status on failure 126 */ 127 ldns_status ldns_rdf2buffer_str_a(ldns_buffer *output, const ldns_rdf *rdf); 128 129 /** 130 * Converts an LDNS_RDF_TYPE_AAAA rdata element to string format and adds it to the output buffer 131 * \param[in] *rdf The rdata to convert 132 * \param[in] *output The buffer to add the data to 133 * \return LDNS_STATUS_OK on success, and error status on failure 134 */ 135 ldns_status ldns_rdf2buffer_str_aaaa(ldns_buffer *output, const ldns_rdf *rdf); 136 137 /** 138 * Converts an LDNS_RDF_TYPE_STR rdata element to string format and adds it to the output buffer 139 * \param[in] *rdf The rdata to convert 140 * \param[in] *output The buffer to add the data to 141 * \return LDNS_STATUS_OK on success, and error status on failure 142 */ 143 ldns_status ldns_rdf2buffer_str_str(ldns_buffer *output, const ldns_rdf *rdf); 144 145 /** 146 * Converts an LDNS_RDF_TYPE_B64 rdata element to string format and adds it to the output buffer 147 * \param[in] *rdf The rdata to convert 148 * \param[in] *output The buffer to add the data to 149 * \return LDNS_STATUS_OK on success, and error status on failure 150 */ 151 ldns_status ldns_rdf2buffer_str_b64(ldns_buffer *output, const ldns_rdf *rdf); 152 153 /** 154 * Converts an LDNS_RDF_TYPE_HEX rdata element to string format and adds it to the output buffer 155 * \param[in] *rdf The rdata to convert 156 * \param[in] *output The buffer to add the data to 157 * \return LDNS_STATUS_OK on success, and error status on failure 158 */ 159 ldns_status ldns_rdf2buffer_str_hex(ldns_buffer *output, const ldns_rdf *rdf); 160 161 /** 162 * Converts an LDNS_RDF_TYPE_TYPE rdata element to string format and adds it to the output buffer 163 * \param[in] *rdf The rdata to convert 164 * \param[in] *output The buffer to add the data to 165 * \return LDNS_STATUS_OK on success, and error status on failure 166 */ 167 ldns_status ldns_rdf2buffer_str_type(ldns_buffer *output, const ldns_rdf *rdf); 168 169 /** 170 * Converts an LDNS_RDF_TYPE_CLASS rdata element to string format and adds it to the output buffer 171 * \param[in] *rdf The rdata to convert 172 * \param[in] *output The buffer to add the data to 173 * \return LDNS_STATUS_OK on success, and error status on failure 174 */ 175 ldns_status ldns_rdf2buffer_str_class(ldns_buffer *output, const ldns_rdf *rdf); 176 177 /** 178 * Converts an LDNS_RDF_TYPE_ALG rdata element to string format and adds it to the output buffer 179 * \param[in] *rdf The rdata to convert 180 * \param[in] *output The buffer to add the data to 181 * \return LDNS_STATUS_OK on success, and error status on failure 182 */ 183 ldns_status ldns_rdf2buffer_str_alg(ldns_buffer *output, const ldns_rdf *rdf); 184 185 /** 186 * Converts an ldns_rr_type value to its string representation, 187 * and places it in the given buffer 188 * \param[in] *output The buffer to add the data to 189 * \param[in] type the ldns_rr_type to convert 190 * \return LDNS_STATUS_OK on success, and error status on failure 191 */ 192 ldns_status ldns_rr_type2buffer_str(ldns_buffer *output, 193 const ldns_rr_type type); 194 195 /** 196 * Converts an ldns_rr_type value to its string representation, 197 * and returns that string. For unknown types, the string 198 * "TYPE<id>" is returned. This function allocates data that must be 199 * freed by the caller 200 * \param[in] type the ldns_rr_type to convert 201 * \return a newly allocated string 202 */ 203 char *ldns_rr_type2str(const ldns_rr_type type); 204 205 /** 206 * Converts an ldns_rr_class value to its string representation, 207 * and places it in the given buffer 208 * \param[in] *output The buffer to add the data to 209 * \param[in] klass the ldns_rr_class to convert 210 * \return LDNS_STATUS_OK on success, and error status on failure 211 */ 212 ldns_status ldns_rr_class2buffer_str(ldns_buffer *output, 213 const ldns_rr_class klass); 214 215 /** 216 * Converts an ldns_rr_class value to its string representation, 217 * and returns that string. For unknown types, the string 218 * "CLASS<id>" is returned. This function allocates data that must be 219 * freed by the caller 220 * \param[in] klass the ldns_rr_class to convert 221 * \return a newly allocated string 222 */ 223 char *ldns_rr_class2str(const ldns_rr_class klass); 224 225 226 /** 227 * Converts an LDNS_RDF_TYPE_CERT rdata element to string format and adds it to the output buffer 228 * \param[in] *rdf The rdata to convert 229 * \param[in] *output The buffer to add the data to 230 * \return LDNS_STATUS_OK on success, and error status on failure 231 */ 232 ldns_status ldns_rdf2buffer_str_cert_alg(ldns_buffer *output, const ldns_rdf *rdf); 233 234 /** 235 * Converts an LDNS_RDF_TYPE_LOC rdata element to string format and adds it to the output buffer 236 * \param[in] *rdf The rdata to convert 237 * \param[in] *output The buffer to add the data to 238 * \return LDNS_STATUS_OK on success, and error status on failure 239 */ 240 ldns_status ldns_rdf2buffer_str_loc(ldns_buffer *output, const ldns_rdf *rdf); 241 242 /** 243 * Converts an LDNS_RDF_TYPE_UNKNOWN rdata element to string format and adds it to the output buffer 244 * \param[in] *rdf The rdata to convert 245 * \param[in] *output The buffer to add the data to 246 * \return LDNS_STATUS_OK on success, and error status on failure 247 */ 248 ldns_status ldns_rdf2buffer_str_unknown(ldns_buffer *output, const ldns_rdf *rdf); 249 250 /** 251 * Converts an LDNS_RDF_TYPE_NSAP rdata element to string format and adds it to the output buffer 252 * \param[in] *rdf The rdata to convert 253 * \param[in] *output The buffer to add the data to 254 * \return LDNS_STATUS_OK on success, and error status on failure 255 */ 256 ldns_status ldns_rdf2buffer_str_nsap(ldns_buffer *output, const ldns_rdf *rdf); 257 258 /** 259 * Converts an LDNS_RDF_TYPE_WKS rdata element to string format and adds it to the output buffer 260 * \param[in] *rdf The rdata to convert 261 * \param[in] *output The buffer to add the data to 262 * \return LDNS_STATUS_OK on success, and error status on failure 263 */ 264 ldns_status ldns_rdf2buffer_str_wks(ldns_buffer *output, const ldns_rdf *rdf); 265 266 /** 267 * Converts an LDNS_RDF_TYPE_NSEC rdata element to string format and adds it to the output buffer 268 * \param[in] *rdf The rdata to convert 269 * \param[in] *output The buffer to add the data to 270 * \return LDNS_STATUS_OK on success, and error status on failure 271 */ 272 ldns_status ldns_rdf2buffer_str_nsec(ldns_buffer *output, const ldns_rdf *rdf); 273 274 /** 275 * Converts an LDNS_RDF_TYPE_PERIOD rdata element to string format and adds it to the output buffer 276 * \param[in] *rdf The rdata to convert 277 * \param[in] *output The buffer to add the data to 278 * \return LDNS_STATUS_OK on success, and error status on failure 279 */ 280 ldns_status ldns_rdf2buffer_str_period(ldns_buffer *output, const ldns_rdf *rdf); 281 282 /** 283 * Converts an LDNS_RDF_TYPE_TSIGTIME rdata element to string format and adds it to the output buffer 284 * \param[in] *rdf The rdata to convert 285 * \param[in] *output The buffer to add the data to 286 * \return LDNS_STATUS_OK on success, and error status on failure 287 */ 288 ldns_status ldns_rdf2buffer_str_tsigtime(ldns_buffer *output, const ldns_rdf *rdf); 289 290 /** 291 * Converts an LDNS_RDF_TYPE_APL rdata element to string format and adds it to the output buffer 292 * \param[in] *rdf The rdata to convert 293 * \param[in] *output The buffer to add the data to 294 * \return LDNS_STATUS_OK on success, and error status on failure 295 */ 296 ldns_status ldns_rdf2buffer_str_apl(ldns_buffer *output, const ldns_rdf *rdf); 297 298 /** 299 * Converts an LDNS_RDF_TYPE_INT16_DATA rdata element to string format and adds it to the output buffer 300 * \param[in] *rdf The rdata to convert 301 * \param[in] *output The buffer to add the data to 302 * \return LDNS_STATUS_OK on success, and error status on failure 303 */ 304 ldns_status ldns_rdf2buffer_str_int16_data(ldns_buffer *output, const ldns_rdf *rdf); 305 306 /** 307 * Converts an LDNS_RDF_TYPE_IPSECKEY 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_ipseckey(ldns_buffer *output, const ldns_rdf *rdf); 313 314 /** 315 * Converts an LDNS_RDF_TYPE_TSIG 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_tsig(ldns_buffer *output, const ldns_rdf *rdf); 321 322 323 /** 324 * Converts the data in the rdata field to presentation 325 * format (as char *) and appends it to the given buffer 326 * 327 * \param[in] output pointer to the buffer to append the data to 328 * \param[in] rdf the pointer to the rdafa field containing the data 329 * \return status 330 */ 331 ldns_status ldns_rdf2buffer_str(ldns_buffer *output, const ldns_rdf *rdf); 332 333 /** 334 * Converts the data in the resource record to presentation 335 * format (as char *) and appends it to the given buffer 336 * 337 * \param[in] output pointer to the buffer to append the data to 338 * \param[in] rr the pointer to the rr field to convert 339 * \return status 340 */ 341 ldns_status ldns_rr2buffer_str(ldns_buffer *output, const ldns_rr *rr); 342 343 /** 344 * Converts the data in the DNS packet to presentation 345 * format (as char *) and appends it to the given buffer 346 * 347 * \param[in] output pointer to the buffer to append the data to 348 * \param[in] pkt the pointer to the packet to convert 349 * \return status 350 */ 351 ldns_status ldns_pkt2buffer_str(ldns_buffer *output, const ldns_pkt *pkt); 352 353 /** 354 * Converts the data in the DNS packet to presentation 355 * format (as char *) and appends it to the given buffer 356 * 357 * \param[in] output pointer to the buffer to append the data to 358 * \param[in] k the pointer to the private key to convert 359 * \return status 360 */ 361 ldns_status ldns_key2buffer_str(ldns_buffer *output, const ldns_key *k); 362 363 /** 364 * Converts the data in the int16 typed rdata field to presentation 365 * format (as char *) and appends it to the given buffer 366 * 367 * \param[in] output pointer to the buffer to append the data to 368 * \param[in] rdf the pointer to the rdafa field containing the data 369 * \return status 370 */ 371 ldns_status ldns_rdf2buffer_str_int16(ldns_buffer *output, const ldns_rdf *rdf); 372 373 /** 374 * Converts the data in the rdata field to presentation format and 375 * returns that as a char *. 376 * Remember to free it. 377 * 378 * \param[in] rdf The rdata field to convert 379 * \return null terminated char * data, or NULL on error 380 */ 381 char *ldns_rdf2str(const ldns_rdf *rdf); 382 383 /** 384 * Converts the data in the resource record to presentation format and 385 * returns that as a char *. 386 * Remember to free it. 387 * 388 * \param[in] rr The rdata field to convert 389 * \return null terminated char * data, or NULL on error 390 */ 391 char *ldns_rr2str(const ldns_rr *rr); 392 393 /** 394 * Converts the data in the DNS packet to presentation format and 395 * returns that as a char *. 396 * Remember to free it. 397 * 398 * \param[in] pkt The rdata field to convert 399 * \return null terminated char * data, or NULL on error 400 */ 401 char *ldns_pkt2str(const ldns_pkt *pkt); 402 403 /** 404 * Converts a private key to the test presentation fmt and 405 * returns that as a char *. 406 * Remember to free it. 407 * 408 * \param[in] k the key to convert to text 409 * \return null terminated char * data, or NULL on error 410 */ 411 char *ldns_key2str(const ldns_key *k); 412 413 /** 414 * Converts a list of resource records to presentation format 415 * and returns that as a char *. 416 * Remember to free it. 417 * 418 * \param[in] rr_list the rr_list to convert to text 419 * \return null terminated char * data, or NULL on error 420 */ 421 char *ldns_rr_list2str(const ldns_rr_list *rr_list); 422 423 /** 424 * Returns the data in the buffer as a null terminated char * string 425 * Buffer data must be char * type, and must be freed by the caller 426 * 427 * \param[in] buffer buffer containing char * data 428 * \return null terminated char * data, or NULL on error 429 */ 430 char *ldns_buffer2str(ldns_buffer *buffer); 431 432 /** 433 * Prints the data in the rdata field to the given file stream 434 * (in presentation format) 435 * 436 * \param[in] output the file stream to print to 437 * \param[in] rdf the rdata field to print 438 * \return void 439 */ 440 void ldns_rdf_print(FILE *output, const ldns_rdf *rdf); 441 442 /** 443 * Prints the data in the resource record to the given file stream 444 * (in presentation format) 445 * 446 * \param[in] output the file stream to print to 447 * \param[in] rr the resource record to print 448 * \return void 449 */ 450 void ldns_rr_print(FILE *output, const ldns_rr *rr); 451 452 /** 453 * Prints the data in the DNS packet to the given file stream 454 * (in presentation format) 455 * 456 * \param[in] output the file stream to print to 457 * \param[in] pkt the packet to print 458 * \return void 459 */ 460 void ldns_pkt_print(FILE *output, const ldns_pkt *pkt); 461 462 /** 463 * Converts a rr_list to presentation format and appends it to 464 * the output buffer 465 * \param[in] output the buffer to append output to 466 * \param[in] list the ldns_rr_list to print 467 * \return ldns_status 468 */ 469 ldns_status ldns_rr_list2buffer_str(ldns_buffer *output, const ldns_rr_list *list); 470 471 /** 472 * Converts the header of a packet to presentation format and appends it to 473 * the output buffer 474 * \param[in] output the buffer to append output to 475 * \param[in] pkt the packet to convert the header of 476 * \return ldns_status 477 */ 478 ldns_status ldns_pktheader2buffer_str(ldns_buffer *output, const ldns_pkt *pkt); 479 480 /** 481 * print a rr_list to output 482 * param[in] output the fd to print to 483 * param[in] list the rr_list to print 484 */ 485 void ldns_rr_list_print(FILE *output, const ldns_rr_list *list); 486 487 /** 488 * Print a resolver (in sofar that is possible) state 489 * to output. 490 * \param[in] output the fd to print to 491 * \param[in] r the resolver to print 492 */ 493 void ldns_resolver_print(FILE *output, const ldns_resolver *r); 494 495 /** 496 * Print a zone structure * to output. Note the SOA record 497 * is included in this output 498 * \param[in] output the fd to print to 499 * \param[in] z the zone to print 500 */ 501 void ldns_zone_print(FILE *output, const ldns_zone *z); 502 503 /** 504 * Print the ldns_rdf containing a dname to the buffer 505 * \param[in] output the buffer to print to 506 * \param[in] dname the dname to print 507 * \return ldns_status message if the printing succeeded 508 */ 509 ldns_status ldns_rdf2buffer_str_dname(ldns_buffer *output, const ldns_rdf *dname); 510 511 512 #endif /* LDNS_HOST2STR_H */ 513