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