386 lines
9.7 KiB
C
386 lines
9.7 KiB
C
/*
|
|
* rdata.h
|
|
*
|
|
* rdata definitions
|
|
*
|
|
* a Net::DNS like library for C
|
|
*
|
|
* (c) NLnet Labs, 2005-2006
|
|
*
|
|
* See the file LICENSE for the license
|
|
*/
|
|
|
|
|
|
/**
|
|
* \file
|
|
*
|
|
* Defines ldns_rdf and functions to manipulate those.
|
|
*/
|
|
|
|
|
|
#ifndef LDNS_RDATA_H
|
|
#define LDNS_RDATA_H
|
|
|
|
#include <ldns/common.h>
|
|
#include <ldns/error.h>
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
#define LDNS_MAX_RDFLEN 8192
|
|
|
|
#define LDNS_RDF_SIZE_BYTE 1
|
|
#define LDNS_RDF_SIZE_WORD 2
|
|
#define LDNS_RDF_SIZE_DOUBLEWORD 4
|
|
#define LDNS_RDF_SIZE_6BYTES 6
|
|
#define LDNS_RDF_SIZE_16BYTES 16
|
|
|
|
#define LDNS_NSEC3_VARS_OPTOUT_MASK 0x01
|
|
|
|
/**
|
|
* The different types of RDATA fields.
|
|
*/
|
|
enum ldns_enum_rdf_type
|
|
{
|
|
/** none */
|
|
LDNS_RDF_TYPE_NONE,
|
|
/** domain name */
|
|
LDNS_RDF_TYPE_DNAME,
|
|
/** 8 bits */
|
|
LDNS_RDF_TYPE_INT8,
|
|
/** 16 bits */
|
|
LDNS_RDF_TYPE_INT16,
|
|
/** 32 bits */
|
|
LDNS_RDF_TYPE_INT32,
|
|
/** A record */
|
|
LDNS_RDF_TYPE_A,
|
|
/** AAAA record */
|
|
LDNS_RDF_TYPE_AAAA,
|
|
/** txt string */
|
|
LDNS_RDF_TYPE_STR,
|
|
/** apl data */
|
|
LDNS_RDF_TYPE_APL,
|
|
/** b32 string */
|
|
LDNS_RDF_TYPE_B32_EXT,
|
|
/** b64 string */
|
|
LDNS_RDF_TYPE_B64,
|
|
/** hex string */
|
|
LDNS_RDF_TYPE_HEX,
|
|
/** nsec type codes */
|
|
LDNS_RDF_TYPE_NSEC,
|
|
/** a RR type */
|
|
LDNS_RDF_TYPE_TYPE,
|
|
/** a class */
|
|
LDNS_RDF_TYPE_CLASS,
|
|
/** certificate algorithm */
|
|
LDNS_RDF_TYPE_CERT_ALG,
|
|
/** a key algorithm */
|
|
LDNS_RDF_TYPE_ALG,
|
|
/** unknown types */
|
|
LDNS_RDF_TYPE_UNKNOWN,
|
|
/** time (32 bits) */
|
|
LDNS_RDF_TYPE_TIME,
|
|
/** period */
|
|
LDNS_RDF_TYPE_PERIOD,
|
|
/** tsig time 48 bits */
|
|
LDNS_RDF_TYPE_TSIGTIME,
|
|
LDNS_RDF_TYPE_TSIG,
|
|
/** variable length any type rdata where the length
|
|
is specified by the first 2 bytes */
|
|
LDNS_RDF_TYPE_INT16_DATA,
|
|
/** protocol and port bitmaps */
|
|
LDNS_RDF_TYPE_SERVICE,
|
|
/** location data */
|
|
LDNS_RDF_TYPE_LOC,
|
|
/** well known services */
|
|
LDNS_RDF_TYPE_WKS,
|
|
/** NSAP */
|
|
LDNS_RDF_TYPE_NSAP,
|
|
/** ATMA */
|
|
LDNS_RDF_TYPE_ATMA,
|
|
/** IPSECKEY */
|
|
LDNS_RDF_TYPE_IPSECKEY,
|
|
/** nsec3 hash salt */
|
|
LDNS_RDF_TYPE_NSEC3_SALT,
|
|
/** nsec3 base32 string (with length byte on wire */
|
|
LDNS_RDF_TYPE_NSEC3_NEXT_OWNER
|
|
};
|
|
typedef enum ldns_enum_rdf_type ldns_rdf_type;
|
|
|
|
/**
|
|
* algorithms used in CERT rrs
|
|
*/
|
|
enum ldns_enum_cert_algorithm
|
|
{
|
|
LDNS_CERT_PKIX = 1,
|
|
LDNS_CERT_SPKI = 2,
|
|
LDNS_CERT_PGP = 3,
|
|
LDNS_CERT_IPKIX = 4,
|
|
LDNS_CERT_ISPKI = 5,
|
|
LDNS_CERT_IPGP = 6,
|
|
LDNS_CERT_ACPKIX = 7,
|
|
LDNS_CERT_IACPKIX = 8,
|
|
LDNS_CERT_URI = 253,
|
|
LDNS_CERT_OID = 254
|
|
};
|
|
typedef enum ldns_enum_cert_algorithm ldns_cert_algorithm;
|
|
|
|
|
|
|
|
/**
|
|
* Resource record data field.
|
|
*
|
|
* The data is a network ordered array of bytes, which size is specified by
|
|
* the (16-bit) size field. To correctly parse it, use the type
|
|
* specified in the (16-bit) type field with a value from \ref ldns_rdf_type.
|
|
*/
|
|
struct ldns_struct_rdf
|
|
{
|
|
/** The size of the data (in octets) */
|
|
size_t _size;
|
|
/** The type of the data */
|
|
ldns_rdf_type _type;
|
|
/** Pointer to the data (raw octets) */
|
|
void *_data;
|
|
};
|
|
typedef struct ldns_struct_rdf ldns_rdf;
|
|
|
|
/* prototypes */
|
|
|
|
/* write access functions */
|
|
|
|
/**
|
|
* sets the size of the rdf.
|
|
* \param[in] *rd the rdf to operate on
|
|
* \param[in] size the new size
|
|
* \return void
|
|
*/
|
|
void ldns_rdf_set_size(ldns_rdf *rd, size_t size);
|
|
|
|
/**
|
|
* sets the size of the rdf.
|
|
* \param[in] *rd the rdf to operate on
|
|
* \param[in] type the new type
|
|
* \return void
|
|
*/
|
|
void ldns_rdf_set_type(ldns_rdf *rd, ldns_rdf_type type);
|
|
|
|
/**
|
|
* sets the size of the rdf.
|
|
* \param[in] *rd the rdf to operate on
|
|
* \param[in] *data pointer to the new data
|
|
* \return void
|
|
*/
|
|
void ldns_rdf_set_data(ldns_rdf *rd, void *data);
|
|
|
|
/* read access */
|
|
|
|
/**
|
|
* returns the size of the rdf.
|
|
* \param[in] *rd the rdf to read from
|
|
* \return uint16_t with the size
|
|
*/
|
|
size_t ldns_rdf_size(const ldns_rdf *rd);
|
|
|
|
/**
|
|
* returns the type of the rdf. We need to insert _get_
|
|
* here to prevent conflict the the rdf_type TYPE.
|
|
* \param[in] *rd the rdf to read from
|
|
* \return ldns_rdf_type with the type
|
|
*/
|
|
ldns_rdf_type ldns_rdf_get_type(const ldns_rdf *rd);
|
|
|
|
/**
|
|
* returns the data of the rdf.
|
|
* \param[in] *rd the rdf to read from
|
|
* \return uint8_t* pointer to the rdf's data
|
|
*/
|
|
uint8_t *ldns_rdf_data(const ldns_rdf *rd);
|
|
|
|
/* creator functions */
|
|
|
|
/**
|
|
* allocates a new rdf structure and fills it.
|
|
* This function DOES NOT copy the contents from
|
|
* the buffer, unlinke ldns_rdf_new_frm_data()
|
|
* \param[in] type type of the rdf
|
|
* \param[in] size size of the buffer
|
|
* \param[in] data pointer to the buffer to be copied
|
|
* \return the new rdf structure or NULL on failure
|
|
*/
|
|
ldns_rdf *ldns_rdf_new(ldns_rdf_type type, size_t size, void *data);
|
|
|
|
/**
|
|
* allocates a new rdf structure and fills it.
|
|
* This function _does_ copy the contents from
|
|
* the buffer, unlinke ldns_rdf_new()
|
|
* \param[in] type type of the rdf
|
|
* \param[in] size size of the buffer
|
|
* \param[in] data pointer to the buffer to be copied
|
|
* \return the new rdf structure or NULL on failure
|
|
*/
|
|
ldns_rdf *ldns_rdf_new_frm_data(ldns_rdf_type type, size_t size, const void *data);
|
|
|
|
/**
|
|
* creates a new rdf from a string.
|
|
* \param[in] type type to use
|
|
* \param[in] str string to use
|
|
* \return ldns_rdf* or NULL in case of an error
|
|
*/
|
|
ldns_rdf *ldns_rdf_new_frm_str(ldns_rdf_type type, const char *str);
|
|
|
|
/**
|
|
* creates a new rdf from a file containing a string.
|
|
* \param[out] r the new rdf
|
|
* \param[in] type type to use
|
|
* \param[in] fp the file pointer to use
|
|
* \return LDNS_STATUS_OK or the error
|
|
*/
|
|
ldns_status ldns_rdf_new_frm_fp(ldns_rdf **r, ldns_rdf_type type, FILE *fp);
|
|
|
|
/**
|
|
* creates a new rdf from a file containing a string.
|
|
* \param[out] r the new rdf
|
|
* \param[in] type type to use
|
|
* \param[in] fp the file pointer to use
|
|
* \param[in] line_nr pointer to an integer containing the current line number (for debugging purposes)
|
|
* \return LDNS_STATUS_OK or the error
|
|
*/
|
|
ldns_status ldns_rdf_new_frm_fp_l(ldns_rdf **r, ldns_rdf_type type, FILE *fp, int *line_nr);
|
|
|
|
/* destroy functions */
|
|
|
|
/**
|
|
* frees a rdf structure, leaving the
|
|
* data pointer intact.
|
|
* \param[in] rd the pointer to be freed
|
|
* \return void
|
|
*/
|
|
void ldns_rdf_free(ldns_rdf *rd);
|
|
|
|
/**
|
|
* frees a rdf structure _and_ frees the
|
|
* data. rdf should be created with _new_frm_data
|
|
* \param[in] rd the rdf structure to be freed
|
|
* \return void
|
|
*/
|
|
void ldns_rdf_deep_free(ldns_rdf *rd);
|
|
|
|
/* conversion functions */
|
|
|
|
/**
|
|
* returns the rdf containing the native uint8_t repr.
|
|
* \param[in] type the ldns_rdf type to use
|
|
* \param[in] value the uint8_t to use
|
|
* \return ldns_rdf* with the converted value
|
|
*/
|
|
ldns_rdf *ldns_native2rdf_int8(ldns_rdf_type type, uint8_t value);
|
|
|
|
/**
|
|
* returns the rdf containing the native uint16_t representation.
|
|
* \param[in] type the ldns_rdf type to use
|
|
* \param[in] value the uint16_t to use
|
|
* \return ldns_rdf* with the converted value
|
|
*/
|
|
ldns_rdf *ldns_native2rdf_int16(ldns_rdf_type type, uint16_t value);
|
|
|
|
/**
|
|
* returns an rdf that contains the given int32 value.
|
|
*
|
|
* Because multiple rdf types can contain an int32, the
|
|
* type must be specified
|
|
* \param[in] type the ldns_rdf type to use
|
|
* \param[in] value the uint32_t to use
|
|
* \return ldns_rdf* with the converted value
|
|
*/
|
|
ldns_rdf *ldns_native2rdf_int32(ldns_rdf_type type, uint32_t value);
|
|
|
|
/**
|
|
* returns an int16_data rdf that contains the data in the
|
|
* given array, preceded by an int16 specifying the length.
|
|
*
|
|
* The memory is copied, and an LDNS_RDF_TYPE_INT16DATA is returned
|
|
* \param[in] size the size of the data
|
|
* \param[in] *data pointer to the actual data
|
|
* \return ldns_rd* the rdf with the data
|
|
*/
|
|
ldns_rdf *ldns_native2rdf_int16_data(size_t size, uint8_t *data);
|
|
|
|
/**
|
|
* reverses an rdf, only actually useful for AAAA and A records.
|
|
* The returned rdf has the type LDNS_RDF_TYPE_DNAME!
|
|
* \param[in] *rd rdf to be reversed
|
|
* \return the reversed rdf (a newly created rdf)
|
|
*/
|
|
ldns_rdf *ldns_rdf_address_reverse(ldns_rdf *rd);
|
|
|
|
/**
|
|
* returns the native uint8_t representation from the rdf.
|
|
* \param[in] rd the ldns_rdf to operate on
|
|
* \return uint8_t the value extracted
|
|
*/
|
|
uint8_t ldns_rdf2native_int8(const ldns_rdf *rd);
|
|
|
|
/**
|
|
* returns the native uint16_t representation from the rdf.
|
|
* \param[in] rd the ldns_rdf to operate on
|
|
* \return uint16_t the value extracted
|
|
*/
|
|
uint16_t ldns_rdf2native_int16(const ldns_rdf *rd);
|
|
|
|
/**
|
|
* returns the native uint32_t representation from the rdf.
|
|
* \param[in] rd the ldns_rdf to operate on
|
|
* \return uint32_t the value extracted
|
|
*/
|
|
uint32_t ldns_rdf2native_int32(const ldns_rdf *rd);
|
|
|
|
/**
|
|
* returns the native time_t representation from the rdf.
|
|
* \param[in] rd the ldns_rdf to operate on
|
|
* \return time_t the value extracted (32 bits currently)
|
|
*/
|
|
time_t ldns_rdf2native_time_t(const ldns_rdf *rd);
|
|
|
|
/**
|
|
* converts a ttl value (like 5d2h) to a long.
|
|
* \param[in] nptr the start of the string
|
|
* \param[out] endptr points to the last char in case of error
|
|
* \return the convert duration value
|
|
*/
|
|
uint32_t ldns_str2period(const char *nptr, const char **endptr);
|
|
|
|
/**
|
|
* removes \\DDD, \\[space] and other escapes from the input.
|
|
* See RFC 1035, section 5.1.
|
|
* \param[in] word what to check
|
|
* \param[in] length the string
|
|
* \return ldns_status mesg
|
|
*/
|
|
ldns_status ldns_octet(char *word, size_t *length);
|
|
|
|
/**
|
|
* clones a rdf structure. The data is copied.
|
|
* \param[in] rd rdf to be copied
|
|
* \return a new rdf structure
|
|
*/
|
|
ldns_rdf *ldns_rdf_clone(const ldns_rdf *rd);
|
|
|
|
/**
|
|
* compares two rdf's on their wire formats.
|
|
* (To order dnames according to rfc4034, use ldns_dname_compare)
|
|
* \param[in] rd1 the first one
|
|
* \param[in] rd2 the second one
|
|
* \return 0 if equal
|
|
* \return -1 if rd1 comes before rd2
|
|
* \return +1 if rd2 comes before rd1
|
|
*/
|
|
int ldns_rdf_compare(const ldns_rdf *rd1, const ldns_rdf *rd2);
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
#endif /* LDNS_RDATA_H */
|