Logo Search packages:      
Sourcecode: ldns version File versions  Download package

rdata.h

Go to the documentation of this file.
/*
 * 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 \ref ldns_rdf and functions to manipulate those.
 */


#ifndef LDNS_RDATA_H
#define LDNS_RDATA_H

#include <ldns/common.h>
#include <ldns/error.h>

#define LDNS_MAX_RDFLEN 65535

#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

/**
 * The different types of RDATA fields.
 */
00038 enum ldns_enum_rdf_type
{
      /** none */
00041       LDNS_RDF_TYPE_NONE,
      /** domain name */
00043       LDNS_RDF_TYPE_DNAME,
      /** 8 bits */
00045       LDNS_RDF_TYPE_INT8,
      /** 16 bits */
00047       LDNS_RDF_TYPE_INT16,
      /** 32 bits */
00049       LDNS_RDF_TYPE_INT32,
      /** A record */
00051       LDNS_RDF_TYPE_A,  
      /** AAAA record */
00053       LDNS_RDF_TYPE_AAAA,
      /** txt string */
00055       LDNS_RDF_TYPE_STR,
      /** apl data */
00057       LDNS_RDF_TYPE_APL,
      /** b64 string */
00059       LDNS_RDF_TYPE_B64,
      /** hex string */
00061       LDNS_RDF_TYPE_HEX,
      /** nsec type codes */
00063       LDNS_RDF_TYPE_NSEC, 
      /** a RR type */
00065       LDNS_RDF_TYPE_TYPE, 
      /** a class */
00067       LDNS_RDF_TYPE_CLASS,
      /** certificate algorithm */
00069       LDNS_RDF_TYPE_CERT_ALG,
      /** a key algorithm */
00071       LDNS_RDF_TYPE_ALG,
      /** unknown types */
00073       LDNS_RDF_TYPE_UNKNOWN,
      /** time (32 bits) */
00075       LDNS_RDF_TYPE_TIME,
      /** period */
00077       LDNS_RDF_TYPE_PERIOD,
      /** tsig time 48 bits */
00079       LDNS_RDF_TYPE_TSIGTIME,
      LDNS_RDF_TYPE_TSIG,
      /** variable length any type rdata where the length
          is specified by the first 2 bytes */
00083       LDNS_RDF_TYPE_INT16_DATA,
      /** protocol and port bitmaps */
00085       LDNS_RDF_TYPE_SERVICE,
      /** location data */
00087       LDNS_RDF_TYPE_LOC,
      /** well known services */
00089       LDNS_RDF_TYPE_WKS,
      /** NSAP */
00091       LDNS_RDF_TYPE_NSAP,
      /** IPSECKEY */
00093       LDNS_RDF_TYPE_IPSECKEY
};
typedef enum ldns_enum_rdf_type ldns_rdf_type;

/**
 * algorithms used in CERT rrs
 */
00100 enum ldns_enum_cert_algorithm
{
      LDNS_CERT_PKIX          = 1,
      LDNS_CERT_SPKI          = 2,
      LDNS_CERT_PGP           = 3,
      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.
 */
00119 struct ldns_struct_rdf
{
      /** The size of the data (in octets) */
00122       size_t _size;
      /** The type of the data */
00124       ldns_rdf_type _type;
      /** Pointer to the data (raw octets) */
00126       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);

#endif      /* LDNS_RDATA_H */

Generated by  Doxygen 1.6.0   Back to index