o refactor ldns_verify_rrsig_keylist and
ldns_verify_rrsig (fold in TSIG stuff or leave it out?)
o Different digest for DS (spec currently specifies SHA-1)
+ o zone.c; make it better/faster??
+ o SHA256 test in configure.ac
Minor:
------
o Check RedHat 9 Compile problem
+ o lua bindings?
1.1.0:
o API cleanup: add missing consts in function arguments
o vim syntax
o walker
- o zone.c; make it better/faster??
- o SHA256 test in configure.ac
DONE:
1.0.1 released 5 January 2006
/* used only on the public key RR */
uint16_t
-ldns_calc_keytag(ldns_rr *key)
+ldns_calc_keytag(const ldns_rr *key)
{
unsigned int i;
uint32_t ac32;
/* do NOT pass compressed data here :p */
ldns_status
-ldns_rdf2buffer_str_dname(ldns_buffer *output, ldns_rdf *dname)
+ldns_rdf2buffer_str_dname(ldns_buffer *output, const ldns_rdf *dname)
{
/* can we do with 1 pos var? or without at all? */
uint8_t src_pos = 0;
}
ldns_status
-ldns_rdf2buffer_str_int8(ldns_buffer *output, ldns_rdf *rdf)
+ldns_rdf2buffer_str_int8(ldns_buffer *output, const ldns_rdf *rdf)
{
uint8_t data = ldns_rdf_data(rdf)[0];
ldns_buffer_printf(output, "%lu", (unsigned long) data);
}
ldns_status
-ldns_rdf2buffer_str_int16(ldns_buffer *output, ldns_rdf *rdf)
+ldns_rdf2buffer_str_int16(ldns_buffer *output, const ldns_rdf *rdf)
{
uint16_t data = ldns_read_uint16(ldns_rdf_data(rdf));
ldns_buffer_printf(output, "%lu", (unsigned long) data);
}
ldns_status
-ldns_rdf2buffer_str_int32(ldns_buffer *output, ldns_rdf *rdf)
+ldns_rdf2buffer_str_int32(ldns_buffer *output, const ldns_rdf *rdf)
{
uint32_t data = ldns_read_uint32(ldns_rdf_data(rdf));
ldns_buffer_printf(output, "%lu", (unsigned long) data);
}
ldns_status
-ldns_rdf2buffer_str_time(ldns_buffer *output, ldns_rdf *rdf)
+ldns_rdf2buffer_str_time(ldns_buffer *output, const ldns_rdf *rdf)
{
/* create a YYYYMMDDHHMMSS string if possible */
uint32_t data = ldns_read_uint32(ldns_rdf_data(rdf));
}
ldns_status
-ldns_rdf2buffer_str_a(ldns_buffer *output, ldns_rdf *rdf)
+ldns_rdf2buffer_str_a(ldns_buffer *output, const ldns_rdf *rdf)
{
char str[INET_ADDRSTRLEN];
}
ldns_status
-ldns_rdf2buffer_str_aaaa(ldns_buffer *output, ldns_rdf *rdf)
+ldns_rdf2buffer_str_aaaa(ldns_buffer *output, const ldns_rdf *rdf)
{
char str[INET6_ADDRSTRLEN];
}
ldns_status
-ldns_rdf2buffer_str_str(ldns_buffer *output, ldns_rdf *rdf)
+ldns_rdf2buffer_str_str(ldns_buffer *output, const ldns_rdf *rdf)
{
const uint8_t *data = ldns_rdf_data(rdf);
uint8_t length = data[0];
}
ldns_status
-ldns_rdf2buffer_str_b64(ldns_buffer *output, ldns_rdf *rdf)
+ldns_rdf2buffer_str_b64(ldns_buffer *output, const ldns_rdf *rdf)
{
size_t size = b64_ntop_calculate_size(ldns_rdf_size(rdf));
char *b64 = LDNS_XMALLOC(char, size);
}
ldns_status
-ldns_rdf2buffer_str_hex(ldns_buffer *output, ldns_rdf *rdf)
+ldns_rdf2buffer_str_hex(ldns_buffer *output, const ldns_rdf *rdf)
{
size_t i;
for (i = 0; i < ldns_rdf_size(rdf); i++) {
}
ldns_status
-ldns_rdf2buffer_str_type(ldns_buffer *output, ldns_rdf *rdf)
+ldns_rdf2buffer_str_type(ldns_buffer *output, const ldns_rdf *rdf)
{
uint16_t data = ldns_read_uint16(ldns_rdf_data(rdf));
const ldns_rr_descriptor *descriptor;
}
ldns_status
-ldns_rdf2buffer_str_class(ldns_buffer *output, ldns_rdf *rdf)
+ldns_rdf2buffer_str_class(ldns_buffer *output, const ldns_rdf *rdf)
{
uint8_t data = ldns_rdf_data(rdf)[0];
ldns_lookup_table *lt;
}
ldns_status
-ldns_rdf2buffer_str_cert_alg(ldns_buffer *output, ldns_rdf *rdf)
+ldns_rdf2buffer_str_cert_alg(ldns_buffer *output, const ldns_rdf *rdf)
{
uint8_t data = ldns_rdf_data(rdf)[0];
ldns_lookup_table *lt;
}
ldns_status
-ldns_rdf2buffer_str_alg(ldns_buffer *output, ldns_rdf *rdf)
+ldns_rdf2buffer_str_alg(ldns_buffer *output, const ldns_rdf *rdf)
{
uint8_t data = ldns_rdf_data(rdf)[0];
ldns_lookup_table *lt;
}
ldns_status
-ldns_rdf2buffer_str_loc(ldns_buffer *output, ldns_rdf *rdf)
+ldns_rdf2buffer_str_loc(ldns_buffer *output, const ldns_rdf *rdf)
{
/* we could do checking (ie degrees < 90 etc)? */
uint8_t version = ldns_rdf_data(rdf)[0];
}
ldns_status
-ldns_rdf2buffer_str_unknown(ldns_buffer *output, ldns_rdf *rdf)
+ldns_rdf2buffer_str_unknown(ldns_buffer *output, const ldns_rdf *rdf)
{
ldns_buffer_printf(output, "\\# %u ", ldns_rdf_size(rdf));
return ldns_rdf2buffer_str_hex(output, rdf);
}
ldns_status
-ldns_rdf2buffer_str_nsap(ldns_buffer *output, ldns_rdf *rdf)
+ldns_rdf2buffer_str_nsap(ldns_buffer *output, const ldns_rdf *rdf)
{
ldns_buffer_printf(output, "0x");
return ldns_rdf2buffer_str_hex(output, rdf);
}
ldns_status
-ldns_rdf2buffer_str_wks(ldns_buffer *output, ldns_rdf *rdf)
+ldns_rdf2buffer_str_wks(ldns_buffer *output, const ldns_rdf *rdf)
{
/* protocol, followed by bitmap of services */
struct protoent *protocol;
}
ldns_status
-ldns_rdf2buffer_str_nsec(ldns_buffer *output, ldns_rdf *rdf)
+ldns_rdf2buffer_str_nsec(ldns_buffer *output, const ldns_rdf *rdf)
{
/* Note: this code is duplicated in higher.c in
* ldns_nsec_type_check() function
}
ldns_status
-ldns_rdf2buffer_str_period(ldns_buffer *output, ldns_rdf *rdf)
+ldns_rdf2buffer_str_period(ldns_buffer *output, const ldns_rdf *rdf)
{
/* period is the number of seconds */
uint32_t p = ldns_read_uint32(ldns_rdf_data(rdf));
}
ldns_status
-ldns_rdf2buffer_str_tsigtime(ldns_buffer *output, ldns_rdf *rdf)
+ldns_rdf2buffer_str_tsigtime(ldns_buffer *output,const ldns_rdf *rdf)
{
/* tsigtime is 48 bits network order unsigned integer */
uint64_t tsigtime = 0;
}
ldns_status
-ldns_rdf2buffer_str_apl(ldns_buffer *output, ldns_rdf *rdf)
+ldns_rdf2buffer_str_apl(ldns_buffer *output, const ldns_rdf *rdf)
{
uint8_t *data = ldns_rdf_data(rdf);
uint16_t address_family = ldns_read_uint16(data);
}
ldns_status
-ldns_rdf2buffer_str_int16_data(ldns_buffer *output, ldns_rdf *rdf)
+ldns_rdf2buffer_str_int16_data(ldns_buffer *output, const ldns_rdf *rdf)
{
/* Subtract the size (2) of the number that specifies the length */
size_t size = b64_ntop_calculate_size(ldns_rdf_size(rdf) - 2);
char *b64 = LDNS_XMALLOC(char, size);
- ldns_buffer_printf(output, "%u ", ldns_rdf_size(rdf)-2);
+ ldns_buffer_printf(output, "%u ", ldns_rdf_size(rdf) - 2);
if (ldns_rdf_size(rdf) > 2 &&
- b64_ntop(ldns_rdf_data(rdf)+2, ldns_rdf_size(rdf)-2, b64, size)) {
+ b64_ntop(ldns_rdf_data(rdf) + 2, ldns_rdf_size(rdf) - 2, b64, size)) {
ldns_buffer_printf(output, "%s", b64);
}
LDNS_FREE(b64);
}
ldns_status
-ldns_rdf2buffer_str_ipseckey(ldns_buffer *output, ldns_rdf *rdf)
+ldns_rdf2buffer_str_ipseckey(ldns_buffer *output, const ldns_rdf *rdf)
{
/* wire format from
http://www.ietf.org/internet-drafts/draft-ietf-ipseckey-rr-12.txt
}
ldns_status
-ldns_rdf2buffer_str_tsig(ldns_buffer *output, ldns_rdf *rdf)
+ldns_rdf2buffer_str_tsig(ldns_buffer *output, const ldns_rdf *rdf)
{
/* TSIG RRs have no presentation format, make them #size <data> */
return ldns_rdf2buffer_str_unknown(output, rdf);
ldns_status
-ldns_rdf2buffer_str(ldns_buffer *buffer, ldns_rdf *rdf)
+ldns_rdf2buffer_str(ldns_buffer *buffer, const ldns_rdf *rdf)
{
ldns_status res;
}
ldns_status
-ldns_rr2buffer_str(ldns_buffer *output, ldns_rr *rr)
+ldns_rr2buffer_str(ldns_buffer *output, const ldns_rr *rr)
{
uint16_t i;
ldns_status status = LDNS_STATUS_OK;
}
ldns_status
-ldns_rr_list2buffer_str(ldns_buffer *output, ldns_rr_list *list)
+ldns_rr_list2buffer_str(ldns_buffer *output, const ldns_rr_list *list)
{
uint16_t i;
}
ldns_status
-ldns_pktheader2buffer_str(ldns_buffer *output, ldns_pkt *pkt)
+ldns_pktheader2buffer_str(ldns_buffer *output, const ldns_pkt *pkt)
{
ldns_lookup_table *opcode = ldns_lookup_by_id(ldns_opcodes,
(int) ldns_pkt_get_opcode(pkt));
}
ldns_status
-ldns_pkt2buffer_str(ldns_buffer *output, ldns_pkt *pkt)
+ldns_pkt2buffer_str(ldns_buffer *output, const ldns_pkt *pkt)
{
uint16_t i;
ldns_status status = LDNS_STATUS_OK;
}
ldns_status
-ldns_key2buffer_str(ldns_buffer *output, ldns_key *k)
+ldns_key2buffer_str(ldns_buffer *output, const ldns_key *k)
{
ldns_status status = LDNS_STATUS_OK;
unsigned char *bignum;
}
char *
-ldns_rdf2str(ldns_rdf *rdf)
+ldns_rdf2str(const ldns_rdf *rdf)
{
char *result = NULL;
ldns_buffer *tmp_buffer = ldns_buffer_new(LDNS_MIN_BUFLEN);
}
char *
-ldns_rr2str(ldns_rr *rr)
+ldns_rr2str(const ldns_rr *rr)
{
char *result = NULL;
ldns_buffer *tmp_buffer = ldns_buffer_new(LDNS_MIN_BUFLEN);
}
char *
-ldns_pkt2str(ldns_pkt *pkt)
+ldns_pkt2str(const ldns_pkt *pkt)
{
char *result = NULL;
ldns_buffer *tmp_buffer = ldns_buffer_new(LDNS_MIN_BUFLEN);
}
char *
-ldns_key2str(ldns_key *k)
+ldns_key2str(const ldns_key *k)
{
char *result = NULL;
ldns_buffer *tmp_buffer = ldns_buffer_new(LDNS_MIN_BUFLEN);
}
char *
-ldns_rr_list2str(ldns_rr_list *list)
+ldns_rr_list2str(const ldns_rr_list *list)
{
char *result = NULL;
ldns_buffer *tmp_buffer = ldns_buffer_new(LDNS_MIN_BUFLEN);
}
void
-ldns_rdf_print(FILE *output, ldns_rdf *rdf)
+ldns_rdf_print(FILE *output, const ldns_rdf *rdf)
{
char *str = ldns_rdf2str(rdf);
if (str) {
}
void
-ldns_rr_print(FILE *output, ldns_rr *rr)
+ldns_rr_print(FILE *output, const ldns_rr *rr)
{
char *str = ldns_rr2str(rr);
if (str) {
}
void
-ldns_pkt_print(FILE *output, ldns_pkt *pkt)
+ldns_pkt_print(FILE *output, const ldns_pkt *pkt)
{
char *str = ldns_pkt2str(pkt);
if (str) {
}
void
-ldns_rr_list_print(FILE *output, ldns_rr_list *lst)
+ldns_rr_list_print(FILE *output, const ldns_rr_list *lst)
{
char *str = ldns_rr_list2str(lst);
if (str) {
}
void
-ldns_resolver_print(FILE *output, ldns_resolver *r)
+ldns_resolver_print(FILE *output, const ldns_resolver *r)
{
uint16_t i;
ldns_rdf **n;
}
void
-ldns_zone_print(FILE *output, ldns_zone *z)
+ldns_zone_print(FILE *output, const ldns_zone *z)
{
ldns_rr_print(output, ldns_zone_soa(z));
ldns_rr_list_print(output, ldns_zone_rrs(z));
*/
ldns_status
-ldns_dname2buffer_wire(ldns_buffer *buffer, ldns_rdf *name)
+ldns_dname2buffer_wire(ldns_buffer *buffer, const ldns_rdf *name)
{
if (ldns_buffer_reserve(buffer, ldns_rdf_size(name))) {
ldns_buffer_write(buffer,
/* convert a rr list to wireformat */
ldns_status
-ldns_rr_list2buffer_wire(ldns_buffer *buffer, ldns_rr_list *rr_list)
+ldns_rr_list2buffer_wire(ldns_buffer *buffer,const ldns_rr_list *rr_list)
{
uint16_t rr_count;
uint16_t i;
}
ldns_status
-ldns_rrsig2buffer_wire(ldns_buffer *buffer, ldns_rr *rr)
+ldns_rrsig2buffer_wire(ldns_buffer *buffer, const ldns_rr *rr)
{
uint16_t i;
}
ldns_status
-ldns_rr_rdata2buffer_wire(ldns_buffer *buffer, ldns_rr *rr)
+ldns_rr_rdata2buffer_wire(ldns_buffer *buffer, const ldns_rr *rr)
{
uint16_t i;
-#if 0
- if (ldns_rr_owner(rr)) {
- (void) ldns_dname2buffer_wire(buffer, ldns_rr_owner(rr));
- }
-
- if (ldns_buffer_reserve(buffer, 4)) {
- (void) ldns_buffer_write_u16(buffer, ldns_rr_get_type(rr));
- (void) ldns_buffer_write_u16(buffer, ldns_rr_get_class(rr));
- }
-
- if (ldns_buffer_reserve(buffer, 6)) {
- ldns_buffer_write_u32(buffer, ldns_rr_ttl(rr));
- /* remember pos for later */
- rdl_pos = ldns_buffer_position(buffer);
- ldns_buffer_write_u16(buffer, 0);
- }
-#endif
-
- /* convert all the rdf */
+ /* convert all the rdf's */
for (i = 0; i < ldns_rr_rd_count(rr); i++) {
(void) ldns_rdf2buffer_wire(buffer, ldns_rr_rdf(rr, i));
}
ldns_buffer_free(buffer);
return status;
}
-
}
void
-ldns_key_print(FILE *output, ldns_key *k)
+ldns_key_print(FILE *output, const ldns_key *k)
{
char *str = ldns_key2str(k);
if (str) {
/* read */
size_t
-ldns_key_list_key_count(ldns_key_list *key_list)
+ldns_key_list_key_count(const ldns_key_list *key_list)
{
return key_list->_key_count;
}
ldns_key *
-ldns_key_list_key(ldns_key_list *key, size_t nr)
+ldns_key_list_key(const ldns_key_list *key, size_t nr)
{
if (nr < ldns_key_list_key_count(key)) {
return key->_keys[nr];
}
ldns_signing_algorithm
-ldns_key_algorithm(ldns_key *k)
+ldns_key_algorithm(const ldns_key *k)
{
return k->_alg;
}
RSA *
-ldns_key_rsa_key(ldns_key *k)
+ldns_key_rsa_key(const ldns_key *k)
{
return k->_key.rsa;
}
DSA *
-ldns_key_dsa_key(ldns_key *k)
+ldns_key_dsa_key(const ldns_key *k)
{
return k->_key.dsa;
}
unsigned char *
-ldns_key_hmac_key(ldns_key *k)
+ldns_key_hmac_key(const ldns_key *k)
{
return k->_key.hmac;
}
uint32_t
-ldns_key_origttl(ldns_key *k)
+ldns_key_origttl(const ldns_key *k)
{
return k->_extra.dnssec.orig_ttl;
}
uint16_t
-ldns_key_flags(ldns_key *k)
+ldns_key_flags(const ldns_key *k)
{
return k->_extra.dnssec.flags;
}
uint32_t
-ldns_key_inception(ldns_key *k)
+ldns_key_inception(const ldns_key *k)
{
return k->_extra.dnssec.inception;
}
uint32_t
-ldns_key_expiration(ldns_key *k)
+ldns_key_expiration(const ldns_key *k)
{
return k->_extra.dnssec.expiration;
}
uint16_t
-ldns_key_keytag(ldns_key *k)
+ldns_key_keytag(const ldns_key *k)
{
return k->_extra.dnssec.keytag;
}
ldns_rdf *
-ldns_key_pubkey_owner(ldns_key *k)
+ldns_key_pubkey_owner(const ldns_key *k)
{
return k->_pubkey_owner;
}
}
ldns_rr *
-ldns_key2rr(ldns_key *k)
+ldns_key2rr(const ldns_key *k)
{
/* this function will convert a the keydata contained in
* rsa/dsa pointers to a DNSKEY rr. It will fill in as
* \param[in] key the key as an RR to use for the calc.
* \return the keytag
*/
-uint16_t ldns_calc_keytag(ldns_rr *key);
+uint16_t ldns_calc_keytag(const ldns_rr *key);
/**
* verifies an rrsig rrset.
* \param[in] *output The buffer to add the data to
* \return LDNS_STATUS_OK on success, and error status on failure
*/
-ldns_status ldns_rdf2buffer_str_a(ldns_buffer *output, ldns_rdf *rdf);
+ldns_status ldns_rdf2buffer_str_a(ldns_buffer *output, const ldns_rdf *rdf);
/**
* Converts an LDNS_RDF_TYPE_AAAA rdata element to string format and adds it to the output buffer
* \param[in] *output The buffer to add the data to
* \return LDNS_STATUS_OK on success, and error status on failure
*/
-ldns_status ldns_rdf2buffer_str_aaaa(ldns_buffer *output, ldns_rdf *rdf);
+ldns_status ldns_rdf2buffer_str_aaaa(ldns_buffer *output, const ldns_rdf *rdf);
/**
* Converts an LDNS_RDF_TYPE_STR rdata element to string format and adds it to the output buffer
* \param[in] *output The buffer to add the data to
* \return LDNS_STATUS_OK on success, and error status on failure
*/
-ldns_status ldns_rdf2buffer_str_str(ldns_buffer *output, ldns_rdf *rdf);
+ldns_status ldns_rdf2buffer_str_str(ldns_buffer *output, const ldns_rdf *rdf);
/**
* Converts an LDNS_RDF_TYPE_B64 rdata element to string format and adds it to the output buffer
* \param[in] *output The buffer to add the data to
* \return LDNS_STATUS_OK on success, and error status on failure
*/
-ldns_status ldns_rdf2buffer_str_b64(ldns_buffer *output, ldns_rdf *rdf);
+ldns_status ldns_rdf2buffer_str_b64(ldns_buffer *output, const ldns_rdf *rdf);
/**
* Converts an LDNS_RDF_TYPE_HEX rdata element to string format and adds it to the output buffer
* \param[in] *output The buffer to add the data to
* \return LDNS_STATUS_OK on success, and error status on failure
*/
-ldns_status ldns_rdf2buffer_str_hex(ldns_buffer *output, ldns_rdf *rdf);
+ldns_status ldns_rdf2buffer_str_hex(ldns_buffer *output, const ldns_rdf *rdf);
/**
* Converts an LDNS_RDF_TYPE_TYPE rdata element to string format and adds it to the output buffer
* \param[in] *output The buffer to add the data to
* \return LDNS_STATUS_OK on success, and error status on failure
*/
-ldns_status ldns_rdf2buffer_str_type(ldns_buffer *output, ldns_rdf *rdf);
+ldns_status ldns_rdf2buffer_str_type(ldns_buffer *output, const ldns_rdf *rdf);
/**
* Converts an LDNS_RDF_TYPE_CLASS rdata element to string format and adds it to the output buffer
* \param[in] *output The buffer to add the data to
* \return LDNS_STATUS_OK on success, and error status on failure
*/
-ldns_status ldns_rdf2buffer_str_class(ldns_buffer *output, ldns_rdf *rdf);
+ldns_status ldns_rdf2buffer_str_class(ldns_buffer *output, const ldns_rdf *rdf);
/**
* Converts an LDNS_RDF_TYPE_ALG rdata element to string format and adds it to the output buffer
* \param[in] *output The buffer to add the data to
* \return LDNS_STATUS_OK on success, and error status on failure
*/
-ldns_status ldns_rdf2buffer_str_alg(ldns_buffer *output, ldns_rdf *rdf);
+ldns_status ldns_rdf2buffer_str_alg(ldns_buffer *output, const ldns_rdf *rdf);
/**
* Converts an LDNS_RDF_TYPE_CERT rdata element to string format and adds it to the output buffer
* \param[in] *output The buffer to add the data to
* \return LDNS_STATUS_OK on success, and error status on failure
*/
-ldns_status ldns_rdf2buffer_str_cert_alg(ldns_buffer *output, ldns_rdf *rdf);
+ldns_status ldns_rdf2buffer_str_cert_alg(ldns_buffer *output, const ldns_rdf *rdf);
/**
* Converts an LDNS_RDF_TYPE_LOC rdata element to string format and adds it to the output buffer
* \param[in] *output The buffer to add the data to
* \return LDNS_STATUS_OK on success, and error status on failure
*/
-ldns_status ldns_rdf2buffer_str_loc(ldns_buffer *output, ldns_rdf *rdf);
+ldns_status ldns_rdf2buffer_str_loc(ldns_buffer *output, const ldns_rdf *rdf);
/**
* Converts an LDNS_RDF_TYPE_UNKNOWN rdata element to string format and adds it to the output buffer
* \param[in] *output The buffer to add the data to
* \return LDNS_STATUS_OK on success, and error status on failure
*/
-ldns_status ldns_rdf2buffer_str_unknown(ldns_buffer *output, ldns_rdf *rdf);
+ldns_status ldns_rdf2buffer_str_unknown(ldns_buffer *output, const ldns_rdf *rdf);
/**
* Converts an LDNS_RDF_TYPE_NSAP rdata element to string format and adds it to the output buffer
* \param[in] *output The buffer to add the data to
* \return LDNS_STATUS_OK on success, and error status on failure
*/
-ldns_status ldns_rdf2buffer_str_nsap(ldns_buffer *output, ldns_rdf *rdf);
+ldns_status ldns_rdf2buffer_str_nsap(ldns_buffer *output, const ldns_rdf *rdf);
/**
* Converts an LDNS_RDF_TYPE_WKS rdata element to string format and adds it to the output buffer
* \param[in] *output The buffer to add the data to
* \return LDNS_STATUS_OK on success, and error status on failure
*/
-ldns_status ldns_rdf2buffer_str_wks(ldns_buffer *output, ldns_rdf *rdf);
+ldns_status ldns_rdf2buffer_str_wks(ldns_buffer *output, const ldns_rdf *rdf);
/**
* Converts an LDNS_RDF_TYPE_NSEC rdata element to string format and adds it to the output buffer
* \param[in] *output The buffer to add the data to
* \return LDNS_STATUS_OK on success, and error status on failure
*/
-ldns_status ldns_rdf2buffer_str_nsec(ldns_buffer *output, ldns_rdf *rdf);
+ldns_status ldns_rdf2buffer_str_nsec(ldns_buffer *output, const ldns_rdf *rdf);
/**
* Converts an LDNS_RDF_TYPE_PERIOD rdata element to string format and adds it to the output buffer
* \param[in] *output The buffer to add the data to
* \return LDNS_STATUS_OK on success, and error status on failure
*/
-ldns_status ldns_rdf2buffer_str_period(ldns_buffer *output, ldns_rdf *rdf);
+ldns_status ldns_rdf2buffer_str_period(ldns_buffer *output, const ldns_rdf *rdf);
/**
* Converts an LDNS_RDF_TYPE_TSIGTIME rdata element to string format and adds it to the output buffer
* \param[in] *output The buffer to add the data to
* \return LDNS_STATUS_OK on success, and error status on failure
*/
-ldns_status ldns_rdf2buffer_str_tsigtime(ldns_buffer *output, ldns_rdf *rdf);
+ldns_status ldns_rdf2buffer_str_tsigtime(ldns_buffer *output, const ldns_rdf *rdf);
/**
* Converts an LDNS_RDF_TYPE_APL rdata element to string format and adds it to the output buffer
* \param[in] *output The buffer to add the data to
* \return LDNS_STATUS_OK on success, and error status on failure
*/
-ldns_status ldns_rdf2buffer_str_apl(ldns_buffer *output, ldns_rdf *rdf);
+ldns_status ldns_rdf2buffer_str_apl(ldns_buffer *output, const ldns_rdf *rdf);
/**
* Converts an LDNS_RDF_TYPE_INT16_DATA rdata element to string format and adds it to the output buffer
* \param[in] *output The buffer to add the data to
* \return LDNS_STATUS_OK on success, and error status on failure
*/
-ldns_status ldns_rdf2buffer_str_int16_data(ldns_buffer *output, ldns_rdf *rdf);
+ldns_status ldns_rdf2buffer_str_int16_data(ldns_buffer *output, const ldns_rdf *rdf);
/**
* Converts an LDNS_RDF_TYPE_IPSECKEY rdata element to string format and adds it to the output buffer
* \param[in] *output The buffer to add the data to
* \return LDNS_STATUS_OK on success, and error status on failure
*/
-ldns_status ldns_rdf2buffer_str_ipseckey(ldns_buffer *output, ldns_rdf *rdf);
+ldns_status ldns_rdf2buffer_str_ipseckey(ldns_buffer *output, const ldns_rdf *rdf);
/**
* Converts an LDNS_RDF_TYPE_TSIG rdata element to string format and adds it to the output buffer
* \param[in] *output The buffer to add the data to
* \return LDNS_STATUS_OK on success, and error status on failure
*/
-ldns_status ldns_rdf2buffer_str_tsig(ldns_buffer *output, ldns_rdf *rdf);
+ldns_status ldns_rdf2buffer_str_tsig(ldns_buffer *output, const ldns_rdf *rdf);
/**
* \param[in] rdf the pointer to the rdafa field containing the data
* \return status
*/
-ldns_status ldns_rdf2buffer_str(ldns_buffer *output, ldns_rdf *rdf);
+ldns_status ldns_rdf2buffer_str(ldns_buffer *output, const ldns_rdf *rdf);
/**
* Converts the data in the resource record to presentation
* \param[in] rr the pointer to the rr field to convert
* \return status
*/
-ldns_status ldns_rr2buffer_str(ldns_buffer *output, ldns_rr *rr);
+ldns_status ldns_rr2buffer_str(ldns_buffer *output, const ldns_rr *rr);
/**
* Converts the data in the DNS packet to presentation
* \param[in] pkt the pointer to the packet to convert
* \return status
*/
-ldns_status ldns_pkt2buffer_str(ldns_buffer *output, ldns_pkt *pkt);
+ldns_status ldns_pkt2buffer_str(ldns_buffer *output, const ldns_pkt *pkt);
/**
* Converts the data in the DNS packet to presentation
* \param[in] k the pointer to the private key to convert
* \return status
*/
-ldns_status ldns_key2buffer_str(ldns_buffer *output, ldns_key *k);
+ldns_status ldns_key2buffer_str(ldns_buffer *output, const ldns_key *k);
/**
* Converts the data in the int16 typed rdata field to presentation
* \param[in] rdf the pointer to the rdafa field containing the data
* \return status
*/
-ldns_status ldns_rdf2buffer_str_int16(ldns_buffer *output, ldns_rdf *rdf);
+ldns_status ldns_rdf2buffer_str_int16(ldns_buffer *output, const ldns_rdf *rdf);
/**
* Converts the data in the rdata field to presentation format and
* \param[in] rdf The rdata field to convert
* \return null terminated char * data, or NULL on error
*/
-char *ldns_rdf2str(ldns_rdf *rdf);
+char *ldns_rdf2str(const ldns_rdf *rdf);
/**
* Converts the data in the resource record to presentation format and
* \param[in] rr The rdata field to convert
* \return null terminated char * data, or NULL on error
*/
-char *ldns_rr2str(ldns_rr *rr);
+char *ldns_rr2str(const ldns_rr *rr);
/**
* Converts the data in the DNS packet to presentation format and
* \param[in] pkt The rdata field to convert
* \return null terminated char * data, or NULL on error
*/
-char *ldns_pkt2str(ldns_pkt *pkt);
+char *ldns_pkt2str(const ldns_pkt *pkt);
/**
* Converts a private key to the test presentation fmt and
* \param[in] k the key to convert to text
* \return null terminated char * data, or NULL on error
*/
-char *ldns_key2str(ldns_key *k);
+char *ldns_key2str(const ldns_key *k);
/**
* Converts a list of resource records to presentation format
* \param[in] rr_list the rr_list to convert to text
* \return null terminated char * data, or NULL on error
*/
-char *ldns_rr_list2str(ldns_rr_list *rr_list);
+char *ldns_rr_list2str(const ldns_rr_list *rr_list);
/**
* Returns the data in the buffer as a null terminated char * string
* \param[in] rdf the rdata field to print
* \return void
*/
-void ldns_rdf_print(FILE *output, ldns_rdf *rdf);
+void ldns_rdf_print(FILE *output, const ldns_rdf *rdf);
/**
* Prints the data in the resource record to the given file stream
* \param[in] rr the resource record to print
* \return void
*/
-void ldns_rr_print(FILE *output, ldns_rr *rr);
+void ldns_rr_print(FILE *output, const ldns_rr *rr);
/**
* Prints the data in the DNS packet to the given file stream
* \param[in] pkt the packet to print
* \return void
*/
-void ldns_pkt_print(FILE *output, ldns_pkt *pkt);
+void ldns_pkt_print(FILE *output, const ldns_pkt *pkt);
/**
* Converts a rr_list to presentation format and appends it to
* \param[in] list the ldns_rr_list to print
* \return ldns_status
*/
-ldns_status ldns_rr_list2buffer_str(ldns_buffer *output, ldns_rr_list *list);
+ldns_status ldns_rr_list2buffer_str(ldns_buffer *output, const ldns_rr_list *list);
/**
* Converts the header of a packet to presentation format and appends it to
* \param[in] pkt the packet to convert the header of
* \return ldns_status
*/
-ldns_status ldns_pktheader2buffer_str(ldns_buffer *output, ldns_pkt *pkt);
+ldns_status ldns_pktheader2buffer_str(ldns_buffer *output, const ldns_pkt *pkt);
/**
* print a rr_list to output
* param[in] output the fd to print to
* param[in] list the rr_list to print
*/
-void ldns_rr_list_print(FILE *output, ldns_rr_list *list);
+void ldns_rr_list_print(FILE *output, const ldns_rr_list *list);
/**
* Print a resolver (in sofar that is possible) state
* \param[in] output the fd to print to
* \param[in] r the resolver to print
*/
-void ldns_resolver_print(FILE *output, ldns_resolver *r);
+void ldns_resolver_print(FILE *output, const ldns_resolver *r);
/**
* Print a zone structure * to output. Note the SOA record
* \param[in] output the fd to print to
* \param[in] z the zone to print
*/
-void ldns_zone_print(FILE *output, ldns_zone *z);
+void ldns_zone_print(FILE *output, const ldns_zone *z);
/**
* Print the ldns_rdf containing a dname to the buffer
* \param[in] dname the dname to print
* \return ldns_status message if the printing succeeded
*/
-ldns_status ldns_rdf2buffer_str_dname(ldns_buffer *output, ldns_rdf *dname);
+ldns_status ldns_rdf2buffer_str_dname(ldns_buffer *output, const ldns_rdf *dname);
#endif /* LDNS_HOST2STR_H */
#include "ldns/util.h"
+/**
+ * Copies the dname data to the buffer in wire format
+ * \param[out] *output buffer to append the result to
+ * \param[in] *name rdata dname to convert
+ * \return ldns_status
+ */
+ldns_status ldns_dname2buffer_wire(ldns_buffer *buffer, const ldns_rdf *name);
+
/**
* Copies the rdata data to the buffer in wire format
* \param[out] *output buffer to append the result to
* \param[in] sigrr signature rr to operate on
* \return ldns_status
*/
-ldns_status ldns_rrsig2buffer_wire(ldns_buffer *output, ldns_rr *sigrr);
+ldns_status ldns_rrsig2buffer_wire(ldns_buffer *output, const ldns_rr *sigrr);
/**
* Converts an rr's rdata to wireformat, while excluding
- * the ownername and all the crap before the rdata.
+ * the ownername and all the stuff before the rdata.
* This is needed in DNSSEC keytag calculation, the ds
* calcalution from the key and maybe elsewhere.
*
* \param[in] *rr rr to operate on
* \return ldns_status
*/
-ldns_status ldns_rr_rdata2buffer_wire(ldns_buffer *output, ldns_rr *rr);
+ldns_status ldns_rr_rdata2buffer_wire(ldns_buffer *output, const ldns_rr *rr);
/**
* Copies the packet data to the buffer in wire format
* \param[in] *rrlist rr_list to to convert
* \return ldns_status
*/
-ldns_status ldns_rr_list2buffer_wire(ldns_buffer *output, ldns_rr_list *rrlist);
+ldns_status ldns_rr_list2buffer_wire(ldns_buffer *output, const ldns_rr_list *rrlist);
/**
* Allocates an array of uint8_t at dest, and puts the wireformat of the
* \param[in] key_list the key_list
* \return the numbers of keys in the list
*/
-size_t ldns_key_list_key_count(ldns_key_list *key_list);
+size_t ldns_key_list_key_count(const ldns_key_list *key_list);
/**
* returns a pointer to the key in the list at the given position
* \param[in] nr the position in the list
* \return the key
*/
-ldns_key *ldns_key_list_key(ldns_key_list *key, size_t nr);
+ldns_key *ldns_key_list_key(const ldns_key_list *key, size_t nr);
#ifdef HAVE_SSL
/**
* \param[in] k the key to look in
* \return the RSA * structure in the key
*/
-RSA *ldns_key_rsa_key(ldns_key *k);
+RSA *ldns_key_rsa_key(const ldns_key *k);
#endif /* HAVE_SSL */
/**
* returns the (openssl) DSA struct contained in the key
*/
#ifdef HAVE_SSL
-DSA *ldns_key_dsa_key(ldns_key *k);
+DSA *ldns_key_dsa_key(const ldns_key *k);
#endif /* HAVE_SSL */
/**
* \param[in] k the key
* \return the algorithm
*/
-ldns_signing_algorithm ldns_key_algorithm(ldns_key *k);
+ldns_signing_algorithm ldns_key_algorithm(const ldns_key *k);
/**
* return the hmac key
* \param[in] k the key
* \return the hmac key
*/
-unsigned char *ldns_key_hmac_key(ldns_key *k);
+unsigned char *ldns_key_hmac_key(const ldns_key *k);
/**
* return the original ttl of the key
* \param[in] k the key
* \return the original ttl
*/
-uint32_t ldns_key_origttl(ldns_key *k);
+uint32_t ldns_key_origttl(const ldns_key *k);
/**
* return the key's inception date
* \param[in] k the key
* \return the inception date
*/
-uint32_t ldns_key_inception(ldns_key *k);
+uint32_t ldns_key_inception(const ldns_key *k);
/**
* return the key's expiration date
* \param[in] k the key
* \return the experiration date
*/
-uint32_t ldns_key_expiration(ldns_key *k);
+uint32_t ldns_key_expiration(const ldns_key *k);
/**
* return the keytag
* \param[in] k the key
* \return the keytag
*/
-uint16_t ldns_key_keytag(ldns_key *k);
+uint16_t ldns_key_keytag(const ldns_key *k);
/**
* return the public key's owner
* \param[in] k the key
* \return the owner
*/
-ldns_rdf *ldns_key_pubkey_owner(ldns_key *k);
+ldns_rdf *ldns_key_pubkey_owner(const ldns_key *k);
/**
* return the flag of the key
* \param[in] k the key
* \return the flag
*/
-uint16_t ldns_key_flags(ldns_key *k);
+uint16_t ldns_key_flags(const ldns_key *k);
/**
* pops the last rr from a keylist
* \param[in] k the ldns_key to convert
* \return ldns_rr representation of the key
*/
-ldns_rr *ldns_key2rr(ldns_key *k);
+ldns_rr *ldns_key2rr(const ldns_key *k);
/**
* print a private key to the file ouput
* \param[in] output the FILE descriptor where to print to
* \param[in] k the ldns_key to print
*/
-void ldns_key_print(FILE *output, ldns_key *k);
+void ldns_key_print(FILE *output, const ldns_key *k);
/**
* frees a key structure
* \param[in] rr_list the rr_list to read from
* \return the number of rr's
*/
-size_t ldns_rr_list_rr_count(ldns_rr_list *rr_list);
+size_t ldns_rr_list_rr_count(const ldns_rr_list *rr_list);
/**
* sets the number of rr's in an rr_list.
* \param[in] nr return this rr
* \return the rr at position nr
*/
-ldns_rr* ldns_rr_list_rr(ldns_rr_list *rr_list, size_t nr);
+ldns_rr* ldns_rr_list_rr(const ldns_rr_list *rr_list, size_t nr);
/**
* creates a new rr_list structure.
* \param[in] r the resource record
* \return a ldns_rdf* with the address or NULL on failure
*/
-ldns_rdf* ldns_rr_a_address(ldns_rr *r);
+ldns_rdf* ldns_rr_a_address(const ldns_rr *r);
/**
* sets the address of a LDNS_RR_TYPE_A rr
* \param[in] r the resource record
* \return a ldns_rdf* with the name or NULL on failure
*/
-ldns_rdf* ldns_rr_ns_nsdname(ldns_rr *r);
+ldns_rdf* ldns_rr_ns_nsdname(const ldns_rr *r);
/* MX */
/**
* \param[in] r the resource record
* \return a ldns_rdf* with the preference or NULL on failure
*/
-ldns_rdf* ldns_rr_mx_preference(ldns_rr *r);
+ldns_rdf* ldns_rr_mx_preference(const ldns_rr *r);
/**
* returns the mx host of a LDNS_RR_TYPE_MX rr
* \param[in] r the resource record
* \return a ldns_rdf* with the name of the MX host or NULL on failure
*/
-ldns_rdf* ldns_rr_mx_exchange(ldns_rr *r);
+ldns_rdf* ldns_rr_mx_exchange(const ldns_rr *r);
/* RRSIG */
/**
* \param[in] r the resource record
* \return a ldns_rdf* with the type covered or NULL on failure
*/
-ldns_rdf* ldns_rr_rrsig_typecovered(ldns_rr *r);
+ldns_rdf* ldns_rr_rrsig_typecovered(const ldns_rr *r);
/**
* sets the typecovered of a LDNS_RR_TYPE_RRSIG rr
* \param[in] r the rr to use
* \param[in] r the resource record
* \return a ldns_rdf* with the algorithm or NULL on failure
*/
-ldns_rdf* ldns_rr_rrsig_algorithm(ldns_rr *r);
+ldns_rdf* ldns_rr_rrsig_algorithm(const ldns_rr *r);
/**
* sets the algorithm of a LDNS_RR_TYPE_RRSIG rr
* \param[in] r the rr to use
* \param[in] r the resource record
* \return a ldns_rdf* with the number of labels or NULL on failure
*/
-ldns_rdf* ldns_rr_rrsig_labels(ldns_rr *r);
+ldns_rdf* ldns_rr_rrsig_labels(const ldns_rr *r);
/**
* sets the number of labels of a LDNS_RR_TYPE_RRSIG rr
* \param[in] r the rr to use
* \param[in] r the resource record
* \return a ldns_rdf* with the original TTL or NULL on failure
*/
-ldns_rdf* ldns_rr_rrsig_origttl(ldns_rr *r);
+ldns_rdf* ldns_rr_rrsig_origttl(const ldns_rr *r);
/**
* sets the original TTL of a LDNS_RR_TYPE_RRSIG rr
* \param[in] r the rr to use
* \param[in] r the resource record
* \return a ldns_rdf* with the expiration time or NULL on failure
*/
-ldns_rdf* ldns_rr_rrsig_expiration(ldns_rr *r);
+ldns_rdf* ldns_rr_rrsig_expiration(const ldns_rr *r);
/**
* sets the expireation date of a LDNS_RR_TYPE_RRSIG rr
* \param[in] r the rr to use
* \param[in] r the resource record
* \return a ldns_rdf* with the inception time or NULL on failure
*/
-ldns_rdf* ldns_rr_rrsig_inception(ldns_rr *r);
+ldns_rdf* ldns_rr_rrsig_inception(const ldns_rr *r);
/**
* sets the inception date of a LDNS_RR_TYPE_RRSIG rr
* \param[in] r the rr to use
* \param[in] r the resource record
* \return a ldns_rdf* with the keytag or NULL on failure
*/
-ldns_rdf* ldns_rr_rrsig_keytag(ldns_rr *r);
+ldns_rdf* ldns_rr_rrsig_keytag(const ldns_rr *r);
/**
* sets the keytag of a LDNS_RR_TYPE_RRSIG rr
* \param[in] r the rr to use
* \param[in] r the resource record
* \return a ldns_rdf* with the signers name or NULL on failure
*/
-ldns_rdf* ldns_rr_rrsig_signame(ldns_rr *r);
+ldns_rdf* ldns_rr_rrsig_signame(const ldns_rr *r);
/**
* sets the signers name of a LDNS_RR_TYPE_RRSIG rr
* \param[in] r the rr to use
* \param[in] r the resource record
* \return a ldns_rdf* with the signature data or NULL on failure
*/
-ldns_rdf* ldns_rr_rrsig_sig(ldns_rr *r);
+ldns_rdf* ldns_rr_rrsig_sig(const ldns_rr *r);
/**
* sets the signature data of a LDNS_RR_TYPE_RRSIG rr
* \param[in] r the rr to use
* \param[in] r the resource record
* \return a ldns_rdf* with the flags or NULL on failure
*/
-ldns_rdf* ldns_rr_dnskey_flags(ldns_rr *r);
+ldns_rdf* ldns_rr_dnskey_flags(const ldns_rr *r);
/**
* sets the flags of a LDNS_RR_TYPE_DNSKEY rr
* \param[in] r the rr to use
* \param[in] r the resource record
* \return a ldns_rdf* with the protocol or NULL on failure
*/
-ldns_rdf* ldns_rr_dnskey_protocol(ldns_rr *r);
+ldns_rdf* ldns_rr_dnskey_protocol(const ldns_rr *r);
/**
* sets the protocol of a LDNS_RR_TYPE_DNSKEY rr
* \param[in] r the rr to use
* \param[in] r the resource record
* \return a ldns_rdf* with the algorithm or NULL on failure
*/
-ldns_rdf* ldns_rr_dnskey_algorithm(ldns_rr *r);
+ldns_rdf* ldns_rr_dnskey_algorithm(const ldns_rr *r);
/**
* sets the algorithm of a LDNS_RR_TYPE_DNSKEY rr
* \param[in] r the rr to use
* \param[in] r the resource record
* \return a ldns_rdf* with the key data or NULL on failure
*/
-ldns_rdf* ldns_rr_dnskey_key(ldns_rr *r);
+ldns_rdf* ldns_rr_dnskey_key(const ldns_rr *r);
/**
* sets the key data of a LDNS_RR_TYPE_DNSKEY rr
* \param[in] r the rr to use
* \param[in] key the key rr to use
* \return the keysize in bits
*/
-uint16_t ldns_rr_dnskey_key_size(ldns_rr *key);
+uint16_t ldns_rr_dnskey_key_size(const ldns_rr *key);
#endif /* LDNS_RR_FUNCTIONS_H */
/* rr_lists */
size_t
-ldns_rr_list_rr_count(ldns_rr_list *rr_list)
+ldns_rr_list_rr_count(const ldns_rr_list *rr_list)
{
if (rr_list) {
return rr_list->_rr_count;
}
ldns_rr *
-ldns_rr_list_rr(ldns_rr_list *rr_list, size_t nr)
+ldns_rr_list_rr(const ldns_rr_list *rr_list, size_t nr)
{
if (nr < ldns_rr_list_rr_count(rr_list)) {
return rr_list->_rrs[nr];
* \return the rdf sought
*/
static ldns_rdf *
-ldns_rr_function(ldns_rr_type type, ldns_rr *rr, size_t pos)
+ldns_rr_function(ldns_rr_type type, const ldns_rr *rr, size_t pos)
{
if (!rr || ldns_rr_get_type(rr) != type) {
return NULL;
/* A/AAAA records */
ldns_rdf *
-ldns_rr_a_address(ldns_rr *r)
+ldns_rr_a_address(const ldns_rr *r)
{
/* 2 types to check, cannot use the macro */
if (!r || (ldns_rr_get_type(r) != LDNS_RR_TYPE_A &&
/* NS record */
ldns_rdf *
-ldns_rr_ns_nsdname(ldns_rr *r)
+ldns_rr_ns_nsdname(const ldns_rr *r)
{
return ldns_rr_function(LDNS_RR_TYPE_NS, r, 0);
}
/* MX record */
ldns_rdf *
-ldns_rr_mx_preference(ldns_rr *r)
+ldns_rr_mx_preference(const ldns_rr *r)
{
return ldns_rr_function(LDNS_RR_TYPE_MX, r, 0);
}
ldns_rdf *
-ldns_rr_mx_exchange(ldns_rr *r)
+ldns_rr_mx_exchange(const ldns_rr *r)
{
return ldns_rr_function(LDNS_RR_TYPE_MX, r, 1);
}
/* RRSIG record */
ldns_rdf *
-ldns_rr_rrsig_typecovered(ldns_rr *r)
+ldns_rr_rrsig_typecovered(const ldns_rr *r)
{
return ldns_rr_function(LDNS_RR_TYPE_RRSIG, r, 0);
}
}
ldns_rdf *
-ldns_rr_rrsig_algorithm(ldns_rr *r)
+ldns_rr_rrsig_algorithm(const ldns_rr *r)
{
return ldns_rr_function(LDNS_RR_TYPE_RRSIG, r, 1);
}
}
ldns_rdf *
-ldns_rr_rrsig_labels(ldns_rr *r)
+ldns_rr_rrsig_labels(const ldns_rr *r)
{
return ldns_rr_function(LDNS_RR_TYPE_RRSIG, r, 2);
}
}
ldns_rdf *
-ldns_rr_rrsig_origttl(ldns_rr *r)
+ldns_rr_rrsig_origttl(const ldns_rr *r)
{
return ldns_rr_function(LDNS_RR_TYPE_RRSIG, r, 3);
}
}
ldns_rdf *
-ldns_rr_rrsig_expiration(ldns_rr *r)
+ldns_rr_rrsig_expiration(const ldns_rr *r)
{
return ldns_rr_function(LDNS_RR_TYPE_RRSIG, r, 4);
}
}
ldns_rdf *
-ldns_rr_rrsig_inception(ldns_rr *r)
+ldns_rr_rrsig_inception(const ldns_rr *r)
{
return ldns_rr_function(LDNS_RR_TYPE_RRSIG, r, 5);
}
}
ldns_rdf *
-ldns_rr_rrsig_keytag(ldns_rr *r)
+ldns_rr_rrsig_keytag(const ldns_rr *r)
{
return ldns_rr_function(LDNS_RR_TYPE_RRSIG, r, 6);
}
return ldns_rr_set_function(LDNS_RR_TYPE_RRSIG, r, f, 6);
}
ldns_rdf *
-ldns_rr_rrsig_signame(ldns_rr *r)
+ldns_rr_rrsig_signame(const ldns_rr *r)
{
return ldns_rr_function(LDNS_RR_TYPE_RRSIG, r, 7);
}
}
ldns_rdf *
-ldns_rr_rrsig_sig(ldns_rr *r)
+ldns_rr_rrsig_sig(const ldns_rr *r)
{
return ldns_rr_function(LDNS_RR_TYPE_RRSIG, r, 8);
}
/* DNSKEY record */
ldns_rdf *
-ldns_rr_dnskey_flags(ldns_rr *r)
+ldns_rr_dnskey_flags(const ldns_rr *r)
{
return ldns_rr_function(LDNS_RR_TYPE_DNSKEY, r, 0);
}
}
ldns_rdf *
-ldns_rr_dnskey_protocol(ldns_rr *r)
+ldns_rr_dnskey_protocol(const ldns_rr *r)
{
return ldns_rr_function(LDNS_RR_TYPE_DNSKEY, r, 1);
}
return ldns_rr_set_function(LDNS_RR_TYPE_DNSKEY, r, f, 1);
}
ldns_rdf *
-ldns_rr_dnskey_algorithm(ldns_rr *r)
+ldns_rr_dnskey_algorithm(const ldns_rr *r)
{
return ldns_rr_function(LDNS_RR_TYPE_DNSKEY, r, 2);
}
return ldns_rr_set_function(LDNS_RR_TYPE_DNSKEY, r, f, 2);
}
ldns_rdf *
-ldns_rr_dnskey_key(ldns_rr *r)
+ldns_rr_dnskey_key(const ldns_rr *r)
{
return ldns_rr_function(LDNS_RR_TYPE_DNSKEY, r, 3);
}
}
uint16_t
-ldns_rr_dnskey_key_size(ldns_rr *key) {
+ldns_rr_dnskey_key_size(const ldns_rr *key) {
ldns_rdf *keydata;
uint16_t length;
projects / thirdparty / ldns.git / commitdiff
