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 #ifdef __cplusplus 28 extern "C" { 29 #endif 30 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 { 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 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 197 * 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 307 * 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 383 #ifdef __cplusplus 384 } 385 #endif 386 387 #endif /* LDNS_RDATA_H */ 388