contrib/ldns/ldns/host2str.h

   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  * Converts an ldns packet opcode value to its mnemonic, and adds that
  44  * to the output buffer
  45  * \param[in] *output the buffer to add the data to
  46  * \param[in] opcode to find the string representation of
  47  * \return LDNS_STATUS_OK on success, or a buffer failure mode on error
  48  */
  49 ldns_status
  50 ldns_pkt_opcode2buffer_str(ldns_buffer *output, ldns_pkt_opcode opcode);
  51
  52 /**
  53  * Converts an ldns packet rcode value to its mnemonic, and adds that
  54  * to the output buffer
  55  * \param[in] *output the buffer to add the data to
  56  * \param[in] rcode to find the string representation of
  57  * \return LDNS_STATUS_OK on success, or a buffer failure mode on error
  58  */
  59 ldns_status
  60 ldns_pkt_rcode2buffer_str(ldns_buffer *output, ldns_pkt_rcode rcode);
  61
  62 /**
  63  * Converts an ldns algorithm type to its mnemonic, and adds that
  64  * to the output buffer
  65  * \param[in] *output the buffer to add the data to
  66  * \param[in] algorithm to find the string representation of
  67  * \return LDNS_STATUS_OK on success, or a buffer failure mode on error
  68  */
  69 ldns_status
  70 ldns_algorithm2buffer_str(ldns_buffer *output,
  71                           ldns_algorithm algorithm);
  72
  73 /**
  74  * Converts an ldns certificate algorithm type to its mnemonic,
  75  * and adds that to the output buffer
  76  * \param[in] *output the buffer to add the data to
  77  * \param[in] cert_algorithm to find the string representation of
  78  * \return LDNS_STATUS_OK on success, or a buffer failure mode on error
  79  */
  80 ldns_status
  81 ldns_cert_algorithm2buffer_str(ldns_buffer *output,
  82                                ldns_cert_algorithm cert_algorithm);
  83
  84
  85 /**
  86  * Converts a packet opcode to its mnemonic and returns that as
  87  * an allocated null-terminated string.
  88  * Remember to free it.
  89  *
  90  * \param[in] opcode the opcode to convert to text
  91  * \return null terminated char * data, or NULL on error
  92  */
  93 char *ldns_pkt_opcode2str(ldns_pkt_opcode opcode);
  94
  95 /**
  96  * Converts a packet rcode to its mnemonic and returns that as
  97  * an allocated null-terminated string.
  98  * Remember to free it.
  99  *
 100  * \param[in] rcode the rcode to convert to text
 101  * \return null terminated char * data, or NULL on error
 102  */
 103 char *ldns_pkt_rcode2str(ldns_pkt_rcode rcode);
 104
 105 /**
 106  * Converts a signing algorithms to its mnemonic and returns that as
 107  * an allocated null-terminated string.
 108  * Remember to free it.
 109  *
 110  * \param[in] algorithm the algorithm to convert to text
 111  * \return null terminated char * data, or NULL on error
 112  */
 113 char *ldns_pkt_algorithm2str(ldns_algorithm algorithm);
 114
 115 /**
 116  * Converts a cert algorithm to its mnemonic and returns that as
 117  * an allocated null-terminated string.
 118  * Remember to free it.
 119  *
 120  * \param[in] cert_algorithm to convert to text
 121  * \return null terminated char * data, or NULL on error
 122  */
 123 char *ldns_pkt_cert_algorithm2str(ldns_cert_algorithm cert_algorithm);
 124
 125 /**
 126  * Converts an LDNS_RDF_TYPE_A rdata element to string format and adds it to the output buffer
 127  * \param[in] *rdf The rdata to convert
 128  * \param[in] *output The buffer to add the data to
 129  * \return LDNS_STATUS_OK on success, and error status on failure
 130  */
 131 ldns_status ldns_rdf2buffer_str_a(ldns_buffer *output, const ldns_rdf *rdf);
 132
 133 /**
 134  * Converts an LDNS_RDF_TYPE_AAAA rdata element to string format and adds it to the output buffer
 135  * \param[in] *rdf The rdata to convert
 136  * \param[in] *output The buffer to add the data to
 137  * \return LDNS_STATUS_OK on success, and error status on failure
 138  */
 139 ldns_status ldns_rdf2buffer_str_aaaa(ldns_buffer *output, const ldns_rdf *rdf);
 140
 141 /**
 142  * Converts an LDNS_RDF_TYPE_STR rdata element to string format and adds it to the output buffer
 143  * \param[in] *rdf The rdata to convert
 144  * \param[in] *output The buffer to add the data to
 145  * \return LDNS_STATUS_OK on success, and error status on failure
 146  */
 147 ldns_status ldns_rdf2buffer_str_str(ldns_buffer *output, const ldns_rdf *rdf);
 148
 149 /**
 150  * Converts an LDNS_RDF_TYPE_B64 rdata element to string format and adds it to the output buffer
 151  * \param[in] *rdf The rdata to convert
 152  * \param[in] *output The buffer to add the data to
 153  * \return LDNS_STATUS_OK on success, and error status on failure
 154  */
 155 ldns_status ldns_rdf2buffer_str_b64(ldns_buffer *output, const ldns_rdf *rdf);
 156
 157 /**
 158  * Converts an LDNS_RDF_TYPE_B32_EXT rdata element to string format and adds it to the output buffer
 159  * \param[in] *rdf The rdata to convert
 160  * \param[in] *output The buffer to add the data to
 161  * \return LDNS_STATUS_OK on success, and error status on failure
 162  */
 163 ldns_status ldns_rdf2buffer_str_b32_ext(ldns_buffer *output, const ldns_rdf *rdf);
 164
 165 /**
 166  * Converts an LDNS_RDF_TYPE_HEX rdata element to string format and adds it to the output buffer
 167  * \param[in] *rdf The rdata to convert
 168  * \param[in] *output The buffer to add the data to
 169  * \return LDNS_STATUS_OK on success, and error status on failure
 170  */
 171 ldns_status ldns_rdf2buffer_str_hex(ldns_buffer *output, const ldns_rdf *rdf);
 172
 173 /**
 174  * Converts an LDNS_RDF_TYPE_TYPE rdata element to string format and adds it to the output buffer
 175  * \param[in] *rdf The rdata to convert
 176  * \param[in] *output The buffer to add the data to
 177  * \return LDNS_STATUS_OK on success, and error status on failure
 178  */
 179 ldns_status ldns_rdf2buffer_str_type(ldns_buffer *output, const ldns_rdf *rdf);
 180
 181 /**
 182  * Converts an LDNS_RDF_TYPE_CLASS rdata element to string format and adds it to the output buffer
 183  * \param[in] *rdf The rdata to convert
 184  * \param[in] *output The buffer to add the data to
 185  * \return LDNS_STATUS_OK on success, and error status on failure
 186  */
 187 ldns_status ldns_rdf2buffer_str_class(ldns_buffer *output, const ldns_rdf *rdf);
 188
 189 /**
 190  * Converts an LDNS_RDF_TYPE_ALG rdata element to string format and adds it to the output buffer
 191  * \param[in] *rdf The rdata to convert
 192  * \param[in] *output The buffer to add the data to
 193  * \return LDNS_STATUS_OK on success, and error status on failure
 194  */
 195 ldns_status ldns_rdf2buffer_str_alg(ldns_buffer *output, const ldns_rdf *rdf);
 196
 197 /**
 198  * Converts an ldns_rr_type value to its string representation,
 199  * and places it in the given buffer
 200  * \param[in] *output The buffer to add the data to
 201  * \param[in] type the ldns_rr_type to convert
 202  * \return LDNS_STATUS_OK on success, and error status on failure
 203  */
 204 ldns_status ldns_rr_type2buffer_str(ldns_buffer *output,
 205                                     const ldns_rr_type type);
 206
 207 /**
 208  * Converts an ldns_rr_type value to its string representation,
 209  * and returns that string. For unknown types, the string
 210  * "TYPE<id>" is returned. This function allocates data that must be
 211  * freed by the caller
 212  * \param[in] type the ldns_rr_type to convert
 213  * \return a newly allocated string
 214  */
 215 char *ldns_rr_type2str(const ldns_rr_type type);
 216
 217 /**
 218  * Converts an ldns_rr_class value to its string representation,
 219  * and places it in the given buffer
 220  * \param[in] *output The buffer to add the data to
 221  * \param[in] klass the ldns_rr_class to convert
 222  * \return LDNS_STATUS_OK on success, and error status on failure
 223  */
 224 ldns_status ldns_rr_class2buffer_str(ldns_buffer *output,
 225                                      const ldns_rr_class klass);
 226
 227 /**
 228  * Converts an ldns_rr_class value to its string representation,
 229  * and returns that string. For unknown types, the string
 230  * "CLASS<id>" is returned. This function allocates data that must be
 231  * freed by the caller
 232  * \param[in] klass the ldns_rr_class to convert
 233  * \return a newly allocated string
 234  */
 235 char *ldns_rr_class2str(const ldns_rr_class klass);
 236
 237
 238 /**
 239  * Converts an LDNS_RDF_TYPE_CERT rdata element to string format and adds it to the output buffer
 240  * \param[in] *rdf The rdata to convert
 241  * \param[in] *output The buffer to add the data to
 242  * \return LDNS_STATUS_OK on success, and error status on failure
 243  */
 244 ldns_status ldns_rdf2buffer_str_cert_alg(ldns_buffer *output, const ldns_rdf *rdf);
 245
 246 /**
 247  * Converts an LDNS_RDF_TYPE_LOC rdata element to string format and adds it to the output buffer
 248  * \param[in] *rdf The rdata to convert
 249  * \param[in] *output The buffer to add the data to
 250  * \return LDNS_STATUS_OK on success, and error status on failure
 251  */
 252 ldns_status ldns_rdf2buffer_str_loc(ldns_buffer *output, const ldns_rdf *rdf);
 253
 254 /**
 255  * Converts an LDNS_RDF_TYPE_UNKNOWN rdata element to string format and adds it to the output buffer
 256  * \param[in] *rdf The rdata to convert
 257  * \param[in] *output The buffer to add the data to
 258  * \return LDNS_STATUS_OK on success, and error status on failure
 259  */
 260 ldns_status ldns_rdf2buffer_str_unknown(ldns_buffer *output, const ldns_rdf *rdf);
 261
 262 /**
 263  * Converts an LDNS_RDF_TYPE_NSAP 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_nsap(ldns_buffer *output, const ldns_rdf *rdf);
 269
 270 /**
 271  * Converts an LDNS_RDF_TYPE_ATMA 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_atma(ldns_buffer *output, const ldns_rdf *rdf);
 277
 278 /**
 279  * Converts an LDNS_RDF_TYPE_WKS 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_wks(ldns_buffer *output, const ldns_rdf *rdf);
 285
 286 /**
 287  * Converts an LDNS_RDF_TYPE_NSEC 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_nsec(ldns_buffer *output, const ldns_rdf *rdf);
 293
 294 /**
 295  * Converts an LDNS_RDF_TYPE_PERIOD 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_period(ldns_buffer *output, const ldns_rdf *rdf);
 301
 302 /**
 303  * Converts an LDNS_RDF_TYPE_TSIGTIME 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_tsigtime(ldns_buffer *output, const ldns_rdf *rdf);
 309
 310 /**
 311  * Converts an LDNS_RDF_TYPE_APL 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_apl(ldns_buffer *output, const ldns_rdf *rdf);
 317
 318 /**
 319  * Converts an LDNS_RDF_TYPE_INT16_DATA 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_int16_data(ldns_buffer *output, const ldns_rdf *rdf);
 325
 326 /**
 327  * Converts an LDNS_RDF_TYPE_IPSECKEY 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_ipseckey(ldns_buffer *output, const ldns_rdf *rdf);
 333
 334 /**
 335  * Converts an LDNS_RDF_TYPE_TSIG rdata element to string format and adds it to the output buffer
 336  * \param[in] *rdf The rdata to convert
 337  * \param[in] *output The buffer to add the data to
 338  * \return LDNS_STATUS_OK on success, and error status on failure
 339  */
 340 ldns_status ldns_rdf2buffer_str_tsig(ldns_buffer *output, const ldns_rdf *rdf);
 341
 342
 343 /**
 344  * Converts the data in the rdata field 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] rdf the pointer to the rdafa field containing the data
 349  * \return status
 350  */
 351 ldns_status ldns_rdf2buffer_str(ldns_buffer *output, const ldns_rdf *rdf);
 352
 353 /**
 354  * Converts the data in the resource record 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] rr the pointer to the rr field to convert
 359  * \return status
 360  */
 361 ldns_status ldns_rr2buffer_str(ldns_buffer *output, const ldns_rr *rr);
 362
 363 /**
 364  * Converts the data in the DNS packet 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] pkt the pointer to the packet to convert
 369  * \return status
 370  */
 371 ldns_status ldns_pkt2buffer_str(ldns_buffer *output, const ldns_pkt *pkt);
 372
 373 /**
 374  * Converts an LDNS_RDF_TYPE_NSEC3_SALT rdata element to string format and adds it to the output buffer
 375  * \param[in] *rdf The rdata to convert
 376  * \param[in] *output The buffer to add the data to
 377  * \return LDNS_STATUS_OK on success, and error status on failure
 378  */
 379 ldns_status ldns_rdf2buffer_str_nsec3_salt(ldns_buffer *output, const ldns_rdf *rdf);
 380
 381
 382 /**
 383  * Converts the data in the DNS packet to presentation
 384  * format (as char *) and appends it to the given buffer
 385  *
 386  * \param[in] output pointer to the buffer to append the data to
 387  * \param[in] k the pointer to the private key to convert
 388  * \return status
 389  */
 390 ldns_status ldns_key2buffer_str(ldns_buffer *output, const ldns_key *k);
 391
 392 /**
 393  * Converts an LDNS_RDF_TYPE_INT8 rdata element to string format and adds it to the output buffer
 394  * \param[in] *rdf The rdata to convert
 395  * \param[in] *output The buffer to add the data to
 396  * \return LDNS_STATUS_OK on success, and error status on failure
 397  */
 398 ldns_status ldns_rdf2buffer_str_int8(ldns_buffer *output, const ldns_rdf *rdf);
 399
 400 /**
 401  * Converts an LDNS_RDF_TYPE_INT16 rdata element to string format and adds it to the output buffer
 402  * \param[in] *rdf The rdata to convert
 403  * \param[in] *output The buffer to add the data to
 404  * \return LDNS_STATUS_OK on success, and error status on failure
 405  */
 406 ldns_status ldns_rdf2buffer_str_int16(ldns_buffer *output, const ldns_rdf *rdf);
 407
 408 /**
 409  * Converts an LDNS_RDF_TYPE_INT32 rdata element to string format and adds it to the output buffer
 410  * \param[in] *rdf The rdata to convert
 411  * \param[in] *output The buffer to add the data to
 412  * \return LDNS_STATUS_OK on success, and error status on failure
 413  */
 414 ldns_status ldns_rdf2buffer_str_int32(ldns_buffer *output, const ldns_rdf *rdf);
 415
 416 /**
 417  * Converts an LDNS_RDF_TYPE_TIME rdata element to string format and adds it to the output buffer
 418  * \param[in] *rdf The rdata to convert
 419  * \param[in] *output The buffer to add the data to
 420  * \return LDNS_STATUS_OK on success, and error status on failure
 421  */
 422 ldns_status ldns_rdf2buffer_str_time(ldns_buffer *output, const ldns_rdf *rdf);
 423
 424 /**
 425  * Converts the data in the rdata field to presentation format and
 426  * returns that as a char *.
 427  * Remember to free it.
 428  *
 429  * \param[in] rdf The rdata field to convert
 430  * \return null terminated char * data, or NULL on error
 431  */
 432 char *ldns_rdf2str(const ldns_rdf *rdf);
 433
 434 /**
 435  * Converts the data in the resource record to presentation format and
 436  * returns that as a char *.
 437  * Remember to free it.
 438  *
 439  * \param[in] rr The rdata field to convert
 440  * \return null terminated char * data, or NULL on error
 441  */
 442 char *ldns_rr2str(const ldns_rr *rr);
 443
 444 /**
 445  * Converts the data in the DNS packet to presentation format and
 446  * returns that as a char *.
 447  * Remember to free it.
 448  *
 449  * \param[in] pkt The rdata field to convert
 450  * \return null terminated char * data, or NULL on error
 451  */
 452 char *ldns_pkt2str(const ldns_pkt *pkt);
 453
 454 /**
 455  * Converts a private key to the test presentation fmt and
 456  * returns that as a char *.
 457  * Remember to free it.
 458  *
 459  * \param[in] k the key to convert to text
 460  * \return null terminated char * data, or NULL on error
 461  */
 462 char *ldns_key2str(const ldns_key *k);
 463
 464 /**
 465  * Converts a list of resource records to presentation format
 466  * and returns that as a char *.
 467  * Remember to free it.
 468  *
 469  * \param[in] rr_list the rr_list to convert to text
 470  * \return null terminated char * data, or NULL on error
 471  */
 472 char *ldns_rr_list2str(const ldns_rr_list *rr_list);
 473
 474 /**
 475  * Returns the data in the buffer as a null terminated char * string
 476  * Buffer data must be char * type, and must be freed by the caller
 477  *
 478  * \param[in] buffer buffer containing char * data
 479  * \return null terminated char * data, or NULL on error
 480  */
 481 char *ldns_buffer2str(ldns_buffer *buffer);
 482
 483 /**
 484  * Prints the data in the rdata field to the given file stream
 485  * (in presentation format)
 486  *
 487  * \param[in] output the file stream to print to
 488  * \param[in] rdf the rdata field to print
 489  * \return void
 490  */
 491 void ldns_rdf_print(FILE *output, const ldns_rdf *rdf);
 492
 493 /**
 494  * Prints the data in the resource record to the given file stream
 495  * (in presentation format)
 496  *
 497  * \param[in] output the file stream to print to
 498  * \param[in] rr the resource record to print
 499  * \return void
 500  */
 501 void ldns_rr_print(FILE *output, const ldns_rr *rr);
 502
 503 /**
 504  * Prints the data in the DNS packet to the given file stream
 505  * (in presentation format)
 506  *
 507  * \param[in] output the file stream to print to
 508  * \param[in] pkt the packet to print
 509  * \return void
 510  */
 511 void ldns_pkt_print(FILE *output, const ldns_pkt *pkt);
 512
 513 /**
 514  * Converts a rr_list to presentation format and appends it to
 515  * the output buffer
 516  * \param[in] output the buffer to append output to
 517  * \param[in] list the ldns_rr_list to print
 518  * \return ldns_status
 519  */
 520 ldns_status ldns_rr_list2buffer_str(ldns_buffer *output, const ldns_rr_list *list);
 521
 522 /**
 523  * Converts the header of a packet to presentation format and appends it to
 524  * the output buffer
 525  * \param[in] output the buffer to append output to
 526  * \param[in] pkt the packet to convert the header of
 527  * \return ldns_status
 528  */
 529 ldns_status ldns_pktheader2buffer_str(ldns_buffer *output, const ldns_pkt *pkt);
 530
 531 /**
 532  * print a rr_list to output
 533  * param[in] output the fd to print to
 534  * param[in] list the rr_list to print
 535  */
 536 void ldns_rr_list_print(FILE *output, const ldns_rr_list *list);
 537
 538 /**
 539  * Print a resolver (in sofar that is possible) state
 540  * to output.
 541  * \param[in] output the fd to print to
 542  * \param[in] r the resolver to print
 543  */
 544 void ldns_resolver_print(FILE *output, const ldns_resolver *r);
 545
 546 /**
 547  * Print a zone structure * to output. Note the SOA record
 548  * is included in this output
 549  * \param[in] output the fd to print to
 550  * \param[in] z the zone to print
 551  */
 552 void ldns_zone_print(FILE *output, const ldns_zone *z);
 553
 554 /**
 555  * Print the ldns_rdf containing a dname to the buffer
 556  * \param[in] output the buffer to print to
 557  * \param[in] dname the dname to print
 558  * \return ldns_status message if the printing succeeded
 559  */
 560 ldns_status ldns_rdf2buffer_str_dname(ldns_buffer *output, const ldns_rdf *dname);
 561
 562 #ifdef __cplusplus
 563 }
 564 #endif
 565
 566 #endif /* LDNS_HOST2STR_H */