ldns/drill: Update vendor branch to 1.6.9
[dragonfly.git] / contrib / ldns / ldns / rdata.h
CommitLineData
825eb42b
JL
1/*
2 * rdata.h
3 *
4 * rdata definitions
5 *
6 * a Net::DNS like library for C
7 *
8 * (c) NLnet Labs, 2005-2006
9 *
10 * See the file LICENSE for the license
11 */
12
13
14/**
15 * \file
16 *
17 * Defines ldns_rdf and functions to manipulate those.
18 */
19
20
21#ifndef LDNS_RDATA_H
22#define LDNS_RDATA_H
23
24#include <ldns/common.h>
25#include <ldns/error.h>
26
ac996e71
JL
27#ifdef __cplusplus
28extern "C" {
29#endif
30
825eb42b
JL
31#define LDNS_MAX_RDFLEN 8192
32
33#define LDNS_RDF_SIZE_BYTE 1
34#define LDNS_RDF_SIZE_WORD 2
35#define LDNS_RDF_SIZE_DOUBLEWORD 4
36#define LDNS_RDF_SIZE_6BYTES 6
37#define LDNS_RDF_SIZE_16BYTES 16
38
39#define LDNS_NSEC3_VARS_OPTOUT_MASK 0x01
40
41/**
42 * The different types of RDATA fields.
43 */
44enum ldns_enum_rdf_type
45{
46 /** none */
47 LDNS_RDF_TYPE_NONE,
48 /** domain name */
49 LDNS_RDF_TYPE_DNAME,
50 /** 8 bits */
51 LDNS_RDF_TYPE_INT8,
52 /** 16 bits */
53 LDNS_RDF_TYPE_INT16,
54 /** 32 bits */
55 LDNS_RDF_TYPE_INT32,
56 /** A record */
57 LDNS_RDF_TYPE_A,
58 /** AAAA record */
59 LDNS_RDF_TYPE_AAAA,
60 /** txt string */
61 LDNS_RDF_TYPE_STR,
62 /** apl data */
63 LDNS_RDF_TYPE_APL,
64 /** b32 string */
65 LDNS_RDF_TYPE_B32_EXT,
66 /** b64 string */
67 LDNS_RDF_TYPE_B64,
68 /** hex string */
69 LDNS_RDF_TYPE_HEX,
70 /** nsec type codes */
71 LDNS_RDF_TYPE_NSEC,
72 /** a RR type */
73 LDNS_RDF_TYPE_TYPE,
74 /** a class */
75 LDNS_RDF_TYPE_CLASS,
76 /** certificate algorithm */
77 LDNS_RDF_TYPE_CERT_ALG,
78 /** a key algorithm */
79 LDNS_RDF_TYPE_ALG,
80 /** unknown types */
81 LDNS_RDF_TYPE_UNKNOWN,
82 /** time (32 bits) */
83 LDNS_RDF_TYPE_TIME,
84 /** period */
85 LDNS_RDF_TYPE_PERIOD,
86 /** tsig time 48 bits */
87 LDNS_RDF_TYPE_TSIGTIME,
88 LDNS_RDF_TYPE_TSIG,
89 /** variable length any type rdata where the length
90 is specified by the first 2 bytes */
91 LDNS_RDF_TYPE_INT16_DATA,
92 /** protocol and port bitmaps */
93 LDNS_RDF_TYPE_SERVICE,
94 /** location data */
95 LDNS_RDF_TYPE_LOC,
96 /** well known services */
97 LDNS_RDF_TYPE_WKS,
98 /** NSAP */
99 LDNS_RDF_TYPE_NSAP,
100 /** ATMA */
101 LDNS_RDF_TYPE_ATMA,
102 /** IPSECKEY */
103 LDNS_RDF_TYPE_IPSECKEY,
104 /** nsec3 hash salt */
105 LDNS_RDF_TYPE_NSEC3_SALT,
106 /** nsec3 base32 string (with length byte on wire */
107 LDNS_RDF_TYPE_NSEC3_NEXT_OWNER
108};
109typedef enum ldns_enum_rdf_type ldns_rdf_type;
110
111/**
112 * algorithms used in CERT rrs
113 */
114enum ldns_enum_cert_algorithm
115{
fd185f4d
JL
116 LDNS_CERT_PKIX = 1,
117 LDNS_CERT_SPKI = 2,
118 LDNS_CERT_PGP = 3,
119 LDNS_CERT_IPKIX = 4,
120 LDNS_CERT_ISPKI = 5,
121 LDNS_CERT_IPGP = 6,
122 LDNS_CERT_ACPKIX = 7,
123 LDNS_CERT_IACPKIX = 8,
124 LDNS_CERT_URI = 253,
125 LDNS_CERT_OID = 254
825eb42b
JL
126};
127typedef enum ldns_enum_cert_algorithm ldns_cert_algorithm;
128
129
130
131/**
132 * Resource record data field.
133 *
134 * The data is a network ordered array of bytes, which size is specified by
135 * the (16-bit) size field. To correctly parse it, use the type
136 * specified in the (16-bit) type field with a value from \ref ldns_rdf_type.
137 */
138struct ldns_struct_rdf
139{
140 /** The size of the data (in octets) */
141 size_t _size;
142 /** The type of the data */
143 ldns_rdf_type _type;
144 /** Pointer to the data (raw octets) */
145 void *_data;
146};
147typedef struct ldns_struct_rdf ldns_rdf;
148
149/* prototypes */
150
151/* write access functions */
152
153/**
154 * sets the size of the rdf.
155 * \param[in] *rd the rdf to operate on
156 * \param[in] size the new size
157 * \return void
158 */
159void ldns_rdf_set_size(ldns_rdf *rd, size_t size);
160
161/**
162 * sets the size of the rdf.
163 * \param[in] *rd the rdf to operate on
164 * \param[in] type the new type
165 * \return void
166 */
167void ldns_rdf_set_type(ldns_rdf *rd, ldns_rdf_type type);
168
169/**
170 * sets the size of the rdf.
171 * \param[in] *rd the rdf to operate on
172 * \param[in] *data pointer to the new data
173 * \return void
174 */
175void ldns_rdf_set_data(ldns_rdf *rd, void *data);
176
177/* read access */
178
179/**
180 * returns the size of the rdf.
181 * \param[in] *rd the rdf to read from
182 * \return uint16_t with the size
183 */
184size_t ldns_rdf_size(const ldns_rdf *rd);
185
186/**
187 * returns the type of the rdf. We need to insert _get_
188 * here to prevent conflict the the rdf_type TYPE.
189 * \param[in] *rd the rdf to read from
190 * \return ldns_rdf_type with the type
191 */
192ldns_rdf_type ldns_rdf_get_type(const ldns_rdf *rd);
193
194/**
195 * returns the data of the rdf.
196 * \param[in] *rd the rdf to read from
197 * \return uint8_t* pointer to the rdf's data
198 */
199uint8_t *ldns_rdf_data(const ldns_rdf *rd);
200
201/* creator functions */
202
203/**
204 * allocates a new rdf structure and fills it.
205 * This function DOES NOT copy the contents from
206 * the buffer, unlinke ldns_rdf_new_frm_data()
207 * \param[in] type type of the rdf
208 * \param[in] size size of the buffer
209 * \param[in] data pointer to the buffer to be copied
210 * \return the new rdf structure or NULL on failure
211 */
212ldns_rdf *ldns_rdf_new(ldns_rdf_type type, size_t size, void *data);
213
214/**
215 * allocates a new rdf structure and fills it.
216 * This function _does_ copy the contents from
217 * the buffer, unlinke ldns_rdf_new()
218 * \param[in] type type of the rdf
219 * \param[in] size size of the buffer
220 * \param[in] data pointer to the buffer to be copied
221 * \return the new rdf structure or NULL on failure
222 */
223ldns_rdf *ldns_rdf_new_frm_data(ldns_rdf_type type, size_t size, const void *data);
224
225/**
226 * creates a new rdf from a string.
227 * \param[in] type type to use
228 * \param[in] str string to use
229 * \return ldns_rdf* or NULL in case of an error
230 */
231ldns_rdf *ldns_rdf_new_frm_str(ldns_rdf_type type, const char *str);
232
233/**
234 * creates a new rdf from a file containing a string.
235 * \param[out] r the new rdf
236 * \param[in] type type to use
237 * \param[in] fp the file pointer to use
238 * \return LDNS_STATUS_OK or the error
239 */
240ldns_status ldns_rdf_new_frm_fp(ldns_rdf **r, ldns_rdf_type type, FILE *fp);
241
242/**
243 * creates a new rdf from a file containing a string.
244 * \param[out] r the new rdf
245 * \param[in] type type to use
246 * \param[in] fp the file pointer to use
247 * \param[in] line_nr pointer to an integer containing the current line number (for debugging purposes)
248 * \return LDNS_STATUS_OK or the error
249 */
250ldns_status ldns_rdf_new_frm_fp_l(ldns_rdf **r, ldns_rdf_type type, FILE *fp, int *line_nr);
251
252/* destroy functions */
253
254/**
255 * frees a rdf structure, leaving the
256 * data pointer intact.
257 * \param[in] rd the pointer to be freed
258 * \return void
259 */
260void ldns_rdf_free(ldns_rdf *rd);
261
262/**
263 * frees a rdf structure _and_ frees the
264 * data. rdf should be created with _new_frm_data
265 * \param[in] rd the rdf structure to be freed
266 * \return void
267 */
268void ldns_rdf_deep_free(ldns_rdf *rd);
269
270/* conversion functions */
271
272/**
273 * returns the rdf containing the native uint8_t repr.
274 * \param[in] type the ldns_rdf type to use
275 * \param[in] value the uint8_t to use
276 * \return ldns_rdf* with the converted value
277 */
278ldns_rdf *ldns_native2rdf_int8(ldns_rdf_type type, uint8_t value);
279
280/**
281 * returns the rdf containing the native uint16_t representation.
282 * \param[in] type the ldns_rdf type to use
283 * \param[in] value the uint16_t to use
284 * \return ldns_rdf* with the converted value
285 */
286ldns_rdf *ldns_native2rdf_int16(ldns_rdf_type type, uint16_t value);
287
288/**
289 * returns an rdf that contains the given int32 value.
290 *
291 * Because multiple rdf types can contain an int32, the
292 * type must be specified
293 * \param[in] type the ldns_rdf type to use
294 * \param[in] value the uint32_t to use
295 * \return ldns_rdf* with the converted value
296 */
297ldns_rdf *ldns_native2rdf_int32(ldns_rdf_type type, uint32_t value);
298
299/**
300 * returns an int16_data rdf that contains the data in the
301 * given array, preceded by an int16 specifying the length.
302 *
303 * The memory is copied, and an LDNS_RDF_TYPE_INT16DATA is returned
304 * \param[in] size the size of the data
305 * \param[in] *data pointer to the actual data
306 * \return ldns_rd* the rdf with the data
307 */
308ldns_rdf *ldns_native2rdf_int16_data(size_t size, uint8_t *data);
309
310/**
311 * reverses an rdf, only actually useful for AAAA and A records.
312 * The returned rdf has the type LDNS_RDF_TYPE_DNAME!
313 * \param[in] *rd rdf to be reversed
314 * \return the reversed rdf (a newly created rdf)
315 */
316ldns_rdf *ldns_rdf_address_reverse(ldns_rdf *rd);
317
318/**
319 * returns the native uint8_t representation from the rdf.
320 * \param[in] rd the ldns_rdf to operate on
321 * \return uint8_t the value extracted
322 */
323uint8_t ldns_rdf2native_int8(const ldns_rdf *rd);
324
325/**
326 * returns the native uint16_t representation from the rdf.
327 * \param[in] rd the ldns_rdf to operate on
328 * \return uint16_t the value extracted
329 */
330uint16_t ldns_rdf2native_int16(const ldns_rdf *rd);
331
332/**
333 * returns the native uint32_t representation from the rdf.
334 * \param[in] rd the ldns_rdf to operate on
335 * \return uint32_t the value extracted
336 */
337uint32_t ldns_rdf2native_int32(const ldns_rdf *rd);
338
339/**
340 * returns the native time_t representation from the rdf.
341 * \param[in] rd the ldns_rdf to operate on
342 * \return time_t the value extracted (32 bits currently)
343 */
344time_t ldns_rdf2native_time_t(const ldns_rdf *rd);
345
346/**
347 * converts a ttl value (like 5d2h) to a long.
348 * \param[in] nptr the start of the string
349 * \param[out] endptr points to the last char in case of error
350 * \return the convert duration value
351 */
352uint32_t ldns_str2period(const char *nptr, const char **endptr);
353
354/**
355 * removes \\DDD, \\[space] and other escapes from the input.
356 * See RFC 1035, section 5.1.
357 * \param[in] word what to check
358 * \param[in] length the string
359 * \return ldns_status mesg
360 */
361ldns_status ldns_octet(char *word, size_t *length);
362
363/**
364 * clones a rdf structure. The data is copied.
365 * \param[in] rd rdf to be copied
366 * \return a new rdf structure
367 */
368ldns_rdf *ldns_rdf_clone(const ldns_rdf *rd);
369
370/**
371 * compares two rdf's on their wire formats.
372 * (To order dnames according to rfc4034, use ldns_dname_compare)
373 * \param[in] rd1 the first one
374 * \param[in] rd2 the second one
375 * \return 0 if equal
376 * \return -1 if rd1 comes before rd2
377 * \return +1 if rd2 comes before rd1
378 */
379int ldns_rdf_compare(const ldns_rdf *rd1, const ldns_rdf *rd2);
380
ac996e71
JL
381#ifdef __cplusplus
382}
383#endif
384
825eb42b 385#endif /* LDNS_RDATA_H */