Initial vendor import of ldns-1.6.4 into contrib.
[dragonfly.git] / contrib / ldns / ldns / host2str.h
CommitLineData
825eb42b
JL
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 */
45ldns_status
46ldns_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 */
55ldns_status
56ldns_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 */
65ldns_status
66ldns_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 */
76ldns_status
77ldns_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 */
89char *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 */
99char *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 */
109char *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 */
119char *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 */
127ldns_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 */
135ldns_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 */
143ldns_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 */
151ldns_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 */
159ldns_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 */
167ldns_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 */
175ldns_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 */
183ldns_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 */
192ldns_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 */
203char *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 */
212ldns_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 */
223char *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 */
232ldns_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 */
240ldns_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 */
248ldns_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 */
256ldns_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 */
264ldns_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 */
272ldns_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 */
280ldns_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 */
288ldns_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 */
296ldns_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 */
304ldns_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 */
312ldns_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 */
320ldns_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 */
331ldns_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 */
341ldns_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 */
351ldns_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 */
361ldns_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 */
371ldns_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 */
381char *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 */
391char *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 */
401char *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 */
411char *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 */
421char *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 */
430char *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 */
440void 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 */
450void 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 */
460void 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 */
469ldns_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 */
478ldns_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 */
485void 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 */
493void 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 */
501void 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 */
509ldns_status ldns_rdf2buffer_str_dname(ldns_buffer *output, const ldns_rdf *dname);
510
511
512#endif /* LDNS_HOST2STR_H */