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         /** Since RFC7218 TLSA records can be given with mnemonics,
 135          * hence these rdata field types.  But as with DNSKEYs, the output
 136          * is always numeric.
 137          */
 138         LDNS_RDF_TYPE_CERTIFICATE_USAGE,
 139         LDNS_RDF_TYPE_SELECTOR,
 140         LDNS_RDF_TYPE_MATCHING_TYPE,
 141
 142         /* Aliases */
 143         LDNS_RDF_TYPE_BITMAP = LDNS_RDF_TYPE_NSEC
 144 };
 145 typedef enum ldns_enum_rdf_type ldns_rdf_type;
 146
 147 /**
 148  * algorithms used in CERT rrs
 149  */
 150 enum ldns_enum_cert_algorithm
 151 {
 152         LDNS_CERT_PKIX          = 1,
 153         LDNS_CERT_SPKI          = 2,
 154         LDNS_CERT_PGP           = 3,
 155         LDNS_CERT_IPKIX         = 4,
 156         LDNS_CERT_ISPKI         = 5,
 157         LDNS_CERT_IPGP          = 6,
 158         LDNS_CERT_ACPKIX        = 7,
 159         LDNS_CERT_IACPKIX       = 8,
 160         LDNS_CERT_URI           = 253,
 161         LDNS_CERT_OID           = 254
 162 };
 163 typedef enum ldns_enum_cert_algorithm ldns_cert_algorithm;
 164
 165
 166
 167 /**
 168  * Resource record data field.
 169  *
 170  * The data is a network ordered array of bytes, which size is specified by
 171  * the (16-bit) size field. To correctly parse it, use the type
 172  * specified in the (16-bit) type field with a value from \ref ldns_rdf_type.
 173  */
 174 struct ldns_struct_rdf
 175 {
 176         /** The size of the data (in octets) */
 177         size_t _size;
 178         /** The type of the data */
 179         ldns_rdf_type _type;
 180         /** Pointer to the data (raw octets) */
 181         void  *_data;
 182 };
 183 typedef struct ldns_struct_rdf ldns_rdf;
 184
 185 /* prototypes */
 186
 187 /* write access functions */
 188
 189 /**
 190  * sets the size of the rdf.
 191  * \param[in] *rd the rdf to operate on
 192  * \param[in] size the new size
 193  * \return void
 194  */
 195 void ldns_rdf_set_size(ldns_rdf *rd, size_t size);
 196
 197 /**
 198  * sets the size of the rdf.
 199  * \param[in] *rd the rdf to operate on
 200  * \param[in] type the new type
 201  * \return void
 202  */
 203 void ldns_rdf_set_type(ldns_rdf *rd, ldns_rdf_type type);
 204
 205 /**
 206  * sets the size of the rdf.
 207  * \param[in] *rd the rdf to operate on
 208  * \param[in] *data pointer to the new data
 209  * \return void
 210  */
 211 void ldns_rdf_set_data(ldns_rdf *rd, void *data);
 212
 213 /* read access */
 214
 215 /**
 216  * returns the size of the rdf.
 217  * \param[in] *rd the rdf to read from
 218  * \return uint16_t with the size
 219  */
 220 size_t ldns_rdf_size(const ldns_rdf *rd);
 221
 222 /**
 223  * returns the type of the rdf. We need to insert _get_
 224  * here to prevent conflict the the rdf_type TYPE.
 225  * \param[in] *rd the rdf to read from
 226  * \return ldns_rdf_type with the type
 227  */
 228 ldns_rdf_type ldns_rdf_get_type(const ldns_rdf *rd);
 229
 230 /**
 231  * returns the data of the rdf.
 232  * \param[in] *rd the rdf to read from
 233  *
 234  * \return uint8_t* pointer to the rdf's data
 235  */
 236 uint8_t *ldns_rdf_data(const ldns_rdf *rd);
 237
 238 /* creator functions */
 239
 240 /**
 241  * allocates a new rdf structure and fills it.
 242  * This function DOES NOT copy the contents from
 243  * the buffer, unlinke ldns_rdf_new_frm_data()
 244  * \param[in] type type of the rdf
 245  * \param[in] size size of the buffer
 246  * \param[in] data pointer to the buffer to be copied
 247  * \return the new rdf structure or NULL on failure
 248  */
 249 ldns_rdf *ldns_rdf_new(ldns_rdf_type type, size_t size, void *data);
 250
 251 /**
 252  * allocates a new rdf structure and fills it.
 253  * This function _does_ copy the contents from
 254  * the buffer, unlinke ldns_rdf_new()
 255  * \param[in] type type of the rdf
 256  * \param[in] size size of the buffer
 257  * \param[in] data pointer to the buffer to be copied
 258  * \return the new rdf structure or NULL on failure
 259  */
 260 ldns_rdf *ldns_rdf_new_frm_data(ldns_rdf_type type, size_t size, const void *data);
 261
 262 /**
 263  * creates a new rdf from a string.
 264  * \param[in] type   type to use
 265  * \param[in] str string to use
 266  * \return ldns_rdf* or NULL in case of an error
 267  */
 268 ldns_rdf *ldns_rdf_new_frm_str(ldns_rdf_type type, const char *str);
 269
 270 /**
 271  * creates a new rdf from a file containing a string.
 272  * \param[out] r the new rdf
 273  * \param[in] type   type to use
 274  * \param[in] fp the file pointer  to use
 275  * \return LDNS_STATUS_OK or the error
 276  */
 277 ldns_status ldns_rdf_new_frm_fp(ldns_rdf **r, ldns_rdf_type type, FILE *fp);
 278
 279 /**
 280  * creates a new rdf from a file containing a string.
 281  * \param[out] r the new rdf
 282  * \param[in] type   type to use
 283  * \param[in] fp the file pointer  to use
 284  * \param[in] line_nr pointer to an integer containing the current line number (for debugging purposes)
 285  * \return LDNS_STATUS_OK or the error
 286  */
 287 ldns_status ldns_rdf_new_frm_fp_l(ldns_rdf **r, ldns_rdf_type type, FILE *fp, int *line_nr);
 288
 289 /* destroy functions */
 290
 291 /**
 292  * frees a rdf structure, leaving the
 293  * data pointer intact.
 294  * \param[in] rd the pointer to be freed
 295  * \return void
 296  */
 297 void ldns_rdf_free(ldns_rdf *rd);
 298
 299 /**
 300  * frees a rdf structure _and_ frees the
 301  * data. rdf should be created with _new_frm_data
 302  * \param[in] rd the rdf structure to be freed
 303  * \return void
 304  */
 305 void ldns_rdf_deep_free(ldns_rdf *rd);
 306
 307 /* conversion functions */
 308
 309 /**
 310  * returns the rdf containing the native uint8_t repr.
 311  * \param[in] type the ldns_rdf type to use
 312  * \param[in] value the uint8_t to use
 313  * \return ldns_rdf* with the converted value
 314  */
 315 ldns_rdf *ldns_native2rdf_int8(ldns_rdf_type type, uint8_t value);
 316
 317 /**
 318  * returns the rdf containing the native uint16_t representation.
 319  * \param[in] type the ldns_rdf type to use
 320  * \param[in] value the uint16_t to use
 321  * \return ldns_rdf* with the converted value
 322  */
 323 ldns_rdf *ldns_native2rdf_int16(ldns_rdf_type type, uint16_t value);
 324
 325 /**
 326  * returns an rdf that contains the given int32 value.
 327  *
 328  * Because multiple rdf types can contain an int32, the
 329  * type must be specified
 330  * \param[in] type the ldns_rdf type to use
 331  * \param[in] value the uint32_t to use
 332  * \return ldns_rdf* with the converted value
 333  */
 334 ldns_rdf *ldns_native2rdf_int32(ldns_rdf_type type, uint32_t value);
 335
 336 /**
 337  * returns an int16_data rdf that contains the data in the
 338  * given array, preceded by an int16 specifying the length.
 339  *
 340  * The memory is copied, and an LDNS_RDF_TYPE_INT16DATA is returned
 341  * \param[in] size the size of the data
 342  * \param[in] *data pointer to the actual data
 343  *
 344  * \return ldns_rd* the rdf with the data
 345  */
 346 ldns_rdf *ldns_native2rdf_int16_data(size_t size, uint8_t *data);
 347
 348 /**
 349  * reverses an rdf, only actually useful for AAAA and A records.
 350  * The returned rdf has the type LDNS_RDF_TYPE_DNAME!
 351  * \param[in] *rd rdf to be reversed
 352  * \return the reversed rdf (a newly created rdf)
 353  */
 354 ldns_rdf *ldns_rdf_address_reverse(const ldns_rdf *rd);
 355
 356 /**
 357  * returns the native uint8_t representation from the rdf.
 358  * \param[in] rd the ldns_rdf to operate on
 359  * \return uint8_t the value extracted
 360  */
 361 uint8_t         ldns_rdf2native_int8(const ldns_rdf *rd);
 362
 363 /**
 364  * returns the native uint16_t representation from the rdf.
 365  * \param[in] rd the ldns_rdf to operate on
 366  * \return uint16_t the value extracted
 367  */
 368 uint16_t        ldns_rdf2native_int16(const ldns_rdf *rd);
 369
 370 /**
 371  * returns the native uint32_t representation from the rdf.
 372  * \param[in] rd the ldns_rdf to operate on
 373  * \return uint32_t the value extracted
 374  */
 375 uint32_t ldns_rdf2native_int32(const ldns_rdf *rd);
 376
 377 /**
 378  * returns the native time_t representation from the rdf.
 379  * \param[in] rd the ldns_rdf to operate on
 380  * \return time_t the value extracted (32 bits currently)
 381  */
 382 time_t ldns_rdf2native_time_t(const ldns_rdf *rd);
 383
 384 /**
 385  * converts a ttl value (like 5d2h) to a long.
 386  * \param[in] nptr the start of the string
 387  * \param[out] endptr points to the last char in case of error
 388  * \return the convert duration value
 389  */
 390 uint32_t ldns_str2period(const char *nptr, const char **endptr);
 391
 392 /**
 393  * removes \\DDD, \\[space] and other escapes from the input.
 394  * See RFC 1035, section 5.1.
 395  * \param[in] word what to check
 396  * \param[in] length the string
 397  * \return ldns_status mesg
 398  */
 399 ldns_status ldns_octet(char *word, size_t *length);
 400
 401 /**
 402  * clones a rdf structure. The data is copied.
 403  * \param[in] rd rdf to be copied
 404  * \return a new rdf structure
 405  */
 406 ldns_rdf *ldns_rdf_clone(const ldns_rdf *rd);
 407
 408 /**
 409  * compares two rdf's on their wire formats.
 410  * (To order dnames according to rfc4034, use ldns_dname_compare)
 411  * \param[in] rd1 the first one
 412  * \param[in] rd2 the second one
 413  * \return 0 if equal
 414  * \return -1 if rd1 comes before rd2
 415  * \return +1 if rd2 comes before rd1
 416  */
 417 int ldns_rdf_compare(const ldns_rdf *rd1, const ldns_rdf *rd2);
 418
 419 /**
 420  * Gets the algorithm value, the HIT and Public Key data from the rdf with
 421  * type LDNS_RDF_TYPE_HIP.
 422  * \param[in] rdf the rdf with type LDNS_RDF_TYPE_HIP
 423  * \param[out] alg      the algorithm
 424  * \param[out] hit_size the size of the HIT data
 425  * \param[out] hit      the hit data
 426  * \param[out] pk_size  the size of the Public Key data
 427  * \param[out] pk       the  Public Key data
 428  * \return LDNS_STATUS_OK on success, and the error otherwise
 429  */
 430 ldns_status ldns_rdf_hip_get_alg_hit_pk(ldns_rdf *rdf, uint8_t* alg,
 431                 uint8_t *hit_size, uint8_t** hit,
 432                 uint16_t *pk_size, uint8_t** pk);
 433
 434 /**
 435  * Creates a new LDNS_RDF_TYPE_HIP rdf from given data.
 436  * \param[out] rdf      the newly created LDNS_RDF_TYPE_HIP rdf
 437  * \param[in]  alg      the algorithm
 438  * \param[in]  hit_size the size of the HIT data
 439  * \param[in]  hit      the hit data
 440  * \param[in]  pk_size  the size of the Public Key data
 441  * \param[in]  pk       the  Public Key data
 442  * \return LDNS_STATUS_OK on success, and the error otherwise
 443  */
 444 ldns_status ldns_rdf_hip_new_frm_alg_hit_pk(ldns_rdf** rdf, uint8_t alg,
 445                 uint8_t hit_size, uint8_t *hit, uint16_t pk_size, uint8_t *pk);
 446
 447 #ifdef __cplusplus
 448 }
 449 #endif
 450
 451 #endif  /* LDNS_RDATA_H */