Changeset View
Changeset View
Standalone View
Standalone View
contrib/ldns/rr.c
/* rr.c | /* rr.c | ||||
* | * | ||||
* access functions for ldns_rr - | * access functions for ldns_rr - | ||||
* a Net::DNS like library for C | * a Net::DNS like library for C | ||||
* LibDNS Team @ NLnet Labs | * LibDNS Team @ NLnet Labs | ||||
* | * | ||||
* (c) NLnet Labs, 2004-2006 | * (c) NLnet Labs, 2004-2006 | ||||
* See the file LICENSE for the license | * See the file LICENSE for the license | ||||
*/ | */ | ||||
#include <ldns/config.h> | #include <ldns/config.h> | ||||
#include <ldns/ldns.h> | #include <ldns/ldns.h> | ||||
#include <ldns/internal.h> | |||||
#include <strings.h> | #include <strings.h> | ||||
#include <limits.h> | #include <limits.h> | ||||
#include <errno.h> | #include <errno.h> | ||||
#define LDNS_SYNTAX_DATALEN 16 | #define LDNS_SYNTAX_DATALEN 16 | ||||
#define LDNS_TTL_DATALEN 21 | #define LDNS_TTL_DATALEN 21 | ||||
#define LDNS_RRLIST_INIT 8 | #define LDNS_RRLIST_INIT 8 | ||||
#define _IS_WHITESPACE(chr) \ | |||||
( NULL != strchr( LDNS_PARSE_NO_NL, chr) ) | |||||
#define _BUFFER_IS_AT_WHITESPACE(rd_buf) \ | |||||
_IS_WHITESPACE(*(ldns_buffer_current(rd_buf))) | |||||
ldns_rr * | ldns_rr * | ||||
ldns_rr_new(void) | ldns_rr_new(void) | ||||
{ | { | ||||
ldns_rr *rr; | ldns_rr *rr; | ||||
rr = LDNS_MALLOC(ldns_rr); | rr = LDNS_MALLOC(ldns_rr); | ||||
if (!rr) { | if (!rr) { | ||||
return NULL; | return NULL; | ||||
} | } | ||||
▲ Show 20 Lines • Show All 75 Lines • ▼ Show 20 Lines | |||||
* miek.nl. 3600 IN MX 10 elektron.atoom.net | * miek.nl. 3600 IN MX 10 elektron.atoom.net | ||||
* or | * or | ||||
* miek.nl. 1h IN MX 10 elektron.atoom.net | * miek.nl. 1h IN MX 10 elektron.atoom.net | ||||
* or | * or | ||||
* miek.nl. IN MX 10 elektron.atoom.net | * miek.nl. IN MX 10 elektron.atoom.net | ||||
*/ | */ | ||||
static ldns_status | static ldns_status | ||||
ldns_rr_new_frm_str_internal(ldns_rr **newrr, const char *str, | ldns_rr_new_frm_str_internal(ldns_rr **newrr, const char *str, | ||||
uint32_t default_ttl, const ldns_rdf *origin, | uint32_t default_ttl, const ldns_rdf *origin, | ||||
ldns_rdf **prev, bool question) | ldns_rdf **prev, bool question, | ||||
bool *explicit_ttl) | |||||
{ | { | ||||
ldns_rr *new; | ldns_rr *new; | ||||
const ldns_rr_descriptor *desc; | const ldns_rr_descriptor *desc; | ||||
ldns_rr_type rr_type; | ldns_rr_type rr_type; | ||||
ldns_buffer *rr_buf = NULL; | ldns_buffer *rr_buf = NULL; | ||||
ldns_buffer *rd_buf = NULL; | ldns_buffer *rd_buf = NULL; | ||||
uint32_t ttl_val; | uint32_t ttl_val; | ||||
char *owner = NULL; | char *owner = NULL; | ||||
char *ttl = NULL; | char *ttl = NULL; | ||||
ldns_rr_class clas_val; | ldns_rr_class clas_val; | ||||
char *clas = NULL; | char *clas = NULL; | ||||
char *type = NULL; | char *type = NULL; | ||||
size_t type_sz; | |||||
char *rdata = NULL; | char *rdata = NULL; | ||||
char *rd = NULL; | char *rd = NULL; | ||||
char *xtok = NULL; /* For RDF types with spaces (i.e. extra tokens) */ | char *xtok = NULL; /* For RDF types with spaces (i.e. extra tokens) */ | ||||
size_t rd_strlen; | size_t rd_strlen; | ||||
const char *delimiters; | const char *delimiters; | ||||
ssize_t c; | ssize_t c; | ||||
ldns_rdf *owner_dname; | ldns_rdf *owner_dname; | ||||
const char* endptr; | const char* endptr; | ||||
▲ Show 20 Lines • Show All 56 Lines • ▼ Show 20 Lines | ldns_rr_new_frm_str_internal(ldns_rr **newrr, const char *str, | ||||
if (strlen(ttl) > 0 && !isdigit((int) ttl[0])) { | if (strlen(ttl) > 0 && !isdigit((int) ttl[0])) { | ||||
/* ah, it's not there or something */ | /* ah, it's not there or something */ | ||||
if (default_ttl == 0) { | if (default_ttl == 0) { | ||||
ttl_val = LDNS_DEFAULT_TTL; | ttl_val = LDNS_DEFAULT_TTL; | ||||
} else { | } else { | ||||
ttl_val = default_ttl; | ttl_val = default_ttl; | ||||
} | } | ||||
if (explicit_ttl) | |||||
*explicit_ttl = false; | |||||
/* we not ASSUMING the TTL is missing and that | /* we not ASSUMING the TTL is missing and that | ||||
* the rest of the RR is still there. That is | * the rest of the RR is still there. That is | ||||
* CLASS TYPE RDATA | * CLASS TYPE RDATA | ||||
* so ttl value we read is actually the class | * so ttl value we read is actually the class | ||||
*/ | */ | ||||
clas_val = ldns_get_rr_class_by_name(ttl); | clas_val = ldns_get_rr_class_by_name(ttl); | ||||
/* class can be left out too, assume IN, current | /* class can be left out too, assume IN, current | ||||
* token must be type | * token must be type | ||||
*/ | */ | ||||
if (clas_val == 0) { | if (clas_val == 0) { | ||||
clas_val = LDNS_RR_CLASS_IN; | clas_val = LDNS_RR_CLASS_IN; | ||||
type = LDNS_XMALLOC(char, strlen(ttl) + 1); | type_sz = strlen(ttl) + 1; | ||||
type = LDNS_XMALLOC(char, type_sz); | |||||
if (!type) { | if (!type) { | ||||
goto memerror; | goto memerror; | ||||
} | } | ||||
strncpy(type, ttl, strlen(ttl) + 1); | strlcpy(type, ttl, type_sz); | ||||
} | } | ||||
} else { | } else { | ||||
if (explicit_ttl) | |||||
*explicit_ttl = true; | |||||
if (-1 == ldns_bget_token( | if (-1 == ldns_bget_token( | ||||
rr_buf, clas, "\t\n ", LDNS_SYNTAX_DATALEN)) { | rr_buf, clas, "\t\n ", LDNS_SYNTAX_DATALEN)) { | ||||
status = LDNS_STATUS_SYNTAX_CLASS_ERR; | status = LDNS_STATUS_SYNTAX_CLASS_ERR; | ||||
goto error; | goto error; | ||||
} | } | ||||
clas_val = ldns_get_rr_class_by_name(clas); | clas_val = ldns_get_rr_class_by_name(clas); | ||||
/* class can be left out too, assume IN, current | /* class can be left out too, assume IN, current | ||||
* token must be type | * token must be type | ||||
*/ | */ | ||||
if (clas_val == 0) { | if (clas_val == 0) { | ||||
clas_val = LDNS_RR_CLASS_IN; | clas_val = LDNS_RR_CLASS_IN; | ||||
type = LDNS_XMALLOC(char, strlen(clas) + 1); | type_sz = strlen(clas) + 1; | ||||
type = LDNS_XMALLOC(char, type_sz); | |||||
if (!type) { | if (!type) { | ||||
goto memerror; | goto memerror; | ||||
} | } | ||||
strncpy(type, clas, strlen(clas) + 1); | strlcpy(type, clas, type_sz); | ||||
} | } | ||||
} | } | ||||
/* the rest should still be waiting for us */ | /* the rest should still be waiting for us */ | ||||
if (!type) { | if (!type) { | ||||
type = LDNS_XMALLOC(char, LDNS_SYNTAX_DATALEN); | type = LDNS_XMALLOC(char, LDNS_SYNTAX_DATALEN); | ||||
if (!type) { | if (!type) { | ||||
goto memerror; | goto memerror; | ||||
} | } | ||||
if (-1 == ldns_bget_token( | if (-1 == ldns_bget_token( | ||||
rr_buf, type, "\t\n ", LDNS_SYNTAX_DATALEN)) { | rr_buf, type, "\t\n ", LDNS_SYNTAX_DATALEN)) { | ||||
status = LDNS_STATUS_SYNTAX_TYPE_ERR; | status = LDNS_STATUS_SYNTAX_TYPE_ERR; | ||||
goto error; | goto error; | ||||
} | } | ||||
} | } | ||||
if (ldns_bget_token(rr_buf, rdata, "\0", LDNS_MAX_PACKETLEN) == -1) { | if (ldns_bget_token(rr_buf, rdata, "\0", LDNS_MAX_PACKETLEN) == -1) { | ||||
/* apparently we are done, and it's only a question RR | /* apparently we are done, and it's only a question RR | ||||
* so do not set status and go to ldnserror here | * so do not set status and go to ldnserror here | ||||
*/ | */ | ||||
} | } | ||||
ldns_buffer_new_frm_data(rd_buf, rdata, strlen(rdata)); | ldns_buffer_new_frm_data(rd_buf, rdata, strlen(rdata)); | ||||
if (strlen(owner) <= 1 && strncmp(owner, "@", 1) == 0) { | if (strncmp(owner, "@", 1) == 0) { | ||||
if (origin) { | if (origin) { | ||||
ldns_rr_set_owner(new, ldns_rdf_clone(origin)); | ldns_rr_set_owner(new, ldns_rdf_clone(origin)); | ||||
} else if (prev && *prev) { | } else if (prev && *prev) { | ||||
ldns_rr_set_owner(new, ldns_rdf_clone(*prev)); | ldns_rr_set_owner(new, ldns_rdf_clone(*prev)); | ||||
} else { | } else { | ||||
/* default to root */ | /* default to root */ | ||||
ldns_rr_set_owner(new, ldns_dname_new_frm_str(".")); | ldns_rr_set_owner(new, ldns_dname_new_frm_str(".")); | ||||
} | } | ||||
▲ Show 20 Lines • Show All 71 Lines • ▼ Show 20 Lines | ldns_rr_new_frm_str_internal(ldns_rr **newrr, const char *str, | ||||
} | } | ||||
for (done = false, r_cnt = 0; !done && r_cnt < r_max; r_cnt++) { | for (done = false, r_cnt = 0; !done && r_cnt < r_max; r_cnt++) { | ||||
quoted = false; | quoted = false; | ||||
switch (ldns_rr_descriptor_field_type(desc, r_cnt)) { | switch (ldns_rr_descriptor_field_type(desc, r_cnt)) { | ||||
case LDNS_RDF_TYPE_B64 : | case LDNS_RDF_TYPE_B64 : | ||||
case LDNS_RDF_TYPE_HEX : /* These rdf types may con- */ | case LDNS_RDF_TYPE_HEX : /* These rdf types may con- */ | ||||
case LDNS_RDF_TYPE_LOC : /* tain whitespace, only if */ | case LDNS_RDF_TYPE_NSEC : /* tain whitespace, only if */ | ||||
case LDNS_RDF_TYPE_WKS : /* it is the last rd field. */ | case LDNS_RDF_TYPE_LOC : /* it is the last rd field. */ | ||||
case LDNS_RDF_TYPE_WKS : | |||||
case LDNS_RDF_TYPE_IPSECKEY : | case LDNS_RDF_TYPE_IPSECKEY : | ||||
case LDNS_RDF_TYPE_NSEC : if (r_cnt == r_max - 1) { | case LDNS_RDF_TYPE_AMTRELAY : | ||||
case LDNS_RDF_TYPE_SVCPARAMS : if (r_cnt == r_max - 1) { | |||||
delimiters = "\n"; | delimiters = "\n"; | ||||
break; | break; | ||||
} | } | ||||
/* fallthrough */ | |||||
default : delimiters = "\n\t "; | default : delimiters = "\n\t "; | ||||
} | } | ||||
if (ldns_rdf_type_maybe_quoted( | if (ldns_rdf_type_maybe_quoted( | ||||
ldns_rr_descriptor_field_type( | ldns_rr_descriptor_field_type( | ||||
desc, r_cnt)) && | desc, r_cnt)) && | ||||
ldns_buffer_remaining(rd_buf) > 0){ | ldns_buffer_remaining(rd_buf) > 0){ | ||||
/* skip spaces */ | /* skip whitespace */ | ||||
while (*(ldns_buffer_current(rd_buf)) == ' ') { | while (ldns_buffer_remaining(rd_buf) > 0 && | ||||
_BUFFER_IS_AT_WHITESPACE(rd_buf)) { | |||||
ldns_buffer_skip(rd_buf, 1); | ldns_buffer_skip(rd_buf, 1); | ||||
} | } | ||||
if (*(ldns_buffer_current(rd_buf)) == '\"') { | if (ldns_buffer_remaining(rd_buf) > 0 && | ||||
*(ldns_buffer_current(rd_buf)) == '\"') { | |||||
delimiters = "\"\0"; | delimiters = "\"\0"; | ||||
ldns_buffer_skip(rd_buf, 1); | ldns_buffer_skip(rd_buf, 1); | ||||
quoted = true; | quoted = true; | ||||
} else if (ldns_rr_descriptor_field_type(desc, r_cnt) | } | ||||
if (!quoted && ldns_rr_descriptor_field_type(desc, r_cnt) | |||||
== LDNS_RDF_TYPE_LONG_STR) { | == LDNS_RDF_TYPE_LONG_STR) { | ||||
status = LDNS_STATUS_SYNTAX_RDATA_ERR; | status = LDNS_STATUS_SYNTAX_RDATA_ERR; | ||||
goto error; | goto error; | ||||
} | } | ||||
} | } | ||||
/* because number of fields can be variable, we can't rely on | /* because number of fields can be variable, we can't rely on | ||||
* _maximum() only | * _maximum() only | ||||
*/ | */ | ||||
/* skip spaces */ | /* skip whitespace */ | ||||
while (ldns_buffer_position(rd_buf) < ldns_buffer_limit(rd_buf) | while (ldns_buffer_position(rd_buf) < ldns_buffer_limit(rd_buf) | ||||
&& *(ldns_buffer_current(rd_buf)) == ' ' | && _BUFFER_IS_AT_WHITESPACE(rd_buf) | ||||
&& !quoted) { | && !quoted) { | ||||
ldns_buffer_skip(rd_buf, 1); | ldns_buffer_skip(rd_buf, 1); | ||||
} | } | ||||
pre_data_pos = ldns_buffer_position(rd_buf); | pre_data_pos = ldns_buffer_position(rd_buf); | ||||
if (-1 == (c = ldns_bget_token( | if (-1 == (c = ldns_bget_token( | ||||
rd_buf, rd, delimiters, LDNS_MAX_RDFLEN))) { | rd_buf, rd, delimiters, LDNS_MAX_RDFLEN))) { | ||||
done = true; | done = true; | ||||
(void)done; /* we're breaking, so done not read anymore */ | |||||
break; | break; | ||||
} | } | ||||
/* hmmz, rfc3597 specifies that any type can be represented | /* hmmz, rfc3597 specifies that any type can be represented | ||||
* with \# method, which can contain spaces... | * with \# method, which can contain spaces... | ||||
* it does specify size though... | * it does specify size though... | ||||
*/ | */ | ||||
rd_strlen = strlen(rd); | rd_strlen = strlen(rd); | ||||
/* unknown RR data */ | /* unknown RR data */ | ||||
if (strncmp(rd, "\\#", 2) == 0 && !quoted && | if (strncmp(rd, "\\#", 2) == 0 && !quoted && | ||||
(rd_strlen == 2 || rd[2]==' ')) { | (rd_strlen == 2 || _IS_WHITESPACE(rd[2]))) { | ||||
was_unknown_rr_format = 1; | was_unknown_rr_format = 1; | ||||
/* go back to before \# | /* go back to before \# | ||||
* and skip it while setting delimiters better | * and skip it while setting delimiters better | ||||
*/ | */ | ||||
ldns_buffer_set_position(rd_buf, pre_data_pos); | ldns_buffer_set_position(rd_buf, pre_data_pos); | ||||
delimiters = "\n\t "; | delimiters = "\n\t "; | ||||
(void)ldns_bget_token(rd_buf, rd, | (void)ldns_bget_token(rd_buf, rd, | ||||
Show All 12 Lines | if (strncmp(rd, "\\#", 2) == 0 && !quoted && | ||||
if (!hex_data_str) { | if (!hex_data_str) { | ||||
/* malloc error */ | /* malloc error */ | ||||
goto memerror; | goto memerror; | ||||
} | } | ||||
cur_hex_data_size = 0; | cur_hex_data_size = 0; | ||||
while(cur_hex_data_size < 2 * hex_data_size) { | while(cur_hex_data_size < 2 * hex_data_size) { | ||||
c = ldns_bget_token(rd_buf, rd, | c = ldns_bget_token(rd_buf, rd, | ||||
delimiters, LDNS_MAX_RDFLEN); | delimiters, LDNS_MAX_RDFLEN); | ||||
if (c != -1) { | if (c == -1) { | ||||
rd_strlen = strlen(rd); | status = LDNS_STATUS_SYNTAX_RDATA_ERR; | ||||
goto error; | |||||
} | } | ||||
if (c == -1 || | rd_strlen = strlen(rd); | ||||
(size_t)cur_hex_data_size + rd_strlen > | if ((size_t)cur_hex_data_size + rd_strlen > | ||||
2 * (size_t)hex_data_size) { | 2 * (size_t)hex_data_size) { | ||||
status = LDNS_STATUS_SYNTAX_RDATA_ERR; | status = LDNS_STATUS_SYNTAX_RDATA_ERR; | ||||
goto error; | goto error; | ||||
} | } | ||||
strncpy(hex_data_str + cur_hex_data_size, rd, | strlcpy(hex_data_str + cur_hex_data_size, rd, | ||||
rd_strlen); | rd_strlen + 1); | ||||
cur_hex_data_size += rd_strlen; | cur_hex_data_size += rd_strlen; | ||||
} | } | ||||
hex_data_str[cur_hex_data_size] = '\0'; | hex_data_str[cur_hex_data_size] = '\0'; | ||||
/* correct the rdf type */ | /* correct the rdf type */ | ||||
/* if *we* know the type, interpret it as wireformat */ | /* if *we* know the type, interpret it as wireformat */ | ||||
if (desc) { | if (desc) { | ||||
▲ Show 20 Lines • Show All 113 Lines • ▼ Show 20 Lines | if (strncmp(rd, "\\#", 2) == 0 && !quoted && | ||||
ldns_rdf_clone( | ldns_rdf_clone( | ||||
ldns_rr_owner(new)) | ldns_rr_owner(new)) | ||||
: ldns_rdf_new_frm_str( | : ldns_rdf_new_frm_str( | ||||
LDNS_RDF_TYPE_DNAME, ".") | LDNS_RDF_TYPE_DNAME, ".") | ||||
); | ); | ||||
} else if (r && rd_strlen >= 1 && origin && | } else if (r && rd_strlen >= 1 | ||||
!ldns_dname_str_absolute(rd)) { | && (origin || rr_type == LDNS_RR_TYPE_SOA) | ||||
&& !ldns_dname_str_absolute(rd)) { | |||||
status = ldns_dname_cat(r, origin); | status = ldns_dname_cat(r, origin | ||||
? origin : ldns_rr_owner(new)); | |||||
if (status != LDNS_STATUS_OK) { | if (status != LDNS_STATUS_OK) { | ||||
goto error; | goto error; | ||||
} | } | ||||
} | } | ||||
break; | break; | ||||
default: | default: | ||||
r = ldns_rdf_new_frm_str( | r = ldns_rdf_new_frm_str( | ||||
ldns_rr_descriptor_field_type( | ldns_rr_descriptor_field_type( | ||||
desc, r_cnt), rd); | desc, r_cnt), rd); | ||||
break; | break; | ||||
} | } | ||||
if (!r) { | if (!r) { | ||||
status = LDNS_STATUS_SYNTAX_RDATA_ERR; | status = LDNS_STATUS_SYNTAX_RDATA_ERR; | ||||
goto error; | goto error; | ||||
} | } | ||||
ldns_rr_push_rdf(new, r); | ldns_rr_push_rdf(new, r); | ||||
} | } | ||||
if (quoted) { | |||||
if (ldns_buffer_available(rd_buf, 1)) { | |||||
ldns_buffer_skip(rd_buf, 1); | |||||
} else { | |||||
done = true; | |||||
} | |||||
} | |||||
} /* for (done = false, r_cnt = 0; !done && r_cnt < r_max; r_cnt++) */ | } /* for (done = false, r_cnt = 0; !done && r_cnt < r_max; r_cnt++) */ | ||||
LDNS_FREE(rd); | LDNS_FREE(rd); | ||||
LDNS_FREE(xtok); | LDNS_FREE(xtok); | ||||
ldns_buffer_free(rr_buf); | ldns_buffer_free(rr_buf); | ||||
LDNS_FREE(rdata); | LDNS_FREE(rdata); | ||||
if (ldns_buffer_remaining(rd_buf) > 0) { | if (ldns_buffer_remaining(rd_buf) > 0) { | ||||
ldns_buffer_free(rd_buf); | ldns_buffer_free(rd_buf); | ||||
ldns_rr_free(new); | ldns_rr_free(new); | ||||
▲ Show 20 Lines • Show All 47 Lines • ▼ Show 20 Lines | ldns_rr_new_frm_str(ldns_rr **newrr, const char *str, | ||||
uint32_t default_ttl, const ldns_rdf *origin, | uint32_t default_ttl, const ldns_rdf *origin, | ||||
ldns_rdf **prev) | ldns_rdf **prev) | ||||
{ | { | ||||
return ldns_rr_new_frm_str_internal(newrr, | return ldns_rr_new_frm_str_internal(newrr, | ||||
str, | str, | ||||
default_ttl, | default_ttl, | ||||
origin, | origin, | ||||
prev, | prev, | ||||
false); | false, | ||||
NULL); | |||||
} | } | ||||
ldns_status | ldns_status | ||||
ldns_rr_new_question_frm_str(ldns_rr **newrr, const char *str, | ldns_rr_new_question_frm_str(ldns_rr **newrr, const char *str, | ||||
const ldns_rdf *origin, ldns_rdf **prev) | const ldns_rdf *origin, ldns_rdf **prev) | ||||
{ | { | ||||
return ldns_rr_new_frm_str_internal(newrr, | return ldns_rr_new_frm_str_internal(newrr, | ||||
str, | str, | ||||
0, | 0, | ||||
origin, | origin, | ||||
prev, | prev, | ||||
true); | true, | ||||
NULL); | |||||
} | } | ||||
/* Strip whitespace from the start and the end of <line>. */ | /* Strip whitespace from the start and the end of <line>. */ | ||||
static char * | static char * | ||||
ldns_strip_ws(char *line) | ldns_strip_ws(char *line) | ||||
{ | { | ||||
char *s = line, *e; | char *s = line, *e; | ||||
Show All 9 Lines | |||||
ldns_status | ldns_status | ||||
ldns_rr_new_frm_fp(ldns_rr **newrr, FILE *fp, uint32_t *ttl, ldns_rdf **origin, ldns_rdf **prev) | ldns_rr_new_frm_fp(ldns_rr **newrr, FILE *fp, uint32_t *ttl, ldns_rdf **origin, ldns_rdf **prev) | ||||
{ | { | ||||
return ldns_rr_new_frm_fp_l(newrr, fp, ttl, origin, prev, NULL); | return ldns_rr_new_frm_fp_l(newrr, fp, ttl, origin, prev, NULL); | ||||
} | } | ||||
ldns_status | ldns_status | ||||
ldns_rr_new_frm_fp_l(ldns_rr **newrr, FILE *fp, uint32_t *default_ttl, ldns_rdf **origin, ldns_rdf **prev, int *line_nr) | _ldns_rr_new_frm_fp_l_internal(ldns_rr **newrr, FILE *fp, | ||||
uint32_t *default_ttl, ldns_rdf **origin, ldns_rdf **prev, | |||||
int *line_nr, bool *explicit_ttl) | |||||
{ | { | ||||
char *line; | char *line = NULL; | ||||
size_t limit = 0; | |||||
const char *endptr; /* unused */ | const char *endptr; /* unused */ | ||||
ldns_rr *rr; | ldns_rr *rr; | ||||
uint32_t ttl; | uint32_t ttl; | ||||
ldns_rdf *tmp; | ldns_rdf *tmp; | ||||
ldns_status s; | ldns_status s; | ||||
ssize_t size; | |||||
if (default_ttl) { | if (default_ttl) { | ||||
ttl = *default_ttl; | ttl = *default_ttl; | ||||
} else { | } else { | ||||
ttl = 0; | ttl = 0; | ||||
} | } | ||||
line = LDNS_XMALLOC(char, LDNS_MAX_LINELEN + 1); | |||||
if (!line) { | |||||
return LDNS_STATUS_MEM_ERR; | |||||
} | |||||
/* read an entire line in from the file */ | /* read an entire line in from the file */ | ||||
if ((size = ldns_fget_token_l(fp, line, LDNS_PARSE_SKIP_SPACE, LDNS_MAX_LINELEN, line_nr)) == -1) { | if ((s = ldns_fget_token_l_st( fp, &line, &limit, false | ||||
, LDNS_PARSE_SKIP_SPACE, line_nr))) { | |||||
LDNS_FREE(line); | LDNS_FREE(line); | ||||
/* if last line was empty, we are now at feof, which is not | return s; | ||||
* always a parse error (happens when for instance last line | |||||
* was a comment) | |||||
*/ | |||||
return LDNS_STATUS_SYNTAX_ERR; | |||||
} | } | ||||
/* we can have the situation, where we've read ok, but still got | |||||
* no bytes to play with, in this case size is 0 | |||||
*/ | |||||
if (size == 0) { | |||||
LDNS_FREE(line); | |||||
return LDNS_STATUS_SYNTAX_EMPTY; | |||||
} | |||||
if (strncmp(line, "$ORIGIN", 7) == 0 && isspace((unsigned char)line[7])) { | if (strncmp(line, "$ORIGIN", 7) == 0 && isspace((unsigned char)line[7])) { | ||||
if (*origin) { | if (*origin) { | ||||
ldns_rdf_deep_free(*origin); | ldns_rdf_deep_free(*origin); | ||||
*origin = NULL; | *origin = NULL; | ||||
} | } | ||||
tmp = ldns_rdf_new_frm_str(LDNS_RDF_TYPE_DNAME, | tmp = ldns_rdf_new_frm_str(LDNS_RDF_TYPE_DNAME, | ||||
ldns_strip_ws(line + 8)); | ldns_strip_ws(line + 8)); | ||||
if (!tmp) { | if (!tmp) { | ||||
Show All 11 Lines | if (strncmp(line, "$ORIGIN", 7) == 0 && isspace((unsigned char)line[7])) { | ||||
s = LDNS_STATUS_SYNTAX_TTL; | s = LDNS_STATUS_SYNTAX_TTL; | ||||
} else if (strncmp(line, "$INCLUDE", 8) == 0) { | } else if (strncmp(line, "$INCLUDE", 8) == 0) { | ||||
s = LDNS_STATUS_SYNTAX_INCLUDE; | s = LDNS_STATUS_SYNTAX_INCLUDE; | ||||
} else if (!*ldns_strip_ws(line)) { | } else if (!*ldns_strip_ws(line)) { | ||||
LDNS_FREE(line); | LDNS_FREE(line); | ||||
return LDNS_STATUS_SYNTAX_EMPTY; | return LDNS_STATUS_SYNTAX_EMPTY; | ||||
} else { | } else { | ||||
if (origin && *origin) { | if (origin && *origin) { | ||||
s = ldns_rr_new_frm_str(&rr, (const char*) line, ttl, *origin, prev); | s = ldns_rr_new_frm_str_internal(&rr, (const char*)line, | ||||
ttl, *origin, prev, false, explicit_ttl); | |||||
} else { | } else { | ||||
s = ldns_rr_new_frm_str(&rr, (const char*) line, ttl, NULL, prev); | s = ldns_rr_new_frm_str_internal(&rr, (const char*)line, | ||||
ttl, NULL, prev, false, explicit_ttl); | |||||
} | } | ||||
} | } | ||||
LDNS_FREE(line); | LDNS_FREE(line); | ||||
if (s == LDNS_STATUS_OK) { | if (s == LDNS_STATUS_OK) { | ||||
if (newrr) { | if (newrr) { | ||||
*newrr = rr; | *newrr = rr; | ||||
} else { | } else { | ||||
/* Just testing if it would parse? */ | /* Just testing if it would parse? */ | ||||
ldns_rr_free(rr); | ldns_rr_free(rr); | ||||
} | } | ||||
} | } | ||||
return s; | return s; | ||||
} | } | ||||
ldns_status | |||||
ldns_rr_new_frm_fp_l(ldns_rr **newrr, FILE *fp, uint32_t *default_ttl, | |||||
ldns_rdf **origin, ldns_rdf **prev, int *line_nr) | |||||
{ | |||||
return _ldns_rr_new_frm_fp_l_internal(newrr, fp, default_ttl, origin, | |||||
prev, line_nr, NULL); | |||||
} | |||||
void | void | ||||
ldns_rr_set_owner(ldns_rr *rr, ldns_rdf *owner) | ldns_rr_set_owner(ldns_rr *rr, ldns_rdf *owner) | ||||
{ | { | ||||
rr->_owner = owner; | rr->_owner = owner; | ||||
} | } | ||||
void | void | ||||
ldns_rr_set_question(ldns_rr *rr, bool question) | ldns_rr_set_question(ldns_rr *rr, bool question) | ||||
Show All 28 Lines | |||||
ldns_rdf * | ldns_rdf * | ||||
ldns_rr_set_rdf(ldns_rr *rr, const ldns_rdf *f, size_t position) | ldns_rr_set_rdf(ldns_rr *rr, const ldns_rdf *f, size_t position) | ||||
{ | { | ||||
size_t rd_count; | size_t rd_count; | ||||
ldns_rdf *pop; | ldns_rdf *pop; | ||||
rd_count = ldns_rr_rd_count(rr); | rd_count = ldns_rr_rd_count(rr); | ||||
if (position < rd_count) { | if (position < rd_count) { | ||||
/* dicard the old one */ | /* discard the old one */ | ||||
pop = rr->_rdata_fields[position]; | pop = rr->_rdata_fields[position]; | ||||
rr->_rdata_fields[position] = (ldns_rdf*)f; | rr->_rdata_fields[position] = (ldns_rdf*)f; | ||||
return pop; | return pop; | ||||
} else { | } else { | ||||
return NULL; | return NULL; | ||||
} | } | ||||
} | } | ||||
▲ Show 20 Lines • Show All 337 Lines • ▼ Show 20 Lines | ldns_rr_list_pop_rr(ldns_rr_list *rr_list) | ||||
if(cap > LDNS_RRLIST_INIT && rr_count-1 <= cap/2) { | if(cap > LDNS_RRLIST_INIT && rr_count-1 <= cap/2) { | ||||
ldns_rr** a; | ldns_rr** a; | ||||
cap /= 2; | cap /= 2; | ||||
a = LDNS_XREALLOC(rr_list->_rrs, ldns_rr *, cap); | a = LDNS_XREALLOC(rr_list->_rrs, ldns_rr *, cap); | ||||
if(a) { | if(a) { | ||||
rr_list->_rrs = a; | rr_list->_rrs = a; | ||||
rr_list->_rr_capacity = cap; | rr_list->_rr_capacity = cap; | ||||
} | } | ||||
/* if the realloc fails, the capacity for the list remains unchanged */ | |||||
} | } | ||||
ldns_rr_list_set_rr_count(rr_list, rr_count - 1); | ldns_rr_list_set_rr_count(rr_list, rr_count - 1); | ||||
return pop; | return pop; | ||||
} | } | ||||
ldns_rr_list * | ldns_rr_list * | ||||
▲ Show 20 Lines • Show All 111 Lines • ▼ Show 20 Lines | if (ldns_rr_get_type(rr) != LDNS_RR_TYPE_RRSIG) { | ||||
return false; | return false; | ||||
} | } | ||||
} | } | ||||
if (ldns_rdf_compare(ldns_rr_owner(last), | if (ldns_rdf_compare(ldns_rr_owner(last), | ||||
ldns_rr_owner(rr)) != 0) { | ldns_rr_owner(rr)) != 0) { | ||||
return false; | return false; | ||||
} | } | ||||
/* ok, still alive - check if the rr already | /* ok, still alive - check if the rr already | ||||
* exists - if so, dont' add it */ | * exists - if so, don't add it */ | ||||
for(i = 0; i < rr_count; i++) { | for(i = 0; i < rr_count; i++) { | ||||
if(ldns_rr_compare( | if(ldns_rr_compare( | ||||
ldns_rr_list_rr(rr_list, i), rr) == 0) { | ldns_rr_list_rr(rr_list, i), rr) == 0) { | ||||
return false; | return false; | ||||
} | } | ||||
} | } | ||||
/* it's safe, push it */ | /* it's safe, push it */ | ||||
return ldns_rr_list_push_rr(rr_list, rr); | return ldns_rr_list_push_rr(rr_list, rr); | ||||
▲ Show 20 Lines • Show All 630 Lines • ▼ Show 20 Lines | |||||
#ifdef RRTYPE_OPENPGPKEY | #ifdef RRTYPE_OPENPGPKEY | ||||
static const ldns_rdf_type type_openpgpkey_wireformat[] = { | static const ldns_rdf_type type_openpgpkey_wireformat[] = { | ||||
LDNS_RDF_TYPE_B64 | LDNS_RDF_TYPE_B64 | ||||
}; | }; | ||||
#endif | #endif | ||||
static const ldns_rdf_type type_csync_wireformat[] = { | static const ldns_rdf_type type_csync_wireformat[] = { | ||||
LDNS_RDF_TYPE_INT32, LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_NSEC | LDNS_RDF_TYPE_INT32, LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_NSEC | ||||
}; | }; | ||||
static const ldns_rdf_type type_zonemd_wireformat[] = { | |||||
LDNS_RDF_TYPE_INT32, | |||||
LDNS_RDF_TYPE_INT8, LDNS_RDF_TYPE_INT8, LDNS_RDF_TYPE_HEX | |||||
}; | |||||
#ifdef RRTYPE_SVCB_HTTPS | |||||
static const ldns_rdf_type type_svcb_wireformat[] = { | |||||
LDNS_RDF_TYPE_INT16, | |||||
LDNS_RDF_TYPE_DNAME, | |||||
LDNS_RDF_TYPE_SVCPARAMS | |||||
}; | |||||
#endif | |||||
/* nsec3 is some vars, followed by same type of data of nsec */ | /* nsec3 is some vars, followed by same type of data of nsec */ | ||||
static const ldns_rdf_type type_nsec3_wireformat[] = { | static const ldns_rdf_type type_nsec3_wireformat[] = { | ||||
/* LDNS_RDF_TYPE_NSEC3_VARS, LDNS_RDF_TYPE_NSEC3_NEXT_OWNER, LDNS_RDF_TYPE_NSEC*/ | /* LDNS_RDF_TYPE_NSEC3_VARS, LDNS_RDF_TYPE_NSEC3_NEXT_OWNER, LDNS_RDF_TYPE_NSEC*/ | ||||
LDNS_RDF_TYPE_INT8, LDNS_RDF_TYPE_INT8, LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_NSEC3_SALT, LDNS_RDF_TYPE_NSEC3_NEXT_OWNER, LDNS_RDF_TYPE_NSEC | LDNS_RDF_TYPE_INT8, LDNS_RDF_TYPE_INT8, LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_NSEC3_SALT, LDNS_RDF_TYPE_NSEC3_NEXT_OWNER, LDNS_RDF_TYPE_NSEC | ||||
}; | }; | ||||
static const ldns_rdf_type type_nsec3param_wireformat[] = { | static const ldns_rdf_type type_nsec3param_wireformat[] = { | ||||
/* LDNS_RDF_TYPE_NSEC3_PARAMS_VARS*/ | /* LDNS_RDF_TYPE_NSEC3_PARAMS_VARS*/ | ||||
▲ Show 20 Lines • Show All 63 Lines • ▼ Show 20 Lines | static const ldns_rdf_type type_uri_wireformat[] = { | ||||
LDNS_RDF_TYPE_INT16, | LDNS_RDF_TYPE_INT16, | ||||
LDNS_RDF_TYPE_LONG_STR | LDNS_RDF_TYPE_LONG_STR | ||||
}; | }; | ||||
static const ldns_rdf_type type_caa_wireformat[] = { | static const ldns_rdf_type type_caa_wireformat[] = { | ||||
LDNS_RDF_TYPE_INT8, | LDNS_RDF_TYPE_INT8, | ||||
LDNS_RDF_TYPE_TAG, | LDNS_RDF_TYPE_TAG, | ||||
LDNS_RDF_TYPE_LONG_STR | LDNS_RDF_TYPE_LONG_STR | ||||
}; | }; | ||||
#ifdef RRTYPE_DOA | |||||
static const ldns_rdf_type type_doa_wireformat[] = { | |||||
LDNS_RDF_TYPE_INT32, | |||||
LDNS_RDF_TYPE_INT32, | |||||
LDNS_RDF_TYPE_INT8, | |||||
LDNS_RDF_TYPE_STR, | |||||
LDNS_RDF_TYPE_B64 | |||||
}; | |||||
#endif | |||||
#ifdef RRTYPE_AMTRELAY | |||||
static const ldns_rdf_type type_amtrelay_wireformat[] = { | |||||
LDNS_RDF_TYPE_AMTRELAY | |||||
}; | |||||
#endif | |||||
/** \endcond */ | /** \endcond */ | ||||
/** \cond */ | /** \cond */ | ||||
/* All RR's defined in 1035 are well known and can thus | /* All RR's defined in 1035 are well known and can thus | ||||
* be compressed. See RFC3597. These RR's are: | * be compressed. See RFC3597. These RR's are: | ||||
* CNAME HINFO MB MD MF MG MINFO MR MX NULL NS PTR SOA TXT | * CNAME HINFO MB MD MF MG MINFO MR MX NULL NS PTR SOA TXT | ||||
*/ | */ | ||||
static ldns_rr_descriptor rdata_field_descriptors[] = { | static ldns_rr_descriptor rdata_field_descriptors[] = { | ||||
▲ Show 20 Lines • Show All 135 Lines • ▼ Show 20 Lines | #endif | ||||
{LDNS_RR_TYPE_CDNSKEY, "CDNSKEY", 4, 4, type_dnskey_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, | {LDNS_RR_TYPE_CDNSKEY, "CDNSKEY", 4, 4, type_dnskey_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, | ||||
#ifdef RRTYPE_OPENPGPKEY | #ifdef RRTYPE_OPENPGPKEY | ||||
/* 61 */ | /* 61 */ | ||||
{LDNS_RR_TYPE_OPENPGPKEY, "OPENPGPKEY", 1, 1, type_openpgpkey_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, | {LDNS_RR_TYPE_OPENPGPKEY, "OPENPGPKEY", 1, 1, type_openpgpkey_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, | ||||
#else | #else | ||||
{LDNS_RR_TYPE_NULL, "TYPE61", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, | {LDNS_RR_TYPE_NULL, "TYPE61", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, | ||||
#endif | #endif | ||||
/* 62 */ | |||||
{LDNS_RR_TYPE_CSYNC, "CSYNC", 3, 3, type_csync_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, | {LDNS_RR_TYPE_CSYNC, "CSYNC", 3, 3, type_csync_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, | ||||
{LDNS_RR_TYPE_NULL, "TYPE63", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, | /* 63 */ | ||||
{LDNS_RR_TYPE_ZONEMD, "ZONEMD", 4, 4, type_zonemd_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, | |||||
#ifdef RRTYPE_SVCB_HTTPS | |||||
/* 64 */ | |||||
{LDNS_RR_TYPE_SVCB, "SVCB", 2, 3, type_svcb_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 1 }, | |||||
/* 65 */ | |||||
{LDNS_RR_TYPE_HTTPS, "HTTPS", 2, 3, type_svcb_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 1 }, | |||||
#else | |||||
{LDNS_RR_TYPE_NULL, "TYPE64", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, | {LDNS_RR_TYPE_NULL, "TYPE64", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, | ||||
{LDNS_RR_TYPE_NULL, "TYPE65", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, | {LDNS_RR_TYPE_NULL, "TYPE65", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, | ||||
#endif | |||||
{LDNS_RR_TYPE_NULL, "TYPE66", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, | {LDNS_RR_TYPE_NULL, "TYPE66", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, | ||||
{LDNS_RR_TYPE_NULL, "TYPE67", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, | {LDNS_RR_TYPE_NULL, "TYPE67", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, | ||||
{LDNS_RR_TYPE_NULL, "TYPE68", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, | {LDNS_RR_TYPE_NULL, "TYPE68", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, | ||||
{LDNS_RR_TYPE_NULL, "TYPE69", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, | {LDNS_RR_TYPE_NULL, "TYPE69", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, | ||||
{LDNS_RR_TYPE_NULL, "TYPE70", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, | {LDNS_RR_TYPE_NULL, "TYPE70", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, | ||||
{LDNS_RR_TYPE_NULL, "TYPE71", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, | {LDNS_RR_TYPE_NULL, "TYPE71", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, | ||||
{LDNS_RR_TYPE_NULL, "TYPE72", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, | {LDNS_RR_TYPE_NULL, "TYPE72", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, | ||||
{LDNS_RR_TYPE_NULL, "TYPE73", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, | {LDNS_RR_TYPE_NULL, "TYPE73", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, | ||||
▲ Show 20 Lines • Show All 216 Lines • ▼ Show 20 Lines | #endif | ||||
{LDNS_RR_TYPE_CAA, "CAA", 3, 3, type_caa_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, | {LDNS_RR_TYPE_CAA, "CAA", 3, 3, type_caa_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, | ||||
#ifdef RRTYPE_AVC | #ifdef RRTYPE_AVC | ||||
/* 258 */ | /* 258 */ | ||||
{LDNS_RR_TYPE_AVC, "AVC", 1, 0, NULL, LDNS_RDF_TYPE_STR, LDNS_RR_NO_COMPRESS, 0 }, | {LDNS_RR_TYPE_AVC, "AVC", 1, 0, NULL, LDNS_RDF_TYPE_STR, LDNS_RR_NO_COMPRESS, 0 }, | ||||
#else | #else | ||||
{LDNS_RR_TYPE_NULL, "TYPE258", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, | {LDNS_RR_TYPE_NULL, "TYPE258", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, | ||||
#endif | #endif | ||||
#ifdef RRTYPE_DOA | |||||
/* 259 */ | |||||
{LDNS_RR_TYPE_DOA, "DOA", 5, 5, type_doa_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, | |||||
#else | |||||
{LDNS_RR_TYPE_NULL, "TYPE259", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, | |||||
#endif | |||||
#ifdef RRTYPE_AMTRELAY | |||||
/* 260 */ | |||||
{LDNS_RR_TYPE_AMTRELAY, "AMTRELAY", 1, 1, type_amtrelay_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, | |||||
#else | |||||
{LDNS_RR_TYPE_NULL, "TYPE260", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, | |||||
#endif | |||||
/* split in array, no longer contiguous */ | /* split in array, no longer contiguous */ | ||||
#ifdef RRTYPE_TA | #ifdef RRTYPE_TA | ||||
/* 32768 */ | /* 32768 */ | ||||
{LDNS_RR_TYPE_TA, "TA", 4, 4, type_ds_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, | {LDNS_RR_TYPE_TA, "TA", 4, 4, type_ds_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, | ||||
#else | #else | ||||
{LDNS_RR_TYPE_NULL, "TYPE32768", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, | {LDNS_RR_TYPE_NULL, "TYPE32768", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, | ||||
Show All 9 Lines | |||||
*/ | */ | ||||
#define LDNS_RDATA_FIELD_DESCRIPTORS_COUNT \ | #define LDNS_RDATA_FIELD_DESCRIPTORS_COUNT \ | ||||
(sizeof(rdata_field_descriptors)/sizeof(rdata_field_descriptors[0])) | (sizeof(rdata_field_descriptors)/sizeof(rdata_field_descriptors[0])) | ||||
/*---------------------------------------------------------------------------* | /*---------------------------------------------------------------------------* | ||||
* The functions below return an bitmap RDF with the space required to set | * The functions below return an bitmap RDF with the space required to set | ||||
* or unset all known RR types. Arguably these functions are better situated | * or unset all known RR types. Arguably these functions are better situated | ||||
* in rdata.c, however for the space calculation it is necesarry to walk | * in rdata.c, however for the space calculation it is necessary to walk | ||||
* through rdata_field_descriptors which is not easily possible from anywhere | * through rdata_field_descriptors which is not easily possible from anywhere | ||||
* other than rr.c where it is declared static. | * other than rr.c where it is declared static. | ||||
* | * | ||||
* Alternatively rr.c could have provided an iterator for rr_type or | * Alternatively rr.c could have provided an iterator for rr_type or | ||||
* rdf_descriptors, but this seemed overkill for internal use only. | * rdf_descriptors, but this seemed overkill for internal use only. | ||||
*/ | */ | ||||
static ldns_rr_descriptor* rdata_field_descriptors_end = | static ldns_rr_descriptor* rdata_field_descriptors_end = | ||||
&rdata_field_descriptors[LDNS_RDATA_FIELD_DESCRIPTORS_COUNT]; | &rdata_field_descriptors[LDNS_RDATA_FIELD_DESCRIPTORS_COUNT]; | ||||
▲ Show 20 Lines • Show All 61 Lines • ▼ Show 20 Lines | for (i = 0; i < 256; i++) { | ||||
if (windows[i]) { | if (windows[i]) { | ||||
sz += windows[i] / 8 + 3; | sz += windows[i] / 8 + 3; | ||||
} | } | ||||
} | } | ||||
if (sz > 0) { | if (sz > 0) { | ||||
/* Format rdf data according RFC3845 Section 2.1.2 (see above) | /* Format rdf data according RFC3845 Section 2.1.2 (see above) | ||||
*/ | */ | ||||
dptr = data = LDNS_XMALLOC(uint8_t, sz); | dptr = data = LDNS_XMALLOC(uint8_t, sz); | ||||
memset(data, value, sz); | |||||
if (!data) { | if (!data) { | ||||
return LDNS_STATUS_MEM_ERR; | return LDNS_STATUS_MEM_ERR; | ||||
} | } | ||||
memset(data, value, sz); | |||||
for (i = 0; i < 256; i++) { | for (i = 0; i < 256; i++) { | ||||
if (windows[i]) { | if (windows[i]) { | ||||
*dptr++ = (uint8_t)i; | *dptr++ = (uint8_t)i; | ||||
*dptr++ = (uint8_t)(windows[i] / 8 + 1); | *dptr++ = (uint8_t)(windows[i] / 8 + 1); | ||||
dptr += dptr[-1]; | dptr += dptr[-1]; | ||||
} | } | ||||
} | } | ||||
} | } | ||||
▲ Show 20 Lines • Show All 179 Lines • Show Last 20 Lines |