}
ldns_rdf *
-ldns_nsec_get_bitmap(ldns_rr *nsec) {
+ldns_nsec_get_bitmap(const ldns_rr *nsec) {
if (ldns_rr_get_type(nsec) == LDNS_RR_TYPE_NSEC) {
return ldns_rr_rdf(nsec, 1);
} else if (ldns_rr_get_type(nsec) == LDNS_RR_TYPE_NSEC3) {
/*return the owner name of the closest encloser for name from the list of rrs */
/* this is NOT the hash, but the original name! */
ldns_rdf *
-ldns_dnssec_nsec3_closest_encloser(ldns_rdf *qname,
+ldns_dnssec_nsec3_closest_encloser(const ldns_rdf *qname,
ATTR_UNUSED(ldns_rr_type qtype),
- ldns_rr_list *nsec3s)
+ const ldns_rr_list *nsec3s)
{
/* remember parameters, they must match */
uint8_t algorithm;
ldns_rr_list *
ldns_dnssec_pkt_get_rrsigs_for_name_and_type(const ldns_pkt *pkt,
- ldns_rdf *name,
+ const ldns_rdf *name,
ldns_rr_type type)
{
uint16_t t_netorder;
return ac16;
}
-uint16_t ldns_calc_keytag_raw(uint8_t* key, size_t keysize)
+uint16_t ldns_calc_keytag_raw(const uint8_t* key, size_t keysize)
{
unsigned int i;
uint32_t ac32;
#ifdef HAVE_SSL
DSA *
-ldns_key_buf2dsa(ldns_buffer *key)
+ldns_key_buf2dsa(const ldns_buffer *key)
{
- return ldns_key_buf2dsa_raw((unsigned char*)ldns_buffer_begin(key),
+ return ldns_key_buf2dsa_raw((const unsigned char*)ldns_buffer_begin(key),
ldns_buffer_position(key));
}
DSA *
-ldns_key_buf2dsa_raw(unsigned char* key, size_t len)
+ldns_key_buf2dsa_raw(const unsigned char* key, size_t len)
{
uint8_t T;
uint16_t length;
}
RSA *
-ldns_key_buf2rsa(ldns_buffer *key)
+ldns_key_buf2rsa(const ldns_buffer *key)
{
- return ldns_key_buf2rsa_raw((unsigned char*)ldns_buffer_begin(key),
+ return ldns_key_buf2rsa_raw((const unsigned char*)ldns_buffer_begin(key),
ldns_buffer_position(key));
}
RSA *
-ldns_key_buf2rsa_raw(unsigned char* key, size_t len)
+ldns_key_buf2rsa_raw(const unsigned char* key, size_t len)
{
uint16_t offset;
uint16_t exp;
}
int
-ldns_digest_evp(unsigned char* data, unsigned int len, unsigned char* dest,
+ldns_digest_evp(const unsigned char* data, unsigned int len, unsigned char* dest,
const EVP_MD* md)
{
EVP_MD_CTX* ctx;
}
int
-ldns_dnssec_rrsets_contains_type(ldns_dnssec_rrsets *rrsets,
+ldns_dnssec_rrsets_contains_type(const ldns_dnssec_rrsets *rrsets,
ldns_rr_type type)
{
- ldns_dnssec_rrsets *cur_rrset = rrsets;
+ const ldns_dnssec_rrsets *cur_rrset = rrsets;
while (cur_rrset) {
if (cur_rrset->type == type) {
return 1;
}
ldns_rr *
-ldns_dnssec_create_nsec(ldns_dnssec_name *from,
- ldns_dnssec_name *to,
+ldns_dnssec_create_nsec(const ldns_dnssec_name *from,
+ const ldns_dnssec_name *to,
ldns_rr_type nsec_type)
{
ldns_rr *nsec_rr;
}
ldns_rr *
-ldns_dnssec_create_nsec3(ldns_dnssec_name *from,
- ldns_dnssec_name *to,
- ldns_rdf *zone_name,
+ldns_dnssec_create_nsec3(const ldns_dnssec_name *from,
+ const ldns_dnssec_name *to,
+ const ldns_rdf *zone_name,
uint8_t algorithm,
uint8_t flags,
uint16_t iterations,
uint8_t salt_length,
- uint8_t *salt)
+ const uint8_t *salt)
{
ldns_rr *nsec_rr;
ldns_rr_type types[65536];
}
ldns_rdf *
-ldns_nsec3_hash_name(ldns_rdf *name,
+ldns_nsec3_hash_name(const ldns_rdf *name,
uint8_t algorithm,
uint16_t iterations,
uint8_t salt_length,
- uint8_t *salt)
+ const uint8_t *salt)
{
size_t hashed_owner_str_len;
ldns_rdf *cann;
uint8_t flags,
uint16_t iterations,
uint8_t salt_length,
- uint8_t *salt)
+ const uint8_t *salt)
{
ldns_rdf *salt_rdf = NULL;
uint8_t *salt_data = NULL;
}
static int
-rr_list_delegation_only(ldns_rdf *origin, ldns_rr_list *rr_list)
+rr_list_delegation_only(const ldns_rdf *origin, const ldns_rr_list *rr_list)
{
size_t i;
ldns_rr *cur_rr;
/* this will NOT return the NSEC3 completed, you will have to run the
finalize function on the rrlist later! */
ldns_rr *
-ldns_create_nsec3(ldns_rdf *cur_owner,
- ldns_rdf *cur_zone,
- ldns_rr_list *rrs,
+ldns_create_nsec3(const ldns_rdf *cur_owner,
+ const ldns_rdf *cur_zone,
+ const ldns_rr_list *rrs,
uint8_t algorithm,
uint8_t flags,
uint16_t iterations,
uint8_t salt_length,
- uint8_t *salt,
+ const uint8_t *salt,
bool emptynonterminal)
{
size_t i;
}
ldns_rdf *
-ldns_nsec3_hash_name_frm_nsec3(const ldns_rr *nsec, ldns_rdf *name)
+ldns_nsec3_hash_name_frm_nsec3(const ldns_rr *nsec, const ldns_rdf *name)
{
uint8_t algorithm;
uint16_t iterations;
}
bool
-ldns_nsec_bitmap_covers_type(const ldns_rdf* bitmap, ldns_rr_type type)
+ldns_nsec_bitmap_covers_type(const ldns_rdf* bitmap, ldns_rr_type type)
{
uint8_t* dptr;
uint8_t* dend;
/* sig may be null - if so look in the packet */
ldns_status
-ldns_pkt_verify_time(ldns_pkt *p, ldns_rr_type t, ldns_rdf *o,
- ldns_rr_list *k, ldns_rr_list *s,
+ldns_pkt_verify_time(const ldns_pkt *p, ldns_rr_type t, const ldns_rdf *o,
+ const ldns_rr_list *k, const ldns_rr_list *s,
time_t check_time, ldns_rr_list *good_keys)
{
ldns_rr_list *rrset;
if (s) {
/* if s is not NULL, the sigs are given to use */
- sigs = s;
+ sigs = (ldns_rr_list *)s;
} else {
/* otherwise get them from the packet */
sigs = ldns_pkt_rr_list_by_name_and_type(p, o,
}
ldns_status
-ldns_pkt_verify(ldns_pkt *p, ldns_rr_type t, ldns_rdf *o,
- ldns_rr_list *k, ldns_rr_list *s, ldns_rr_list *good_keys)
+ldns_pkt_verify(const ldns_pkt *p, ldns_rr_type t, const ldns_rdf *o,
+ const ldns_rr_list *k, const ldns_rr_list *s, ldns_rr_list *good_keys)
{
return ldns_pkt_verify_time(p, t, o, k, s, ldns_time(NULL), good_keys);
}
#endif /* HAVE_SSL */
ldns_rr *
-ldns_create_empty_rrsig(ldns_rr_list *rrset,
- ldns_key *current_key)
+ldns_create_empty_rrsig(const ldns_rr_list *rrset,
+ const ldns_key *current_key)
{
uint32_t orig_ttl;
ldns_rr_class orig_class;
ldns_status
ldns_verify_time(
- ldns_rr_list *rrset,
- ldns_rr_list *rrsig,
+ const ldns_rr_list *rrset,
+ const ldns_rr_list *rrsig,
const ldns_rr_list *keys,
time_t check_time,
ldns_rr_list *good_keys
#ifdef USE_GOST
EVP_PKEY*
-ldns_gost2pkey_raw(unsigned char* key, size_t keylen)
+ldns_gost2pkey_raw(const unsigned char* key, size_t keylen)
{
/* prefix header for X509 encoding */
uint8_t asn[37] = { 0x30, 0x63, 0x30, 0x1c, 0x06, 0x06, 0x2a, 0x85,
}
static ldns_status
-ldns_verify_rrsig_gost_raw(unsigned char* sig, size_t siglen,
- ldns_buffer* rrset, unsigned char* key, size_t keylen)
+ldns_verify_rrsig_gost_raw(const unsigned char* sig, size_t siglen,
+ const ldns_buffer* rrset, const unsigned char* key, size_t keylen)
{
EVP_PKEY *evp_key;
ldns_status result;
#ifdef USE_ECDSA
EVP_PKEY*
-ldns_ecdsa2pkey_raw(unsigned char* key, size_t keylen, uint8_t algo)
+ldns_ecdsa2pkey_raw(const unsigned char* key, size_t keylen, uint8_t algo)
{
unsigned char buf[256+2]; /* sufficient for 2*384/8+1 */
const unsigned char* pp = buf;
* @param sig: signature to take TTL and wildcard values from
*/
static void
-ldns_rrset_use_signature_ttl(ldns_rr_list* rrset_clone, ldns_rr* rrsig)
+ldns_rrset_use_signature_ttl(ldns_rr_list* rrset_clone, const ldns_rr* rrsig)
{
uint32_t orig_ttl;
uint16_t i;
* @return OK or more specific error.
*/
static ldns_status
-ldns_rrsig2rawsig_buffer(ldns_buffer* rawsig_buf, ldns_rr* rrsig)
+ldns_rrsig2rawsig_buffer(ldns_buffer* rawsig_buf, const ldns_rr* rrsig)
{
uint8_t sig_algo;
* @return status code LDNS_STATUS_OK if all is fine.
*/
static ldns_status
-ldns_rrsig_check_timestamps(ldns_rr* rrsig, time_t now)
+ldns_rrsig_check_timestamps(const ldns_rr* rrsig, time_t now)
{
int32_t inception, expiration;
*/
static ldns_status
ldns_prepare_for_verify(ldns_buffer* rawsig_buf, ldns_buffer* verify_buf,
- ldns_rr_list* rrset_clone, ldns_rr* rrsig)
+ ldns_rr_list* rrset_clone, const ldns_rr* rrsig)
{
ldns_status result;
*/
static ldns_status
ldns_verify_test_sig_key(ldns_buffer* rawsig_buf, ldns_buffer* verify_buf,
- ldns_rr* rrsig, ldns_rr* key)
+ const ldns_rr* rrsig, ldns_rr* key)
{
uint8_t sig_algo;
*/
ldns_status
ldns_verify_rrsig_keylist_time(
- ldns_rr_list *rrset,
- ldns_rr *rrsig,
+ const ldns_rr_list *rrset,
+ const ldns_rr *rrsig,
const ldns_rr_list *keys,
time_t check_time,
ldns_rr_list *good_keys)
}
ldns_status
-ldns_verify_rrsig_keylist_notime(ldns_rr_list *rrset,
- ldns_rr *rrsig,
+ldns_verify_rrsig_keylist_notime(const ldns_rr_list *rrset,
+ const ldns_rr *rrsig,
const ldns_rr_list *keys,
ldns_rr_list *good_keys)
{
}
ldns_status
-ldns_verify_rrsig_evp_raw(unsigned char *sig, size_t siglen,
- ldns_buffer *rrset, EVP_PKEY *key, const EVP_MD *digest_type)
+ldns_verify_rrsig_evp_raw(const unsigned char *sig, size_t siglen,
+ const ldns_buffer *rrset, EVP_PKEY *key, const EVP_MD *digest_type)
{
EVP_MD_CTX ctx;
int res;
void
ldns_dnssec_rrs_print_fmt(FILE *out, const ldns_output_format *fmt,
- ldns_dnssec_rrs *rrs)
+ const ldns_dnssec_rrs *rrs)
{
if (!rrs) {
if ((fmt->flags & LDNS_COMMENT_LAYOUT))
}
void
-ldns_dnssec_rrs_print(FILE *out, ldns_dnssec_rrs *rrs)
+ldns_dnssec_rrs_print(FILE *out, const ldns_dnssec_rrs *rrs)
{
ldns_dnssec_rrs_print_fmt(out, ldns_output_format_default, rrs);
}
}
ldns_rr_type
-ldns_dnssec_rrsets_type(ldns_dnssec_rrsets *rrsets)
+ldns_dnssec_rrsets_type(const ldns_dnssec_rrsets *rrsets)
{
if (rrsets) {
return rrsets->type;
static void
ldns_dnssec_rrsets_print_soa_fmt(FILE *out, const ldns_output_format *fmt,
- ldns_dnssec_rrsets *rrsets,
+ const ldns_dnssec_rrsets *rrsets,
bool follow,
bool show_soa)
{
void
ldns_dnssec_rrsets_print_fmt(FILE *out, const ldns_output_format *fmt,
- ldns_dnssec_rrsets *rrsets,
+ const ldns_dnssec_rrsets *rrsets,
bool follow)
{
ldns_dnssec_rrsets_print_soa_fmt(out, fmt, rrsets, follow, true);
}
void
-ldns_dnssec_rrsets_print(FILE *out, ldns_dnssec_rrsets *rrsets, bool follow)
+ldns_dnssec_rrsets_print(FILE *out, const ldns_dnssec_rrsets *rrsets, bool follow)
{
ldns_dnssec_rrsets_print_fmt(out, ldns_output_format_default,
rrsets, follow);
}
ldns_rdf *
-ldns_dnssec_name_name(ldns_dnssec_name *name)
+ldns_dnssec_name_name(const ldns_dnssec_name *name)
{
if (name) {
return name->name;
}
bool
-ldns_dnssec_name_is_glue(ldns_dnssec_name *name)
+ldns_dnssec_name_is_glue(const ldns_dnssec_name *name)
{
if (name) {
return name->is_glue;
}
ldns_dnssec_rrsets *
-ldns_dnssec_name_find_rrset(ldns_dnssec_name *name,
+ldns_dnssec_name_find_rrset(const ldns_dnssec_name *name,
ldns_rr_type type) {
ldns_dnssec_rrsets *result;
}
ldns_dnssec_rrsets *
-ldns_dnssec_zone_find_rrset(ldns_dnssec_zone *zone,
- ldns_rdf *dname,
+ldns_dnssec_zone_find_rrset(const ldns_dnssec_zone *zone,
+ const ldns_rdf *dname,
ldns_rr_type type)
{
ldns_rbnode_t *node;
static void
ldns_dnssec_name_print_soa_fmt(FILE *out, const ldns_output_format *fmt,
- ldns_dnssec_name *name,
+ const ldns_dnssec_name *name,
bool show_soa)
{
if (name) {
void
ldns_dnssec_name_print_fmt(FILE *out, const ldns_output_format *fmt,
- ldns_dnssec_name *name)
+ const ldns_dnssec_name *name)
{
ldns_dnssec_name_print_soa_fmt(out, fmt, name, true);
}
void
-ldns_dnssec_name_print(FILE *out, ldns_dnssec_name *name)
+ldns_dnssec_name_print(FILE *out, const ldns_dnssec_name *name)
{
ldns_dnssec_name_print_fmt(out, ldns_output_format_default, name);
}
void
ldns_dnssec_zone_names_print_fmt(FILE *out, const ldns_output_format *fmt,
- ldns_rbtree_t *tree,
+ const ldns_rbtree_t *tree,
bool print_soa)
{
ldns_rbnode_t *node;
}
void
-ldns_dnssec_zone_names_print(FILE *out, ldns_rbtree_t *tree, bool print_soa)
+ldns_dnssec_zone_names_print(FILE *out, const ldns_rbtree_t *tree, bool print_soa)
{
ldns_dnssec_zone_names_print_fmt(out, ldns_output_format_default,
tree, print_soa);
void
ldns_dnssec_zone_print_fmt(FILE *out, const ldns_output_format *fmt,
- ldns_dnssec_zone *zone)
+ const ldns_dnssec_zone *zone)
{
if (zone) {
if (zone->soa) {
}
void
-ldns_dnssec_zone_print(FILE *out, ldns_dnssec_zone *zone)
+ldns_dnssec_zone_print(FILE *out, const ldns_dnssec_zone *zone)
{
ldns_dnssec_zone_print_fmt(out, ldns_output_format_default, zone);
}
}
bool
-ldns_dnssec_zone_is_nsec3_optout(ldns_dnssec_zone* zone)
+ldns_dnssec_zone_is_nsec3_optout(const ldns_dnssec_zone* zone)
{
ldns_rr* nsec3;
ldns_rbnode_t* node;
}
char *
-ldns_key_get_file_base_name(ldns_key *key)
+ldns_key_get_file_base_name(const ldns_key *key)
{
ldns_buffer *buffer;
char *file_base_name;
* \param[in] nsec The nsec to get the covered type bitmap of
* \return An ldns_rdf containing the bitmap, or NULL on error
*/
-ldns_rdf *ldns_nsec_get_bitmap(ldns_rr *nsec);
+ldns_rdf *ldns_nsec_get_bitmap(const ldns_rr *nsec);
#define LDNS_NSEC3_MAX_ITERATIONS 65535
* Returns the dname of the closest (provable) encloser
*/
ldns_rdf *
-ldns_dnssec_nsec3_closest_encloser(ldns_rdf *qname,
+ldns_dnssec_nsec3_closest_encloser(const ldns_rdf *qname,
ldns_rr_type qtype,
- ldns_rr_list *nsec3s);
+ const ldns_rr_list *nsec3s);
/**
* Checks whether the packet contains rrsigs
* Returns a ldns_rr_list containing the signatures covering the given name
* and type
*/
-ldns_rr_list *ldns_dnssec_pkt_get_rrsigs_for_name_and_type(const ldns_pkt *pkt, ldns_rdf *name, ldns_rr_type type);
+ldns_rr_list *ldns_dnssec_pkt_get_rrsigs_for_name_and_type(const ldns_pkt *pkt, const ldns_rdf *name, ldns_rr_type type);
/**
* Returns a ldns_rr_list containing the signatures covering the given type
* \param[in] keysize length of key data.
* \return the keytag
*/
-uint16_t ldns_calc_keytag_raw(uint8_t* key, size_t keysize);
+uint16_t ldns_calc_keytag_raw(const uint8_t* key, size_t keysize);
#if LDNS_BUILD_CONFIG_HAVE_SSL
/**
* \param[in] key the key to convert
* \return a DSA * structure with the key material
*/
-DSA *ldns_key_buf2dsa(ldns_buffer *key);
+DSA *ldns_key_buf2dsa(const ldns_buffer *key);
/**
* Like ldns_key_buf2dsa, but uses raw buffer.
* \param[in] key the uncompressed wireformat of the key.
* \param[in] len length of key data
* \return a DSA * structure with the key material
*/
-DSA *ldns_key_buf2dsa_raw(unsigned char* key, size_t len);
+DSA *ldns_key_buf2dsa_raw(const unsigned char* key, size_t len);
/**
* Utility function to calculate hash using generic EVP_MD pointer.
* \param[in] md the message digest to use.
* \return true if worked, false on failure.
*/
-int ldns_digest_evp(unsigned char* data, unsigned int len,
+int ldns_digest_evp(const unsigned char* data, unsigned int len,
unsigned char* dest, const EVP_MD* md);
/**
* \param[in] keylen length of the key data
* \return the key or NULL on error.
*/
-EVP_PKEY* ldns_gost2pkey_raw(unsigned char* key, size_t keylen);
+EVP_PKEY* ldns_gost2pkey_raw(const unsigned char* key, size_t keylen);
/**
* Converts a holding buffer with key material to EVP PKEY in openssl.
* \param[in] algo precise algorithm to initialize ECC group values.
* \return the key or NULL on error.
*/
-EVP_PKEY* ldns_ecdsa2pkey_raw(unsigned char* key, size_t keylen, uint8_t algo);
+EVP_PKEY* ldns_ecdsa2pkey_raw(const unsigned char* key, size_t keylen, uint8_t algo);
#endif /* LDNS_BUILD_CONFIG_HAVE_SSL */
* \param[in] key the key to convert
* \return a RSA * structure with the key material
*/
-RSA *ldns_key_buf2rsa(ldns_buffer *key);
+RSA *ldns_key_buf2rsa(const ldns_buffer *key);
/**
* Like ldns_key_buf2rsa, but uses raw buffer.
* \param[in] len length of key data
* \return a RSA * structure with the key material
*/
-RSA *ldns_key_buf2rsa_raw(unsigned char* key, size_t len);
+RSA *ldns_key_buf2rsa_raw(const unsigned char* key, size_t len);
#endif /* LDNS_BUILD_CONFIG_HAVE_SSL */
/**
* \return int 1 if the type was found, 0 otherwise.
*/
int
-ldns_dnssec_rrsets_contains_type (ldns_dnssec_rrsets *rrsets, ldns_rr_type type);
+ldns_dnssec_rrsets_contains_type(const ldns_dnssec_rrsets *rrsets, ldns_rr_type type);
/**
* Creates NSEC
*/
ldns_rr *
-ldns_dnssec_create_nsec(ldns_dnssec_name *from,
- ldns_dnssec_name *to,
+ldns_dnssec_create_nsec(const ldns_dnssec_name *from,
+ const ldns_dnssec_name *to,
ldns_rr_type nsec_type);
* Creates NSEC3
*/
ldns_rr *
-ldns_dnssec_create_nsec3(ldns_dnssec_name *from,
- ldns_dnssec_name *to,
- ldns_rdf *zone_name,
+ldns_dnssec_create_nsec3(const ldns_dnssec_name *from,
+ const ldns_dnssec_name *to,
+ const ldns_rdf *zone_name,
uint8_t algorithm,
uint8_t flags,
uint16_t iterations,
uint8_t salt_length,
- uint8_t *salt);
+ const uint8_t *salt);
/**
* Create a NSEC record
* \param[in] salt The salt to use
* \return The hashed owner name rdf, without the domain name
*/
-ldns_rdf *ldns_nsec3_hash_name(ldns_rdf *name, uint8_t algorithm, uint16_t iterations, uint8_t salt_length, uint8_t *salt);
+ldns_rdf *ldns_nsec3_hash_name(const ldns_rdf *name, uint8_t algorithm, uint16_t iterations, uint8_t salt_length, const uint8_t *salt);
/**
* Sets all the NSEC3 options. The rr to set them in must be initialized with _new() and
uint8_t flags,
uint16_t iterations,
uint8_t salt_length,
- uint8_t *salt);
+ const uint8_t *salt);
/* this will NOT return the NSEC3 completed, you will have to run the
finalize function on the rrlist later! */
ldns_rr *
-ldns_create_nsec3(ldns_rdf *cur_owner,
- ldns_rdf *cur_zone,
- ldns_rr_list *rrs,
+ldns_create_nsec3(const ldns_rdf *cur_owner,
+ const ldns_rdf *cur_zone,
+ const ldns_rr_list *rrs,
uint8_t algorithm,
uint8_t flags,
uint16_t iterations,
uint8_t salt_length,
- uint8_t *salt,
+ const uint8_t *salt,
bool emptynonterminal);
/**
* \param[in] *name The owner name to calculate the hash for
* \return The hashed owner name rdf, without the domain name
*/
-ldns_rdf *ldns_nsec3_hash_name_frm_nsec3(const ldns_rr *nsec, ldns_rdf *name);
+ldns_rdf *ldns_nsec3_hash_name_frm_nsec3(const ldns_rr *nsec, const ldns_rdf *name);
/**
* Check if RR type t is enumerated and set in the RR type bitmap rdf.
* \param[in] type the type to check for
* \return true when t is found and set, otherwise return false
*/
-bool ldns_nsec_bitmap_covers_type(const ldns_rdf* bitmap, ldns_rr_type type);
+bool ldns_nsec_bitmap_covers_type(const const ldns_rdf* bitmap, ldns_rr_type type);
/**
* Checks if RR type t is enumerated in the type bitmap rdf and sets the bit.
* \return status
*
*/
-ldns_status ldns_pkt_verify(ldns_pkt *p, ldns_rr_type t, ldns_rdf *o, ldns_rr_list *k, ldns_rr_list *s, ldns_rr_list *good_keys);
+ldns_status ldns_pkt_verify(const ldns_pkt *p, ldns_rr_type t, const ldns_rdf *o, const ldns_rr_list *k, const ldns_rr_list *s, ldns_rr_list *good_keys);
/**
* verify a packet
* \return status
*
*/
-ldns_status ldns_pkt_verify_time(ldns_pkt *p, ldns_rr_type t, ldns_rdf *o, ldns_rr_list *k, ldns_rr_list *s, time_t check_time, ldns_rr_list *good_keys);
+ldns_status ldns_pkt_verify_time(const ldns_pkt *p, ldns_rr_type t, const ldns_rdf *o, const ldns_rr_list *k, const ldns_rr_list *s, time_t check_time, ldns_rr_list *good_keys);
#endif
* \return signature rr
*/
ldns_rr *
-ldns_create_empty_rrsig(ldns_rr_list *rrset,
- ldns_key *key);
+ldns_create_empty_rrsig(const ldns_rr_list *rrset,
+ const ldns_key *key);
/**
* Sign the buffer which contains the wiredata of an rrset, and the
* are added to it
* \return status LDNS_STATUS_OK if there is at least one correct key
*/
-ldns_status ldns_verify_time(ldns_rr_list *rrset,
- ldns_rr_list *rrsig,
+ldns_status ldns_verify_time(const ldns_rr_list *rrset,
+ const ldns_rr_list *rrsig,
const ldns_rr_list *keys,
time_t check_time,
ldns_rr_list *good_keys);
* status LDNS_STATUS_OK if at least one key matched. Else an error.
*/
ldns_status ldns_verify_rrsig_keylist_time(
- ldns_rr_list *rrset, ldns_rr *rrsig,
+ const ldns_rr_list *rrset, const ldns_rr *rrsig,
const ldns_rr_list *keys, time_t check_time,
ldns_rr_list *good_keys);
* \return a list of keys which validate the rrsig + rrset. Returns
* status LDNS_STATUS_OK if at least one key matched. Else an error.
*/
-ldns_status ldns_verify_rrsig_keylist_notime(ldns_rr_list *rrset,
- ldns_rr *rrsig,
+ldns_status ldns_verify_rrsig_keylist_notime(const ldns_rr_list *rrset,
+ const ldns_rr *rrsig,
const ldns_rr_list *keys,
ldns_rr_list *good_keys);
* \param[in] key the EVP key structure
* \param[in] digest_type The digest type of the signature
*/
-ldns_status ldns_verify_rrsig_evp_raw(unsigned char *sig,
+ldns_status ldns_verify_rrsig_evp_raw(const unsigned char *sig,
size_t siglen,
- ldns_buffer *rrset,
+ const ldns_buffer *rrset,
EVP_PKEY *key,
const EVP_MD *digest_type);
#endif
* \param[in] out the file descriptor to print to
* \param[in] rrs the list of RRs to print
*/
-void ldns_dnssec_rrs_print(FILE *out, ldns_dnssec_rrs *rrs);
+void ldns_dnssec_rrs_print(FILE *out, const ldns_dnssec_rrs *rrs);
/**
* Prints the given rrs to the file descriptor
* \param[in] rrs the list of RRs to print
*/
void ldns_dnssec_rrs_print_fmt(FILE *out,
- const ldns_output_format *fmt, ldns_dnssec_rrs *rrs);
+ const ldns_output_format *fmt, const ldns_dnssec_rrs *rrs);
/**
* Creates a new list (entry) of RRsets
* \param[in] rrsets the rrset to get the type of
* \return the rr type
*/
-ldns_rr_type ldns_dnssec_rrsets_type(ldns_dnssec_rrsets *rrsets);
+ldns_rr_type ldns_dnssec_rrsets_type(const ldns_dnssec_rrsets *rrsets);
/**
* Sets the RR type of the rrset (that is head of the given list)
* \param[in] follow if set to false, only print the first RRset
*/
void ldns_dnssec_rrsets_print(FILE *out,
- ldns_dnssec_rrsets *rrsets,
+ const ldns_dnssec_rrsets *rrsets,
bool follow);
/**
*/
void ldns_dnssec_rrsets_print_fmt(FILE *out,
const ldns_output_format *fmt,
- ldns_dnssec_rrsets *rrsets,
+ const ldns_dnssec_rrsets *rrsets,
bool follow);
* \param[in] name the dnssec name to get the domain name from
* \return the domain name
*/
-ldns_rdf *ldns_dnssec_name_name(ldns_dnssec_name *name);
+ldns_rdf *ldns_dnssec_name_name(const ldns_dnssec_name *name);
/**
* \param[in] name the dnssec name to get the domain name from
* \return true if the structure is marked as glue, false otherwise.
*/
-bool ldns_dnssec_name_is_glue(ldns_dnssec_name *name);
+bool ldns_dnssec_name_is_glue(const ldns_dnssec_name *name);
/**
* Sets the NSEC(3) RR of the given dnssec_name structure
* \param[in] type the type of the RRset to find
* \return the RRset, or NULL if not present
*/
-ldns_dnssec_rrsets *ldns_dnssec_name_find_rrset(ldns_dnssec_name *name,
+ldns_dnssec_rrsets *ldns_dnssec_name_find_rrset(const ldns_dnssec_name *name,
ldns_rr_type type);
/**
* \param[in] type the type of the RRset to find
* \return the RRset, or NULL if not present
*/
-ldns_dnssec_rrsets *ldns_dnssec_zone_find_rrset(ldns_dnssec_zone *zone,
- ldns_rdf *dname,
+ldns_dnssec_rrsets *ldns_dnssec_zone_find_rrset(const ldns_dnssec_zone *zone,
+ const ldns_rdf *dname,
ldns_rr_type type);
/**
* \param[in] out the file descriptor to print to
* \param[in] name the name structure to print the contents of
*/
-void ldns_dnssec_name_print(FILE *out, ldns_dnssec_name *name);
+void ldns_dnssec_name_print(FILE *out, const ldns_dnssec_name *name);
/**
* Prints the RRs in the dnssec name structure to the given
* \param[in] name the name structure to print the contents of
*/
void ldns_dnssec_name_print_fmt(FILE *out,
- const ldns_output_format *fmt, ldns_dnssec_name *name);
+ const ldns_output_format *fmt, const ldns_dnssec_name *name);
/**
* Creates a new dnssec_zone structure
* \param[in] tree the tree of ldns_dnssec_name structures to print
* \param[in] print_soa if true, print SOA records, if false, skip them
*/
-void ldns_dnssec_zone_names_print(FILE *out, ldns_rbtree_t *tree, bool print_soa);
+void ldns_dnssec_zone_names_print(FILE *out, const ldns_rbtree_t *tree, bool print_soa);
/**
* Prints the rbtree of ldns_dnssec_name structures to the file descriptor
* \param[in] print_soa if true, print SOA records, if false, skip them
*/
void ldns_dnssec_zone_names_print_fmt(FILE *out, const ldns_output_format *fmt,
- ldns_rbtree_t *tree, bool print_soa);
+ const ldns_rbtree_t *tree, bool print_soa);
/**
* Prints the complete zone to the given file descriptor
* \param[in] out the file descriptor to print to
* \param[in] zone the dnssec_zone to print
*/
-void ldns_dnssec_zone_print(FILE *out, ldns_dnssec_zone *zone);
+void ldns_dnssec_zone_print(FILE *out, const ldns_dnssec_zone *zone);
/**
* Prints the complete zone to the given file descriptor
* \param[in] zone the dnssec_zone to print
*/
void ldns_dnssec_zone_print_fmt(FILE *out,
- const ldns_output_format *fmt, ldns_dnssec_zone *zone);
+ const ldns_output_format *fmt, const ldns_dnssec_zone *zone);
/**
* Adds explicit dnssec_name structures for the empty nonterminals
* \param[in] zone the zone to check for nsec3 optout records
* return true when the zone has at least one nsec3 optout record.
*/
-bool ldns_dnssec_zone_is_nsec3_optout(ldns_dnssec_zone* zone);
+bool ldns_dnssec_zone_is_nsec3_optout(const ldns_dnssec_zone* zone);
#ifdef __cplusplus
}
* \param[in] key the key to get the file name from
* \returns A string containing the file base name
*/
-char *ldns_key_get_file_base_name(ldns_key *key);
+char *ldns_key_get_file_base_name(const ldns_key *key);
/**
* See if a key algorithm is supported
* \param[in] port what port was used. When NULL this is not set
* \return ldns_rdf* wth the address
*/
-ldns_rdf * ldns_sockaddr_storage2rdf(struct sockaddr_storage *sock, uint16_t *port);
+ldns_rdf * ldns_sockaddr_storage2rdf(const struct sockaddr_storage *sock, uint16_t *port);
/**
* Prepares the resolver for an axfr query
* \param[in] c the class to use
* \return ldns_status the status of the transfer
*/
-ldns_status ldns_axfr_start(ldns_resolver *resolver, ldns_rdf *domain, ldns_rr_class c);
+ldns_status ldns_axfr_start(ldns_resolver *resolver, const ldns_rdf *domain, ldns_rr_class c);
#ifdef __cplusplus
}
* \param[in] s the packet's section
* \return a list with the rr's or NULL if none were found
*/
-ldns_rr_list *ldns_pkt_rr_list_by_name(ldns_pkt *p, ldns_rdf *r, ldns_pkt_section s);
+ldns_rr_list *ldns_pkt_rr_list_by_name(const ldns_pkt *p, const ldns_rdf *r, ldns_pkt_section s);
/**
* return all the rr with a specific type from a packet. Optionally
* specify from which section in the packet
* \param[in] sec in which section to look
* \param[in] rr the rr to look for
*/
-bool ldns_pkt_rr(ldns_pkt *pkt, ldns_pkt_section sec, ldns_rr *rr);
+bool ldns_pkt_rr(const ldns_pkt *pkt, ldns_pkt_section sec, const ldns_rr *rr);
/**
* \param[in] p the packet to examine
* \return the type of packet
*/
-ldns_pkt_type ldns_pkt_reply_type(ldns_pkt *p);
+ldns_pkt_type ldns_pkt_reply_type(const ldns_pkt *p);
/**
* return the packet's edns udp size
* \param[in] flags packet flags
* \return ldns_pkt* a pointer to the new pkt
*/
-ldns_pkt *ldns_pkt_query_new(ldns_rdf *rr_name, ldns_rr_type rr_type, ldns_rr_class rr_class, uint16_t flags);
+ldns_pkt *ldns_pkt_query_new(const ldns_rdf *rr_name, ldns_rr_type rr_type, ldns_rr_class rr_class, uint16_t flags);
/**
* creates an IXFR request packet for the given name, type and class.
* \param[in] soa soa record to be added to the authority section
* \return ldns_pkt* a pointer to the new pkt
*/
-ldns_pkt *ldns_pkt_ixfr_request_new(ldns_rdf *rr_name, ldns_rr_class rr_class, uint16_t flags, ldns_rr* soa);
+ldns_pkt *ldns_pkt_ixfr_request_new(const ldns_rdf *rr_name, ldns_rr_class rr_class, uint16_t flags, ldns_rr* soa);
/**
* clones the given packet, creating a fully allocated copy
* @return: unlinked data or NULL if not present.
*
*/
-void* ldns_radix_delete(ldns_radix_t* tree, uint8_t* key, radix_strlen_t len);
+void* ldns_radix_delete(ldns_radix_t* tree, const uint8_t* key, radix_strlen_t len);
/**
* Search data in the tree.
* @return: the radix node or NULL if not found.
*
*/
-ldns_radix_node_t* ldns_radix_search(ldns_radix_t* tree, uint8_t* key,
+ldns_radix_node_t* ldns_radix_search(ldns_radix_t* tree, const uint8_t* key,
radix_strlen_t len);
/**
* @return 1 if exact match, 0 otherwise.
*
*/
-int ldns_radix_find_less_equal(ldns_radix_t* tree, uint8_t* key,
+int ldns_radix_find_less_equal(ldns_radix_t* tree, const uint8_t* key,
radix_strlen_t len, ldns_radix_node_t** result);
/**
* @return: the radix node with the first element.
*
*/
-ldns_radix_node_t* ldns_radix_first(ldns_radix_t* tree);
+ldns_radix_node_t* ldns_radix_first(const ldns_radix_t* tree);
/**
* Get the last element in the tree.
* @return: the radix node with the last element.
*
*/
-ldns_radix_node_t* ldns_radix_last(ldns_radix_t* tree);
+ldns_radix_node_t* ldns_radix_last(const ldns_radix_t* tree);
/**
* Next element.
* @param tree: tree.
*
*/
-void ldns_radix_printf(FILE* fd, ldns_radix_t* tree);
+void ldns_radix_printf(FILE* fd, const ldns_radix_t* tree);
#ifdef __cplusplus
}
* @param rbtree: tree
* @return: smallest element or NULL if tree empty.
*/
-ldns_rbnode_t *ldns_rbtree_first(ldns_rbtree_t *rbtree);
+ldns_rbnode_t *ldns_rbtree_first(const ldns_rbtree_t *rbtree);
/**
* Returns last (largest) node in the tree
* @param rbtree: tree
* @return: largest element or NULL if tree empty.
*/
-ldns_rbnode_t *ldns_rbtree_last(ldns_rbtree_t *rbtree);
+ldns_rbnode_t *ldns_rbtree_last(const ldns_rbtree_t *rbtree);
/**
* Returns next larger node in the tree
* \param[in] n the ip address
* \return ldns_status a status
*/
-ldns_status ldns_resolver_push_nameserver(ldns_resolver *r, ldns_rdf *n);
+ldns_status ldns_resolver_push_nameserver(ldns_resolver *r, const ldns_rdf *n);
/**
* Push a new nameserver to the resolver. It must be an
* \param[in] rr the resource record
* \return ldns_status a status
*/
-ldns_status ldns_resolver_push_nameserver_rr(ldns_resolver *r, ldns_rr *rr);
+ldns_status ldns_resolver_push_nameserver_rr(ldns_resolver *r, const ldns_rr *rr);
/**
* Push a new nameserver rr_list to the resolver.
* \param[in] rrlist the rr_list to push
* \return ldns_status a status
*/
-ldns_status ldns_resolver_push_nameserver_rr_list(ldns_resolver *r, ldns_rr_list *rrlist);
+ldns_status ldns_resolver_push_nameserver_rr_list(ldns_resolver *r, const ldns_rr_list *rrlist);
/**
* Send the query for using the resolver and take the search list into account
* \param[in] right the rightside
* \return a left with right concatenated to it
*/
-bool ldns_rr_list_cat(ldns_rr_list *left, ldns_rr_list *right);
+bool ldns_rr_list_cat(ldns_rr_list *left, const ldns_rr_list *right);
/**
* concatenates two ldns_rr_lists together, but makes clones of the rr's
* \param[in] right the rightside
* \return a new rr_list with leftside/rightside concatenated
*/
-ldns_rr_list* ldns_rr_list_cat_clone(ldns_rr_list *left, ldns_rr_list *right);
+ldns_rr_list* ldns_rr_list_cat_clone(const ldns_rr_list *left, const ldns_rr_list *right);
/**
* pushes an rr to an rrlist.
* \param[in] rr the rr to check
* \return true if rr_list contains rr, false otherwise
*/
-bool ldns_rr_list_contains_rr(const ldns_rr_list *rr_list, ldns_rr *rr);
+bool ldns_rr_list_contains_rr(const ldns_rr_list *rr_list, const ldns_rr *rr);
/**
* checks if an rr_list is a rrset.
* \param[in] rr_list the rr_list to check
* \return true if it is an rrset otherwise false
*/
-bool ldns_is_rrset(ldns_rr_list *rr_list);
+bool ldns_is_rrset(const ldns_rr_list *rr_list);
/**
* pushes an rr to an rrset (which really are rr_list's).
* -1 if rr1_buf comes before rr2_buf
* +1 if rr2_buf comes before rr1_buf
*/
-int ldns_rr_compare_wire(ldns_buffer *rr1_buf, ldns_buffer *rr2_buf);
+int ldns_rr_compare_wire(const ldns_buffer *rr1_buf, const ldns_buffer *rr2_buf);
/**
* returns true of the given rr's are equal.
* \param[in] rr_list the rr_list to work on
* \return void
*/
-void ldns_rr_list2canonical(ldns_rr_list *rr_list);
+void ldns_rr_list2canonical(const ldns_rr_list *rr_list);
/**
* counts the number of labels of the ownername.
* \param[in] rr count the labels of this rr
* \return the number of labels
*/
-uint8_t ldns_rr_label_count(ldns_rr *rr);
+uint8_t ldns_rr_label_count(const ldns_rr *rr);
/**
* returns the resource record descriptor for the given rr type.
* \return a new rr list with only the RRs that match
*
*/
-ldns_rr_list *ldns_rr_list_subtype_by_rdf(ldns_rr_list *l, ldns_rdf *r, size_t pos);
+ldns_rr_list *ldns_rr_list_subtype_by_rdf(const ldns_rr_list *l, const ldns_rdf *r, size_t pos);
/**
* convert an rdf of type LDNS_RDF_TYPE_TYPE to an actual
/* XXX More eventually. */
} ldns_tsig_credentials;
-char *ldns_tsig_algorithm(ldns_tsig_credentials *);
-char *ldns_tsig_keyname(ldns_tsig_credentials *);
-char *ldns_tsig_keydata(ldns_tsig_credentials *);
-char *ldns_tsig_keyname_clone(ldns_tsig_credentials *);
-char *ldns_tsig_keydata_clone(ldns_tsig_credentials *);
+char *ldns_tsig_algorithm(const ldns_tsig_credentials *);
+char *ldns_tsig_keyname(const ldns_tsig_credentials *);
+char *ldns_tsig_keydata(const ldns_tsig_credentials *);
+char *ldns_tsig_keyname_clone(const ldns_tsig_credentials *);
+char *ldns_tsig_keydata_clone(const ldns_tsig_credentials *);
/**
* verifies the tsig rr for the given packet and key.
* \param[in] mac original mac
* \return true if tsig is correct, false if not, or if tsig is not set
*/
-bool ldns_pkt_tsig_verify(ldns_pkt *pkt, uint8_t *wire, size_t wire_size, const char *key_name, const char *key_data, ldns_rdf *mac);
+bool ldns_pkt_tsig_verify(ldns_pkt *pkt, const uint8_t *wire, size_t wire_size, const char *key_name, const char *key_data, const ldns_rdf *mac);
/**
* verifies the tsig rr for the given packet and key.
components are used to verify the _mac. If non-zero, only the TSIG timers are used to verify the mac.
* \return true if tsig is correct, false if not, or if tsig is not set
*/
-bool ldns_pkt_tsig_verify_next(ldns_pkt *pkt, uint8_t *wire, size_t wire_size, const char *key_name, const char *key_data, ldns_rdf *mac,
+bool ldns_pkt_tsig_verify_next(ldns_pkt *pkt, const uint8_t *wire, size_t wire_size, const char *key_name, const char *key_data, const ldns_rdf *mac,
int tsig_timers_only);
/**
* \return status (OK if success)
*/
ldns_status ldns_pkt_tsig_sign(ldns_pkt *pkt, const char *key_name, const char *key_data, uint16_t fudge,
- const char *algorithm_name, ldns_rdf *query_mac);
+ const char *algorithm_name, const ldns_rdf *query_mac);
/**
* creates a tsig rr for the given packet and key.
* \return status (OK if success)
*/
ldns_status ldns_pkt_tsig_sign_next(ldns_pkt *pkt, const char *key_name, const char *key_data, uint16_t fudge,
- const char *algorithm_name, ldns_rdf *query_mac, int tsig_timers_only);
+ const char *algorithm_name, const ldns_rdf *query_mac, int tsig_timers_only);
#ifdef __cplusplus
}
* \param[in] ad_rrlist list of Additional Data Section RRs (currently unused)
* \return the new packet
*/
-ldns_pkt *ldns_update_pkt_new(ldns_rdf *zone_rdf, ldns_rr_class clas, ldns_rr_list *pr_rrlist, ldns_rr_list *up_rrlist, ldns_rr_list *ad_rrlist);
+ldns_pkt *ldns_update_pkt_new(const ldns_rdf *zone_rdf, ldns_rr_class clas, const ldns_rr_list *pr_rrlist, const ldns_rr_list *up_rrlist, const ldns_rr_list *ad_rrlist);
/**
* add tsig credentials to
*
* \return status wether successfull or not
*/
-ldns_status ldns_update_pkt_tsig_add(ldns_pkt *p, ldns_resolver *r);
+ldns_status ldns_update_pkt_tsig_add(ldns_pkt *p, const ldns_resolver *r);
/* access functions */
ldns_status ldns_wire2pkt(ldns_pkt **packet, const uint8_t *data, size_t len);
/**
- * converts the data on the uint8_t bytearray (in wire format) to a DNS packet.
+ * converts the data in the ldns_buffer (in wire format) to a DNS packet.
* This function will initialize and allocate memory space for the packet
* structure.
*
* \param[in] buffer the buffer with the data
* \return LDNS_STATUS_OK if everything succeeds, error otherwise
*/
-ldns_status ldns_buffer2pkt_wire(ldns_pkt **packet, ldns_buffer *buffer);
+ldns_status ldns_buffer2pkt_wire(ldns_pkt **packet, const ldns_buffer *buffer);
/**
* converts the data on the uint8_t bytearray (in wire format) to a DNS
* \param[in] list the list to add
* \return a true on succes otherwise falsed
*/
-bool ldns_zone_push_rr_list(ldns_zone *z, ldns_rr_list *list);
+bool ldns_zone_push_rr_list(ldns_zone *z, const ldns_rr_list *list);
/**
* push an single rr to a zone structure. This function use pointer
#ifndef S_SPLINT_S
ldns_rdf *
-ldns_sockaddr_storage2rdf(struct sockaddr_storage *sock, uint16_t *port)
+ldns_sockaddr_storage2rdf(const struct sockaddr_storage *sock, uint16_t *port)
{
ldns_rdf *addr;
struct sockaddr_in *data_in;
/* code from resolver.c */
ldns_status
-ldns_axfr_start(ldns_resolver *resolver, ldns_rdf *domain, ldns_rr_class class)
+ldns_axfr_start(ldns_resolver *resolver, const ldns_rdf *domain, ldns_rr_class class)
{
ldns_pkt *query;
ldns_buffer *query_wire;
/* return only those rr that share the ownername */
ldns_rr_list *
-ldns_pkt_rr_list_by_name(ldns_pkt *packet,
- ldns_rdf *ownername,
+ldns_pkt_rr_list_by_name(const ldns_pkt *packet,
+ const ldns_rdf *ownername,
ldns_pkt_section sec)
{
ldns_rr_list *rrs;
}
bool
-ldns_pkt_rr(ldns_pkt *pkt, ldns_pkt_section sec, ldns_rr *rr)
+ldns_pkt_rr(const ldns_pkt *pkt, ldns_pkt_section sec, const ldns_rr *rr)
{
bool result = false;
static ldns_rr*
-ldns_pkt_authsoa(ldns_rdf* rr_name, ldns_rr_class rr_class)
+ldns_pkt_authsoa(const ldns_rdf* rr_name, ldns_rr_class rr_class)
{
ldns_rr* soa_rr = ldns_rr_new();
ldns_rdf *owner_rdf;
}
static ldns_pkt *
-ldns_pkt_query_new_internal(ldns_rdf *rr_name, ldns_rr_type rr_type,
+ldns_pkt_query_new_internal(const ldns_rdf *rr_name, ldns_rr_type rr_type,
ldns_rr_class rr_class, uint16_t flags, ldns_rr* authsoa_rr)
{
ldns_pkt *packet;
rr_class = LDNS_RR_CLASS_IN;
}
- ldns_rr_set_owner(question_rr, rr_name);
+ ldns_rr_set_owner(question_rr, ldns_rdf_clone(rr_name));
ldns_rr_set_type(question_rr, rr_type);
ldns_rr_set_class(question_rr, rr_class);
ldns_rr_set_question(question_rr, true);
}
ldns_pkt *
-ldns_pkt_query_new(ldns_rdf *rr_name, ldns_rr_type rr_type,
+ldns_pkt_query_new(const ldns_rdf *rr_name, ldns_rr_type rr_type,
ldns_rr_class rr_class, uint16_t flags)
{
return ldns_pkt_query_new_internal(rr_name, rr_type,
}
ldns_pkt *
-ldns_pkt_ixfr_request_new(ldns_rdf *rr_name, ldns_rr_class rr_class,
+ldns_pkt_ixfr_request_new(const ldns_rdf *rr_name, ldns_rr_class rr_class,
uint16_t flags, ldns_rr* soa)
{
ldns_rr* authsoa_rr = soa;
}
ldns_pkt_type
-ldns_pkt_reply_type(ldns_pkt *p)
+ldns_pkt_reply_type(const ldns_pkt *p)
{
ldns_rr_list *tmp;
* Delete data from the tree.
*
*/
-void* ldns_radix_delete(ldns_radix_t* tree, uint8_t* key, radix_strlen_t len)
+void* ldns_radix_delete(ldns_radix_t* tree, const uint8_t* key, radix_strlen_t len)
{
ldns_radix_node_t* del = ldns_radix_search(tree, key, len);
void* data = NULL;
*
*/
ldns_radix_node_t*
-ldns_radix_search(ldns_radix_t* tree, uint8_t* key, radix_strlen_t len)
+ldns_radix_search(ldns_radix_t* tree, const uint8_t* key, radix_strlen_t len)
{
ldns_radix_node_t* node = NULL;
radix_strlen_t pos = 0;
*
*/
int
-ldns_radix_find_less_equal(ldns_radix_t* tree, uint8_t* key,
+ldns_radix_find_less_equal(ldns_radix_t* tree, const uint8_t* key,
radix_strlen_t len, ldns_radix_node_t** result)
{
ldns_radix_node_t* node = NULL;
*
*/
ldns_radix_node_t*
-ldns_radix_first(ldns_radix_t* tree)
+ldns_radix_first(const ldns_radix_t* tree)
{
ldns_radix_node_t* first = NULL;
if (!tree || !tree->root) {
*
*/
ldns_radix_node_t*
-ldns_radix_last(ldns_radix_t* tree)
+ldns_radix_last(const ldns_radix_t* tree)
{
if (!tree || !tree->root) {
return NULL;
*
*/
void
-ldns_radix_printf(FILE* fd, ldns_radix_t* tree)
+ldns_radix_printf(FILE* fd, const ldns_radix_t* tree)
{
if (!fd || !tree) {
return;
*
*/
ldns_rbnode_t *
-ldns_rbtree_first (ldns_rbtree_t *rbtree)
+ldns_rbtree_first(const ldns_rbtree_t *rbtree)
{
ldns_rbnode_t *node = rbtree->root;
}
ldns_rbnode_t *
-ldns_rbtree_last (ldns_rbtree_t *rbtree)
+ldns_rbtree_last(const ldns_rbtree_t *rbtree)
{
ldns_rbnode_t *node = rbtree->root;
*
*/
ldns_rbnode_t *
-ldns_rbtree_next (ldns_rbnode_t *node)
+ldns_rbtree_next(ldns_rbnode_t *node)
{
ldns_rbnode_t *parent;
}
ldns_status
-ldns_resolver_push_nameserver(ldns_resolver *r, ldns_rdf *n)
+ldns_resolver_push_nameserver(ldns_resolver *r, const ldns_rdf *n)
{
ldns_rdf **nameservers;
size_t ns_count;
}
ldns_status
-ldns_resolver_push_nameserver_rr(ldns_resolver *r, ldns_rr *rr)
+ldns_resolver_push_nameserver_rr(ldns_resolver *r, const ldns_rr *rr)
{
ldns_rdf *address;
if ((!rr) || (ldns_rr_get_type(rr) != LDNS_RR_TYPE_A &&
}
ldns_status
-ldns_resolver_push_nameserver_rr_list(ldns_resolver *r, ldns_rr_list *rrlist)
+ldns_resolver_push_nameserver_rr_list(ldns_resolver *r, const ldns_rr_list *rrlist)
{
ldns_rr *rr;
ldns_status stat;
/* add right to left. So we modify *left! */
bool
-ldns_rr_list_cat(ldns_rr_list *left, ldns_rr_list *right)
+ldns_rr_list_cat(ldns_rr_list *left, const ldns_rr_list *right)
{
size_t r_rr_count;
size_t i;
}
ldns_rr_list *
-ldns_rr_list_cat_clone(ldns_rr_list *left, ldns_rr_list *right)
+ldns_rr_list_cat_clone(const ldns_rr_list *left, const ldns_rr_list *right)
{
size_t l_rr_count;
size_t r_rr_count;
}
ldns_rr_list *
-ldns_rr_list_subtype_by_rdf(ldns_rr_list *l, ldns_rdf *r, size_t pos)
+ldns_rr_list_subtype_by_rdf(const ldns_rr_list *l, const ldns_rdf *r, size_t pos)
{
size_t i;
ldns_rr_list *subtyped;
bool
-ldns_rr_list_contains_rr(const ldns_rr_list *rr_list, ldns_rr *rr)
+ldns_rr_list_contains_rr(const ldns_rr_list *rr_list, const ldns_rr *rr)
{
size_t i;
}
bool
-ldns_is_rrset(ldns_rr_list *rr_list)
+ldns_is_rrset(const ldns_rr_list *rr_list)
{
ldns_rr_type t;
ldns_rr_class c;
return 0;
}
-int ldns_rr_compare_wire(ldns_buffer *rr1_buf, ldns_buffer *rr2_buf)
+int ldns_rr_compare_wire(const ldns_buffer *rr1_buf, const ldns_buffer *rr2_buf)
{
size_t rr1_len, rr2_len, min_len, i, offset;
}
void
-ldns_rr_list2canonical(ldns_rr_list *rr_list)
+ldns_rr_list2canonical(const ldns_rr_list *rr_list)
{
size_t i;
for (i = 0; i < ldns_rr_list_rr_count(rr_list); i++) {
}
uint8_t
-ldns_rr_label_count(ldns_rr *rr)
+ldns_rr_label_count(const ldns_rr *rr)
{
if (!rr) {
return 0;
#endif /* HAVE_SSL */
char *
-ldns_tsig_algorithm(ldns_tsig_credentials *tc)
+ldns_tsig_algorithm(const ldns_tsig_credentials *tc)
{
return tc->algorithm;
}
char *
-ldns_tsig_keyname(ldns_tsig_credentials *tc)
+ldns_tsig_keyname(const ldns_tsig_credentials *tc)
{
return tc->keyname;
}
char *
-ldns_tsig_keydata(ldns_tsig_credentials *tc)
+ldns_tsig_keydata(const ldns_tsig_credentials *tc)
{
return tc->keydata;
}
char *
-ldns_tsig_keyname_clone(ldns_tsig_credentials *tc)
+ldns_tsig_keyname_clone(const ldns_tsig_credentials *tc)
{
return strdup(tc->keyname);
}
char *
-ldns_tsig_keydata_clone(ldns_tsig_credentials *tc)
+ldns_tsig_keydata_clone(const ldns_tsig_credentials *tc)
{
return strdup(tc->keydata);
}
* Makes an exact copy of the wire, but with the tsig rr removed
*/
static uint8_t *
-ldns_tsig_prepare_pkt_wire(uint8_t *wire, size_t wire_len, size_t *result_len)
+ldns_tsig_prepare_pkt_wire(const uint8_t *wire, size_t wire_len, size_t *result_len)
{
uint8_t *wire2 = NULL;
uint16_t qd_count;
#ifdef HAVE_SSL
static ldns_status
-ldns_tsig_mac_new(ldns_rdf **tsig_mac, uint8_t *pkt_wire, size_t pkt_wire_size,
- const char *key_data, ldns_rdf *key_name_rdf, ldns_rdf *fudge_rdf,
- ldns_rdf *algorithm_rdf, ldns_rdf *time_signed_rdf, ldns_rdf *error_rdf,
- ldns_rdf *other_data_rdf, ldns_rdf *orig_mac_rdf, int tsig_timers_only)
+ldns_tsig_mac_new(ldns_rdf **tsig_mac, const uint8_t *pkt_wire, size_t pkt_wire_size,
+ const char *key_data, const ldns_rdf *key_name_rdf, const ldns_rdf *fudge_rdf,
+ const ldns_rdf *algorithm_rdf, const ldns_rdf *time_signed_rdf, const ldns_rdf *error_rdf,
+ const ldns_rdf *other_data_rdf, const ldns_rdf *orig_mac_rdf, int tsig_timers_only)
{
ldns_status status;
char *wireformat;
#ifdef HAVE_SSL
bool
-ldns_pkt_tsig_verify(ldns_pkt *pkt, uint8_t *wire, size_t wirelen, const char *key_name,
- const char *key_data, ldns_rdf *orig_mac_rdf)
+ldns_pkt_tsig_verify(ldns_pkt *pkt, const uint8_t *wire, size_t wirelen, const char *key_name,
+ const char *key_data, const ldns_rdf *orig_mac_rdf)
{
return ldns_pkt_tsig_verify_next(pkt, wire, wirelen, key_name, key_data, orig_mac_rdf, 0);
}
bool
-ldns_pkt_tsig_verify_next(ldns_pkt *pkt, uint8_t *wire, size_t wirelen, const char* key_name,
- const char *key_data, ldns_rdf *orig_mac_rdf, int tsig_timers_only)
+ldns_pkt_tsig_verify_next(ldns_pkt *pkt, const uint8_t *wire, size_t wirelen, const char* key_name,
+ const char *key_data, const ldns_rdf *orig_mac_rdf, int tsig_timers_only)
{
ldns_rdf *fudge_rdf;
ldns_rdf *algorithm_rdf;
#ifdef HAVE_SSL
ldns_status
ldns_pkt_tsig_sign(ldns_pkt *pkt, const char *key_name, const char *key_data,
- uint16_t fudge, const char *algorithm_name, ldns_rdf *query_mac)
+ uint16_t fudge, const char *algorithm_name, const ldns_rdf *query_mac)
{
return ldns_pkt_tsig_sign_next(pkt, key_name, key_data, fudge, algorithm_name, query_mac, 0);
}
ldns_status
ldns_pkt_tsig_sign_next(ldns_pkt *pkt, const char *key_name, const char *key_data,
- uint16_t fudge, const char *algorithm_name, ldns_rdf *query_mac, int tsig_timers_only)
+ uint16_t fudge, const char *algorithm_name, const ldns_rdf *query_mac, int tsig_timers_only)
{
ldns_rr *tsig_rr;
ldns_rdf *key_name_rdf = ldns_rdf_new_frm_str(LDNS_RDF_TYPE_DNAME, key_name);
*/
ldns_pkt *
-ldns_update_pkt_new(ldns_rdf *zone_rdf, ldns_rr_class c,
- ldns_rr_list *pr_rrlist, ldns_rr_list *up_rrlist, ldns_rr_list *ad_rrlist)
+ldns_update_pkt_new(const ldns_rdf *zone_rdf, ldns_rr_class c,
+ const ldns_rr_list *pr_rrlist, const ldns_rr_list *up_rrlist, const ldns_rr_list *ad_rrlist)
{
ldns_pkt *p;
}
ldns_status
-ldns_update_pkt_tsig_add(ldns_pkt *p, ldns_resolver *r)
+ldns_update_pkt_tsig_add(ldns_pkt *p, const ldns_resolver *r)
{
#ifdef HAVE_SSL
uint16_t fudge = 300; /* Recommended fudge. [RFC2845 6.4] */
}
ldns_status
-ldns_buffer2pkt_wire(ldns_pkt **packet, ldns_buffer *buffer)
+ldns_buffer2pkt_wire(ldns_pkt **packet, const ldns_buffer *buffer)
{
/* lazy */
return ldns_wire2pkt(packet, ldns_buffer_begin(buffer),
}
bool
-ldns_zone_push_rr_list(ldns_zone *z, ldns_rr_list *list)
+ldns_zone_push_rr_list(ldns_zone *z, const ldns_rr_list *list)
{
return ldns_rr_list_cat(ldns_zone_rrs(z), list);
-
}
bool
ldns_zone_push_rr(ldns_zone *z, ldns_rr *rr)
{
- return ldns_rr_list_push_rr( ldns_zone_rrs(z), rr);
+ return ldns_rr_list_push_rr(ldns_zone_rrs(z), rr);
}
projects / thirdparty / ldns.git / commitdiff
