Commit | Line | Data |
---|---|---|
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 |
28 | extern "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 | */ | |
44 | enum 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 | }; | |
109 | typedef enum ldns_enum_rdf_type ldns_rdf_type; | |
110 | ||
111 | /** | |
112 | * algorithms used in CERT rrs | |
113 | */ | |
114 | enum 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 | }; |
127 | typedef 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 | */ | |
138 | struct 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 | }; | |
147 | typedef 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 | */ | |
159 | void 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 | */ | |
167 | void 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 | */ | |
175 | void 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 | */ | |
184 | size_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 | */ | |
192 | ldns_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 | |
d1b2b5ca | 197 | * |
825eb42b JL |
198 | * \return uint8_t* pointer to the rdf's data |
199 | */ | |
200 | uint8_t *ldns_rdf_data(const ldns_rdf *rd); | |
201 | ||
202 | /* creator functions */ | |
203 | ||
204 | /** | |
205 | * allocates a new rdf structure and fills it. | |
206 | * This function DOES NOT copy the contents from | |
207 | * the buffer, unlinke ldns_rdf_new_frm_data() | |
208 | * \param[in] type type of the rdf | |
209 | * \param[in] size size of the buffer | |
210 | * \param[in] data pointer to the buffer to be copied | |
211 | * \return the new rdf structure or NULL on failure | |
212 | */ | |
213 | ldns_rdf *ldns_rdf_new(ldns_rdf_type type, size_t size, void *data); | |
214 | ||
215 | /** | |
216 | * allocates a new rdf structure and fills it. | |
217 | * This function _does_ copy the contents from | |
218 | * the buffer, unlinke ldns_rdf_new() | |
219 | * \param[in] type type of the rdf | |
220 | * \param[in] size size of the buffer | |
221 | * \param[in] data pointer to the buffer to be copied | |
222 | * \return the new rdf structure or NULL on failure | |
223 | */ | |
224 | ldns_rdf *ldns_rdf_new_frm_data(ldns_rdf_type type, size_t size, const void *data); | |
225 | ||
226 | /** | |
227 | * creates a new rdf from a string. | |
228 | * \param[in] type type to use | |
229 | * \param[in] str string to use | |
230 | * \return ldns_rdf* or NULL in case of an error | |
231 | */ | |
232 | ldns_rdf *ldns_rdf_new_frm_str(ldns_rdf_type type, const char *str); | |
233 | ||
234 | /** | |
235 | * creates a new rdf from a file containing a string. | |
236 | * \param[out] r the new rdf | |
237 | * \param[in] type type to use | |
238 | * \param[in] fp the file pointer to use | |
239 | * \return LDNS_STATUS_OK or the error | |
240 | */ | |
241 | ldns_status ldns_rdf_new_frm_fp(ldns_rdf **r, ldns_rdf_type type, FILE *fp); | |
242 | ||
243 | /** | |
244 | * creates a new rdf from a file containing a string. | |
245 | * \param[out] r the new rdf | |
246 | * \param[in] type type to use | |
247 | * \param[in] fp the file pointer to use | |
248 | * \param[in] line_nr pointer to an integer containing the current line number (for debugging purposes) | |
249 | * \return LDNS_STATUS_OK or the error | |
250 | */ | |
251 | ldns_status ldns_rdf_new_frm_fp_l(ldns_rdf **r, ldns_rdf_type type, FILE *fp, int *line_nr); | |
252 | ||
253 | /* destroy functions */ | |
254 | ||
255 | /** | |
256 | * frees a rdf structure, leaving the | |
257 | * data pointer intact. | |
258 | * \param[in] rd the pointer to be freed | |
259 | * \return void | |
260 | */ | |
261 | void ldns_rdf_free(ldns_rdf *rd); | |
262 | ||
263 | /** | |
264 | * frees a rdf structure _and_ frees the | |
265 | * data. rdf should be created with _new_frm_data | |
266 | * \param[in] rd the rdf structure to be freed | |
267 | * \return void | |
268 | */ | |
269 | void ldns_rdf_deep_free(ldns_rdf *rd); | |
270 | ||
271 | /* conversion functions */ | |
272 | ||
273 | /** | |
274 | * returns the rdf containing the native uint8_t repr. | |
275 | * \param[in] type the ldns_rdf type to use | |
276 | * \param[in] value the uint8_t to use | |
277 | * \return ldns_rdf* with the converted value | |
278 | */ | |
279 | ldns_rdf *ldns_native2rdf_int8(ldns_rdf_type type, uint8_t value); | |
280 | ||
281 | /** | |
282 | * returns the rdf containing the native uint16_t representation. | |
283 | * \param[in] type the ldns_rdf type to use | |
284 | * \param[in] value the uint16_t to use | |
285 | * \return ldns_rdf* with the converted value | |
286 | */ | |
287 | ldns_rdf *ldns_native2rdf_int16(ldns_rdf_type type, uint16_t value); | |
288 | ||
289 | /** | |
290 | * returns an rdf that contains the given int32 value. | |
291 | * | |
292 | * Because multiple rdf types can contain an int32, the | |
293 | * type must be specified | |
294 | * \param[in] type the ldns_rdf type to use | |
295 | * \param[in] value the uint32_t to use | |
296 | * \return ldns_rdf* with the converted value | |
297 | */ | |
298 | ldns_rdf *ldns_native2rdf_int32(ldns_rdf_type type, uint32_t value); | |
299 | ||
300 | /** | |
301 | * returns an int16_data rdf that contains the data in the | |
302 | * given array, preceded by an int16 specifying the length. | |
303 | * | |
304 | * The memory is copied, and an LDNS_RDF_TYPE_INT16DATA is returned | |
305 | * \param[in] size the size of the data | |
306 | * \param[in] *data pointer to the actual data | |
d1b2b5ca | 307 | * |
825eb42b JL |
308 | * \return ldns_rd* the rdf with the data |
309 | */ | |
310 | ldns_rdf *ldns_native2rdf_int16_data(size_t size, uint8_t *data); | |
311 | ||
312 | /** | |
313 | * reverses an rdf, only actually useful for AAAA and A records. | |
314 | * The returned rdf has the type LDNS_RDF_TYPE_DNAME! | |
315 | * \param[in] *rd rdf to be reversed | |
316 | * \return the reversed rdf (a newly created rdf) | |
317 | */ | |
318 | ldns_rdf *ldns_rdf_address_reverse(ldns_rdf *rd); | |
319 | ||
320 | /** | |
321 | * returns the native uint8_t representation from the rdf. | |
322 | * \param[in] rd the ldns_rdf to operate on | |
323 | * \return uint8_t the value extracted | |
324 | */ | |
325 | uint8_t ldns_rdf2native_int8(const ldns_rdf *rd); | |
326 | ||
327 | /** | |
328 | * returns the native uint16_t representation from the rdf. | |
329 | * \param[in] rd the ldns_rdf to operate on | |
330 | * \return uint16_t the value extracted | |
331 | */ | |
332 | uint16_t ldns_rdf2native_int16(const ldns_rdf *rd); | |
333 | ||
334 | /** | |
335 | * returns the native uint32_t representation from the rdf. | |
336 | * \param[in] rd the ldns_rdf to operate on | |
337 | * \return uint32_t the value extracted | |
338 | */ | |
339 | uint32_t ldns_rdf2native_int32(const ldns_rdf *rd); | |
340 | ||
341 | /** | |
342 | * returns the native time_t representation from the rdf. | |
343 | * \param[in] rd the ldns_rdf to operate on | |
344 | * \return time_t the value extracted (32 bits currently) | |
345 | */ | |
346 | time_t ldns_rdf2native_time_t(const ldns_rdf *rd); | |
347 | ||
348 | /** | |
349 | * converts a ttl value (like 5d2h) to a long. | |
350 | * \param[in] nptr the start of the string | |
351 | * \param[out] endptr points to the last char in case of error | |
352 | * \return the convert duration value | |
353 | */ | |
354 | uint32_t ldns_str2period(const char *nptr, const char **endptr); | |
355 | ||
356 | /** | |
357 | * removes \\DDD, \\[space] and other escapes from the input. | |
358 | * See RFC 1035, section 5.1. | |
359 | * \param[in] word what to check | |
360 | * \param[in] length the string | |
361 | * \return ldns_status mesg | |
362 | */ | |
363 | ldns_status ldns_octet(char *word, size_t *length); | |
364 | ||
365 | /** | |
366 | * clones a rdf structure. The data is copied. | |
367 | * \param[in] rd rdf to be copied | |
368 | * \return a new rdf structure | |
369 | */ | |
370 | ldns_rdf *ldns_rdf_clone(const ldns_rdf *rd); | |
371 | ||
372 | /** | |
373 | * compares two rdf's on their wire formats. | |
374 | * (To order dnames according to rfc4034, use ldns_dname_compare) | |
375 | * \param[in] rd1 the first one | |
376 | * \param[in] rd2 the second one | |
377 | * \return 0 if equal | |
378 | * \return -1 if rd1 comes before rd2 | |
379 | * \return +1 if rd2 comes before rd1 | |
380 | */ | |
381 | int ldns_rdf_compare(const ldns_rdf *rd1, const ldns_rdf *rd2); | |
382 | ||
ac996e71 JL |
383 | #ifdef __cplusplus |
384 | } | |
385 | #endif | |
386 | ||
825eb42b | 387 | #endif /* LDNS_RDATA_H */ |