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 */