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