static int
rdata_hex_to_string(buffer_type *output, rdata_atom_type rdata,
rr_type* ATTR_UNUSED(rr))
{
if(rdata_atom_size(rdata) == 0) {
/* single zero represents empty buffer, such as CDS deletes */
buffer_printf(output, "0");
} else {
hex_to_string(output, rdata_atom_data(rdata), rdata_atom_size(rdata));
}
return 1;
}
static int
rdata_hexlen_to_string(buffer_type *output, rdata_atom_type rdata,
rr_type* ATTR_UNUSED(rr))
{
if(rdata_atom_size(rdata) <= 1) {
/* NSEC3 salt hex can be empty */
buffer_printf(output, "-");
return 1;
}
hex_to_string(output, rdata_atom_data(rdata)+1, rdata_atom_size(rdata)-1);
return 1;
}
static int
rdata_texts_to_string(buffer_type *output, rdata_atom_type rdata,
rr_type* ATTR_UNUSED(rr))
{
uint16_t pos = 0;
const uint8_t *data = rdata_atom_data(rdata);
uint16_t length = rdata_atom_size(rdata);
size_t i;
while (pos < length && pos + data[pos] < length) {
buffer_printf(output, "\"");
for (i = 1; i <= data[pos]; ++i) {
char ch = (char) data[pos + i];
if (isprint((unsigned char)ch)) {
if (ch == '"' || ch == '\\') {
buffer_printf(output, "\\");
}
buffer_printf(output, "%c", ch);
} else {
buffer_printf(output, "\\%03u", (unsigned) data[pos+i]);
}
}
pos += data[pos]+1;
buffer_printf(output, pos < length?"\" ":"\"");
}
return 1;
}
static int
rdata_hex_to_string(buffer_type *output, rdata_atom_type rdata,
rr_type* ATTR_UNUSED(rr))
{
hex_to_string(output, rdata_atom_data(rdata), rdata_atom_size(rdata));
return 1;
}
int
packet_encode_rr(query_type *q, domain_type *owner, rr_type *rr)
{
size_t truncation_mark;
uint16_t rdlength = 0;
size_t rdlength_pos;
uint16_t j;
assert(q);
assert(owner);
assert(rr);
/*
* If the record does not in fit in the packet the packet size
* will be restored to the mark.
*/
truncation_mark = buffer_position(q->packet);
encode_dname(q, owner);
buffer_write_u16(q->packet, rr->type);
buffer_write_u16(q->packet, rr->klass);
buffer_write_u32(q->packet, rr->ttl);
/* Reserve space for rdlength. */
rdlength_pos = buffer_position(q->packet);
buffer_skip(q->packet, sizeof(rdlength));
for (j = 0; j < rr->rdata_count; ++j) {
switch (rdata_atom_wireformat_type(rr->type, j)) {
case RDATA_WF_COMPRESSED_DNAME:
encode_dname(q, rdata_atom_domain(rr->rdatas[j]));
break;
case RDATA_WF_UNCOMPRESSED_DNAME:
{
const dname_type *dname = domain_dname(
rdata_atom_domain(rr->rdatas[j]));
buffer_write(q->packet,
dname_name(dname), dname->name_size);
break;
}
default:
buffer_write(q->packet,
rdata_atom_data(rr->rdatas[j]),
rdata_atom_size(rr->rdatas[j]));
break;
}
}
if (!query_overflow(q)) {
rdlength = (buffer_position(q->packet) - rdlength_pos
- sizeof(rdlength));
buffer_write_u16_at(q->packet, rdlength_pos, rdlength);
return 1;
} else {
buffer_set_position(q->packet, truncation_mark);
query_clear_dname_offsets(q, truncation_mark);
assert(!query_overflow(q));
return 0;
}
}
static int
rdata_nsap_to_string(buffer_type *output, rdata_atom_type rdata,
rr_type* ATTR_UNUSED(rr))
{
buffer_printf(output, "0x");
hex_to_string(output, rdata_atom_data(rdata), rdata_atom_size(rdata));
return 1;
}
static int
rdata_unknown_to_string(buffer_type *output, rdata_atom_type rdata,
rr_type* ATTR_UNUSED(rr))
{
uint16_t size = rdata_atom_size(rdata);
buffer_printf(output, "\\# %lu ", (unsigned long) size);
hex_to_string(output, rdata_atom_data(rdata), size);
return 1;
}
/** add an rdata (uncompressed) to the destination */
static size_t
add_rdata(rr_type* rr, unsigned i, uint8_t* buf, size_t buflen)
{
switch(rdata_atom_wireformat_type(rr->type, i)) {
case RDATA_WF_COMPRESSED_DNAME:
case RDATA_WF_UNCOMPRESSED_DNAME:
{
const dname_type* dname = domain_dname(
rdata_atom_domain(rr->rdatas[i]));
if(dname->name_size > buflen)
return 0;
memmove(buf, dname_name(dname), dname->name_size);
return dname->name_size;
}
default:
break;
}
if(rdata_atom_size(rr->rdatas[i]) > buflen)
return 0;
memmove(buf, rdata_atom_data(rr->rdatas[i]),
rdata_atom_size(rr->rdatas[i]));
return rdata_atom_size(rr->rdatas[i]);
}
static void
add_rdata_to_recyclebin(namedb_type* db, rr_type* rr)
{
/* add rdatas to recycle bin. */
size_t i;
for(i=0; i<rr->rdata_count; i++)
{
if(!rdata_atom_is_domain(rr->type, i))
region_recycle(db->region, rr->rdatas[i].data,
rdata_atom_size(rr->rdatas[i])
+ sizeof(uint16_t));
}
region_recycle(db->region, rr->rdatas,
sizeof(rdata_atom_type)*rr->rdata_count);
}
static int
rdata_base64_to_string(buffer_type *output, rdata_atom_type rdata,
rr_type* ATTR_UNUSED(rr))
{
int length;
size_t size = rdata_atom_size(rdata);
if(size == 0)
return 1;
buffer_reserve(output, size * 2 + 1);
length = __b64_ntop(rdata_atom_data(rdata), size,
(char *) buffer_current(output), size * 2);
if (length > 0) {
buffer_skip(output, length);
}
return length != -1;
}
size_t
rdata_maximum_wireformat_size(rrtype_descriptor_type *descriptor,
size_t rdata_count,
rdata_atom_type *rdatas)
{
size_t result = 0;
size_t i;
for (i = 0; i < rdata_count; ++i) {
if (rdata_atom_is_domain(descriptor->type, i)) {
result += domain_dname(rdata_atom_domain(rdatas[i]))->name_size;
} else {
result += rdata_atom_size(rdatas[i]);
}
}
return result;
}
static int
rdata_nxt_to_string(buffer_type *output, rdata_atom_type rdata,
rr_type* ATTR_UNUSED(rr))
{
size_t i;
uint8_t *bitmap = rdata_atom_data(rdata);
size_t bitmap_size = rdata_atom_size(rdata);
for (i = 0; i < bitmap_size * 8; ++i) {
if (get_bit(bitmap, i)) {
buffer_printf(output, "%s ", rrtype_to_string(i));
}
}
buffer_skip(output, -1);
return 1;
}
static int
rdata_base64_to_string(buffer_type *output, rdata_atom_type rdata,
rr_type* ATTR_UNUSED(rr))
{
int length;
size_t size = rdata_atom_size(rdata);
if(size == 0) {
/* single zero represents empty buffer */
buffer_write(output, "0", 1);
return 1;
}
buffer_reserve(output, size * 2 + 1);
length = b64_ntop(rdata_atom_data(rdata), size,
(char *) buffer_current(output), size * 2);
if (length > 0) {
buffer_skip(output, length);
}
return length != -1;
}
static int
rdata_apl_to_string(buffer_type *output, rdata_atom_type rdata,
rr_type* ATTR_UNUSED(rr))
{
int result = 0;
buffer_type packet;
buffer_create_from(
&packet, rdata_atom_data(rdata), rdata_atom_size(rdata));
if (buffer_available(&packet, 4)) {
uint16_t address_family = buffer_read_u16(&packet);
uint8_t prefix = buffer_read_u8(&packet);
uint8_t length = buffer_read_u8(&packet);
int negated = length & APL_NEGATION_MASK;
int af = -1;
length &= APL_LENGTH_MASK;
switch (address_family) {
case 1:
af = AF_INET;
break;
case 2:
af = AF_INET6;
break;
}
if (af != -1 && buffer_available(&packet, length)) {
char text_address[1000];
uint8_t address[128];
memset(address, 0, sizeof(address));
buffer_read(&packet, address, length);
if (inet_ntop(af, address, text_address, sizeof(text_address))) {
buffer_printf(output, "%s%d:%s/%d",
negated ? "!" : "",
(int) address_family,
text_address,
(int) prefix);
result = 1;
}
}
}
return result;
}
static int
rdata_base32_to_string(buffer_type *output, rdata_atom_type rdata,
rr_type* ATTR_UNUSED(rr))
{
int length;
size_t size = rdata_atom_size(rdata);
if(size == 0) {
buffer_write(output, "-", 1);
return 1;
}
size -= 1; /* remove length byte from count */
buffer_reserve(output, size * 2 + 1);
length = b32_ntop(rdata_atom_data(rdata)+1, size,
(char *) buffer_current(output), size * 2);
if (length > 0) {
buffer_skip(output, length);
}
return length != -1;
}
/*
* Compares two rdata arrays.
*
* Returns:
*
* zero if they are equal
* non-zero if not
*
*/
static int
zrdatacmp(uint16_t type, rr_type *a, rr_type *b)
{
int i = 0;
assert(a);
assert(b);
/* One is shorter than another */
if (a->rdata_count != b->rdata_count)
return 1;
/* Compare element by element */
for (i = 0; i < a->rdata_count; ++i) {
if (rdata_atom_is_domain(type, i)) {
if (rdata_atom_domain(a->rdatas[i])
!= rdata_atom_domain(b->rdatas[i]))
{
return 1;
}
} else if(rdata_atom_is_literal_domain(type, i)) {
if (rdata_atom_size(a->rdatas[i])
!= rdata_atom_size(b->rdatas[i]))
return 1;
if (!dname_equal_nocase(rdata_atom_data(a->rdatas[i]),
rdata_atom_data(b->rdatas[i]),
rdata_atom_size(a->rdatas[i])))
return 1;
} else {
if (rdata_atom_size(a->rdatas[i])
!= rdata_atom_size(b->rdatas[i]))
{
return 1;
}
if (memcmp(rdata_atom_data(a->rdatas[i]),
rdata_atom_data(b->rdatas[i]),
rdata_atom_size(a->rdatas[i])) != 0)
{
return 1;
}
}
}
/* Otherwise they are equal */
return 0;
}
int
rdata_atoms_to_unknown_string(buffer_type *output,
rrtype_descriptor_type *descriptor,
size_t rdata_count,
rdata_atom_type *rdatas)
{
size_t i;
size_t size =
rdata_maximum_wireformat_size(descriptor, rdata_count, rdatas);
buffer_printf(output, " \\# %lu ", (unsigned long) size);
for (i = 0; i < rdata_count; ++i) {
if (rdata_atom_is_domain(descriptor->type, i)) {
const dname_type *dname =
domain_dname(rdata_atom_domain(rdatas[i]));
hex_to_string(
output, dname_name(dname), dname->name_size);
} else {
hex_to_string(output, rdata_atom_data(rdatas[i]),
rdata_atom_size(rdatas[i]));
}
}
return 1;
}
static int
rdata_long_text_to_string(buffer_type *output, rdata_atom_type rdata,
rr_type* ATTR_UNUSED(rr))
{
const uint8_t *data = rdata_atom_data(rdata);
uint16_t length = rdata_atom_size(rdata);
size_t i;
buffer_printf(output, "\"");
for (i = 0; i < length; ++i) {
char ch = (char) data[i];
if (isprint((unsigned char)ch)) {
if (ch == '"' || ch == '\\') {
buffer_printf(output, "\\");
}
buffer_printf(output, "%c", ch);
} else {
buffer_printf(output, "\\%03u", (unsigned) data[i]);
}
}
buffer_printf(output, "\"");
return 1;
}
static int
rdata_nsec_to_string(buffer_type *output, rdata_atom_type rdata,
rr_type* ATTR_UNUSED(rr))
{
size_t saved_position = buffer_position(output);
buffer_type packet;
int insert_space = 0;
buffer_create_from(
&packet, rdata_atom_data(rdata), rdata_atom_size(rdata));
while (buffer_available(&packet, 2)) {
uint8_t window = buffer_read_u8(&packet);
uint8_t bitmap_size = buffer_read_u8(&packet);
uint8_t *bitmap = buffer_current(&packet);
int i;
if (!buffer_available(&packet, bitmap_size)) {
buffer_set_position(output, saved_position);
return 0;
}
for (i = 0; i < bitmap_size * 8; ++i) {
if (get_bit(bitmap, i)) {
buffer_printf(output,
"%s%s",
insert_space ? " " : "",
rrtype_to_string(
window * 256 + i));
insert_space = 1;
}
}
buffer_skip(&packet, bitmap_size);
}
return 1;
}
static int
rdata_services_to_string(buffer_type *output, rdata_atom_type rdata,
rr_type* ATTR_UNUSED(rr))
{
int result = 0;
buffer_type packet;
buffer_create_from(
&packet, rdata_atom_data(rdata), rdata_atom_size(rdata));
if (buffer_available(&packet, 1)) {
uint8_t protocol_number = buffer_read_u8(&packet);
ssize_t bitmap_size = buffer_remaining(&packet);
uint8_t *bitmap = buffer_current(&packet);
struct protoent *proto = getprotobynumber(protocol_number);
if (proto) {
int i;
buffer_printf(output, "%s", proto->p_name);
for (i = 0; i < bitmap_size * 8; ++i) {
if (get_bit(bitmap, i)) {
struct servent *service = getservbyport((int)htons(i), proto->p_name);
if (service) {
buffer_printf(output, " %s", service->s_name);
} else {
buffer_printf(output, " %d", i);
}
}
}
buffer_skip(&packet, bitmap_size);
result = 1;
}
}
return result;
}
static int
add_RR(namedb_type* db, const dname_type* dname,
uint16_t type, uint16_t klass, uint32_t ttl,
buffer_type* packet, size_t rdatalen, zone_type *zone,
int is_axfr)
{
domain_type* domain;
rrset_type* rrset;
rdata_atom_type *rdatas;
rr_type *rrs_old;
ssize_t rdata_num;
int rrnum;
domain = domain_table_find(db->domains, dname);
if(!domain) {
/* create the domain */
domain = domain_table_insert(db->domains, dname);
}
rrset = domain_find_rrset(domain, zone, type);
if(!rrset) {
/* create the rrset */
rrset = region_alloc(db->region, sizeof(rrset_type));
if(!rrset) {
log_msg(LOG_ERR, "out of memory, %s:%d", __FILE__, __LINE__);
exit(1);
}
rrset->zone = zone;
rrset->rrs = 0;
rrset->rr_count = 0;
domain_add_rrset(domain, rrset);
}
/* dnames in rdata are normalized, conform RFC 4035,
* Section 6.2
*/
rdata_num = rdata_wireformat_to_rdata_atoms(
db->region, db->domains, type, rdatalen, packet, &rdatas);
if(rdata_num == -1) {
log_msg(LOG_ERR, "diff: bad rdata for %s",
dname_to_string(dname,0));
return 0;
}
rrnum = find_rr_num(rrset, type, klass, rdatas, rdata_num);
if(rrnum != -1) {
DEBUG(DEBUG_XFRD, 2, (LOG_ERR, "diff: RR <%s, %s> already exists",
dname_to_string(dname,0), rrtype_to_string(type)));
/* ignore already existing RR: lenient accepting of messages */
return 1;
}
/* re-alloc the rrs and add the new */
rrs_old = rrset->rrs;
rrset->rrs = region_alloc(db->region,
(rrset->rr_count+1) * sizeof(rr_type));
if(!rrset->rrs) {
log_msg(LOG_ERR, "out of memory, %s:%d", __FILE__, __LINE__);
exit(1);
}
if(rrs_old)
memcpy(rrset->rrs, rrs_old, rrset->rr_count * sizeof(rr_type));
region_recycle(db->region, rrs_old, sizeof(rr_type) * rrset->rr_count);
rrset->rr_count ++;
rrset->rrs[rrset->rr_count - 1].owner = domain;
rrset->rrs[rrset->rr_count - 1].rdatas = rdatas;
rrset->rrs[rrset->rr_count - 1].ttl = ttl;
rrset->rrs[rrset->rr_count - 1].type = type;
rrset->rrs[rrset->rr_count - 1].klass = klass;
rrset->rrs[rrset->rr_count - 1].rdata_count = rdata_num;
/* see if it is a SOA */
if(domain == zone->apex) {
if(type == TYPE_SOA) {
uint32_t soa_minimum;
zone->soa_rrset = rrset;
zone->updated = 1;
/* BUG #103 tweaked SOA ttl value */
if(zone->soa_nx_rrset == 0) {
zone->soa_nx_rrset = region_alloc(db->region,
sizeof(rrset_type));
if(!zone->soa_nx_rrset) {
log_msg(LOG_ERR, "out of memory, %s:%d",
__FILE__, __LINE__);
exit(1);
}
zone->soa_nx_rrset->rr_count = 1;
zone->soa_nx_rrset->next = 0;
zone->soa_nx_rrset->zone = zone;
zone->soa_nx_rrset->rrs = region_alloc(db->region,
sizeof(rr_type));
if(!zone->soa_nx_rrset->rrs) {
log_msg(LOG_ERR, "out of memory, %s:%d",
__FILE__, __LINE__);
exit(1);
}
}
memcpy(zone->soa_nx_rrset->rrs, rrset->rrs, sizeof(rr_type));
memcpy(&soa_minimum, rdata_atom_data(rrset->rrs->rdatas[6]),
rdata_atom_size(rrset->rrs->rdatas[6]));
if (rrset->rrs->ttl > ntohl(soa_minimum)) {
rrset->zone->soa_nx_rrset->rrs[0].ttl = ntohl(soa_minimum);
}
domain->has_SOA = 1;
}
if(type == TYPE_NS) {
zone->ns_rrset = rrset;
}
if(type == TYPE_RRSIG) {
int i;
for (i = 0; i < rrset->rr_count; ++i) {
if (rr_rrsig_type_covered(&rrset->rrs[i]) == TYPE_DNSKEY) {
zone->is_secure = 1;
break;
}
}
}
}
#ifdef NSEC3
#ifndef FULL_PREHASH
if ((type == TYPE_NSEC3) &&
(rrset->rr_count == 1)) {
/* NSEC3 RRset just added */
if (0 != namedb_add_nsec3_domain(db, domain, zone))
return 0;
}
if (is_axfr == 0) {
struct domain *parent = domain;
do {
if (0 != namedb_add_nsec3_mod_domain(db, parent))
return 0;
parent = parent->parent;
} while (parent != zone->apex->parent);
}
#else
(void)is_axfr;
#endif /* !FULL_PREHASH */
#endif /* NSEC3 */
return 1;
}
static rrset_type *
read_rrset(namedb_type *db,
uint32_t domain_count, domain_type **domains,
uint32_t zone_count, zone_type **zones)
{
rrset_type *rrset;
int i, j;
domain_type *owner;
uint16_t type;
uint16_t klass;
uint32_t soa_minimum;
owner = read_domain(db, domain_count, domains);
if (!owner)
return NULL;
rrset = (rrset_type *) region_alloc(db->region, sizeof(rrset_type));
rrset->zone = read_zone(db, zone_count, zones);
if (!rrset->zone)
return NULL;
if (fread(&type, sizeof(type), 1, db->fd) != 1)
return NULL;
type = ntohs(type);
if (fread(&klass, sizeof(klass), 1, db->fd) != 1)
return NULL;
klass = ntohs(klass);
if (fread(&rrset->rr_count, sizeof(rrset->rr_count), 1, db->fd) != 1)
return NULL;
rrset->rr_count = ntohs(rrset->rr_count);
rrset->rrs = (rr_type *) region_alloc(
db->region, rrset->rr_count * sizeof(rr_type));
assert(rrset->rr_count > 0);
for (i = 0; i < rrset->rr_count; ++i) {
rr_type *rr = &rrset->rrs[i];
rr->owner = owner;
rr->type = type;
rr->klass = klass;
if (fread(&rr->rdata_count, sizeof(rr->rdata_count), 1, db->fd) != 1)
return NULL;
rr->rdata_count = ntohs(rr->rdata_count);
rr->rdatas = (rdata_atom_type *) region_alloc(
db->region, rr->rdata_count * sizeof(rdata_atom_type));
if (fread(&rr->ttl, sizeof(rr->ttl), 1, db->fd) != 1)
return NULL;
rr->ttl = ntohl(rr->ttl);
for (j = 0; j < rr->rdata_count; ++j) {
if (!read_rdata_atom(db, rr->type, j, domain_count, domains, &rr->rdatas[j]))
return NULL;
}
}
domain_add_rrset(owner, rrset);
if (rrset_rrtype(rrset) == TYPE_SOA) {
assert(owner == rrset->zone->apex);
rrset->zone->soa_rrset = rrset;
/* BUG #103 add another soa with a tweaked ttl */
rrset->zone->soa_nx_rrset = region_alloc(db->region, sizeof(rrset_type));
rrset->zone->soa_nx_rrset->rrs =
region_alloc(db->region, rrset->rr_count * sizeof(rr_type));
memcpy(rrset->zone->soa_nx_rrset->rrs, rrset->rrs, sizeof(rr_type));
rrset->zone->soa_nx_rrset->rr_count = 1;
rrset->zone->soa_nx_rrset->next = 0;
/* also add a link to the zone */
rrset->zone->soa_nx_rrset->zone = rrset->zone;
/* check the ttl and MINIMUM value and set accordinly */
memcpy(&soa_minimum, rdata_atom_data(rrset->rrs->rdatas[6]),
rdata_atom_size(rrset->rrs->rdatas[6]));
if (rrset->rrs->ttl > ntohl(soa_minimum)) {
rrset->zone->soa_nx_rrset->rrs[0].ttl = ntohl(soa_minimum);
}
owner->has_SOA = 1;
} else if (owner == rrset->zone->apex
&& rrset_rrtype(rrset) == TYPE_NS)
{
rrset->zone->ns_rrset = rrset;
}
#ifdef NSEC3
#ifndef FULL_PREHASH
else if (type == TYPE_NSEC3) {
if (0 != namedb_add_nsec3_domain(db, owner, rrset->zone)) {
return NULL;
}
}
#endif /* !FULL_PREHASH */
#endif /* NSEC3 */
if (rrset_rrtype(rrset) == TYPE_RRSIG && owner == rrset->zone->apex) {
for (i = 0; i < rrset->rr_count; ++i) {
if (rr_rrsig_type_covered(&rrset->rrs[i]) == TYPE_DNSKEY) {
rrset->zone->is_secure = 1;
break;
}
}
}
return rrset;
}
