struct zonefile *
zonefile_init_fname(const char *fname)
{
struct zonefile *z = my_calloc(1, sizeof(struct zonefile));
size_t len_fname = strlen(fname);
if (len_fname >= 3 &&
fname[len_fname - 3] == '.' &&
fname[len_fname - 2] == 'g' &&
fname[len_fname - 1] == 'z')
{
ubuf *u = ubuf_new();
ubuf_add_cstr(u, "zcat ");
ubuf_add_cstr(u, fname);
z->fp = popen(ubuf_cstr(u), "r");
z->is_pipe = true;
ubuf_destroy(&u);
} else {
z->fp = fopen(fname, "r");
}
if (z->fp == NULL)
return (NULL);
z->valid = true;
if (read_soa(z) != LDNS_STATUS_OK)
zonefile_destroy(&z);
return (z);
}
static size_t
rdata_to_str_string(const uint8_t *src, ubuf *u) {
size_t len;
uint8_t oclen;
oclen = *src++;
ubuf_add_cstr(u, "\"");
len = oclen;
while (len--) {
uint8_t c;
c = *src++;
if (c == '"') {
ubuf_add_cstr(u, "\\\"");
} else if (c == '\\') {
ubuf_add_cstr(u, "\\\\");
} else if (c >= ' ' && c <= '~') {
ubuf_append(u, &c, 1);
} else {
ubuf_add_fmt(u, "\\%.3d", c);
}
}
ubuf_add_cstr(u, "\" ");
return (oclen + 1); /* number of bytes consumed from src */
}
static void *
thr_producer(void *arg)
{
struct producer *p = (struct producer *) arg;
memset(&p->pstat, 0, sizeof(p->pstat));
for (unsigned i = 0; i < p->num_messages; i++) {
fstrm_res res;
size_t len = 0;
uint8_t *message = NULL;
ubuf *u = ubuf_init(512);
unsigned ndups = (p->pstat.count_generated % 4) + 1;
for (unsigned j = 0; j < ndups; j++)
ubuf_add_cstr(u, test_string);
ubuf_detach(u, &message, &len);
ubuf_destroy(&u);
res = fstrm_iothr_submit(p->iothr, p->ioq,
message, len, fstrm_free_wrapper, NULL);
if (res == fstrm_res_success) {
p->pstat.count_submitted++;
p->pstat.bytes_submitted += len;
} else {
free(message);
}
p->pstat.count_generated++;
p->pstat.bytes_generated += len;
if ((i % 1000) == 0)
poll(NULL, 0, 1);
}
return NULL;
}
void
_wdns_rdata_to_ubuf(ubuf *u, const uint8_t *rdata, uint16_t rdlen,
uint16_t rrtype, uint16_t rrclass)
{
#define bytes_required(n) do { \
if (src_bytes < ((signed) (n))) \
goto err; \
} while(0)
#define bytes_consumed(n) do { \
src += n; \
src_bytes -= n; \
} while(0)
char domain_name[WDNS_PRESLEN_NAME];
const record_descr *descr;
const uint8_t *src;
size_t len;
ssize_t src_bytes;
uint8_t oclen;
wdns_res res;
if (rrtype < record_descr_len)
descr = &record_descr_array[rrtype];
if (rrtype >= record_descr_len || descr->types[0] == rdf_unknown) {
/* generic encoding */
ubuf_add_cstr(u, "\\# ");
ubuf_add_fmt(u, "%u ", rdlen);
for (unsigned i = 0; i < rdlen; i++)
ubuf_add_fmt(u, "%02x ", rdata[i]);
return;
} else if (!(descr->record_class == class_un ||
descr->record_class == rrclass))
{
return;
}
src = rdata;
src_bytes = (ssize_t) rdlen;
for (const uint8_t *t = &descr->types[0]; *t != rdf_end; t++) {
if (src_bytes == 0)
break;
switch (*t) {
case rdf_name:
case rdf_uname:
res = wdns_len_uname(src, src + src_bytes, &len);
if (res != wdns_res_success) {
src_bytes = 0;
goto err_res;
}
wdns_domain_to_str(src, len, domain_name);
ubuf_add_cstr(u, domain_name);
ubuf_add_cstr(u, " ");
bytes_consumed(len);
break;
case rdf_bytes:
len = src_bytes;
while (len > 0) {
ubuf_add_fmt(u, "%02X", *src);
src++;
len--;
}
src_bytes = 0;
break;
case rdf_bytes_b64: {
base64_encodestate b64;
char *buf;
base64_init_encodestate(&b64);
buf = alloca(2 * src_bytes + 1);
len = base64_encode_block((const char *) src, src_bytes, buf, &b64);
ubuf_append(u, (uint8_t *) buf, len);
len = base64_encode_blockend(buf, &b64);
ubuf_append(u, (uint8_t *) buf, len);
src_bytes = 0;
break;
}
case rdf_ipv6prefix:
bytes_required(1);
len = oclen = *src++;
bytes_required(1 + oclen);
while (len > 0) {
ubuf_add_fmt(u, "%02x", *src);
src++;
len--;
}
ubuf_add_cstr(u, " ");
src_bytes -= oclen + 1;
break;
case rdf_salt:
bytes_required(1);
len = oclen = *src++;
bytes_required(1 + oclen);
if (oclen == 0)
ubuf_add_cstr(u, "-");
while (len > 0) {
ubuf_add_fmt(u, "%02x", *src);
src++;
len--;
}
ubuf_add_cstr(u, " ");
src_bytes -= oclen + 1;
break;
case rdf_hash: {
char *buf;
bytes_required(1);
oclen = *src++;
bytes_required(1 + oclen);
buf = alloca(2 * oclen + 1);
len = base32_encode(buf, 2 * oclen + 1, src, oclen);
ubuf_append(u, (uint8_t *) buf, len);
ubuf_add_cstr(u, " ");
src += oclen;
src_bytes -= oclen + 1;
break;
}
case rdf_int8: {
uint8_t val;
bytes_required(1);
memcpy(&val, src, sizeof(val));
ubuf_add_fmt(u, "%u ", val);
bytes_consumed(1);
break;
}
case rdf_int16: {
uint16_t val;
bytes_required(2);
memcpy(&val, src, sizeof(val));
val = ntohs(val);
ubuf_add_fmt(u, "%hu ", val);
bytes_consumed(2);
break;
}
case rdf_int32: {
uint32_t val;
bytes_required(4);
memcpy(&val, src, sizeof(val));
val = ntohl(val);
ubuf_add_fmt(u, "%u ", val);
bytes_consumed(4);
break;
}
case rdf_ipv4: {
char pres[WDNS_PRESLEN_TYPE_A];
bytes_required(4);
inet_ntop(AF_INET, src, pres, sizeof(pres));
ubuf_add_cstr(u, pres);
ubuf_add_cstr(u, " ");
bytes_consumed(4);
break;
}
case rdf_ipv6: {
char pres[WDNS_PRESLEN_TYPE_AAAA];
bytes_required(16);
inet_ntop(AF_INET6, src, pres, sizeof(pres));
ubuf_add_cstr(u, pres);
ubuf_add_cstr(u, " ");
bytes_consumed(16);
break;
}
case rdf_string: {
bytes_required(1);
oclen = *src;
bytes_required(1 + oclen);
len = rdata_to_str_string(src, u);
bytes_consumed(len);
break;
}
case rdf_repstring:
while (src_bytes > 0) {
bytes_required(1);
oclen = *src;
bytes_required(1 + oclen);
len = rdata_to_str_string(src, u);
bytes_consumed(len);
}
break;
case rdf_rrtype: {
const char *s_rrtype;
uint16_t my_rrtype;
bytes_required(2);
memcpy(&my_rrtype, src, 2);
my_rrtype = ntohs(my_rrtype);
bytes_consumed(2);
s_rrtype = wdns_rrtype_to_str(my_rrtype);
if (s_rrtype != NULL) {
ubuf_add_cstr(u, s_rrtype);
ubuf_add_cstr(u, " ");
} else {
ubuf_add_fmt(u, "TYPE%hu ", my_rrtype);
}
break;
}
case rdf_type_bitmap: {
const char *s_rrtype;
uint16_t my_rrtype, lo;
uint8_t a, b, window_block, bitmap_len;
bytes_required(2);
while (src_bytes >= 2) {
window_block = *src;
bitmap_len = *(src + 1);
bytes_consumed(2);
bytes_required(bitmap_len);
lo = 0;
for (int i = 0; i < bitmap_len; i++) {
a = src[i];
for (int j = 1; j <= 8; j++) {
b = a & (1 << (8 - j));
if (b != 0) {
my_rrtype = (window_block << 16) | lo;
s_rrtype = wdns_rrtype_to_str(my_rrtype);
if (s_rrtype != NULL) {
ubuf_add_cstr(u, s_rrtype);
ubuf_add_cstr(u, " ");
} else {
ubuf_add_fmt(u, "TYPE%hu ", my_rrtype);
}
}
lo += 1;
}
}
bytes_consumed(bitmap_len);
}
break;
} /* end case */
}
}
/* truncate trailing " " */
if (ubuf_size(u) > 0 && ubuf_value(u, ubuf_size(u) - 1) == ' ')
ubuf_clip(u, ubuf_size(u) - 1);
return;
err:
ubuf_add_fmt(u, " ### PARSE ERROR ###");
return;
err_res:
ubuf_add_fmt(u, " ### PARSE ERROR #%u ###", res);
return;
}
void
my_fileset_reload(struct my_fileset *fs)
{
assert(fs != NULL);
struct fileset_entry *ent, **entptr;
entry_vec *new_entries;
FILE *fp;
char *fname, *line = NULL;
size_t len = 0;
ubuf *u;
if (!setfile_updated(fs))
return;
fp = fopen(fs->setfile, "r");
if (fp == NULL)
return;
u = ubuf_init(64);
new_entries = entry_vec_init(1);
while (getline(&line, &len, fp) != -1) {
ubuf_clip(u, 0);
if (line[0] != '/') { /* if not absolute path, prepend fileset file's path */
ubuf_add_cstr(u, fs->setdir);
ubuf_add(u, '/');
}
ubuf_add_cstr(u, line);
ubuf_rstrip(u, '\n');
fname = ubuf_cstr(u);
if (path_exists(fname)) {
entptr = fetch_entry(fs->entries, fname);
if (entptr == NULL) {
ent = my_calloc(1, sizeof(*ent));
ent->fname = my_strdup(fname);
if (fs->load)
ent->ptr = fs->load(fs, fname);
entry_vec_add(new_entries, ent);
} else {
ent = my_calloc(1, sizeof(*ent));
ent->fname = my_strdup(fname);
ent->ptr = (*entptr)->ptr;
(*entptr)->keep = true;
entry_vec_add(new_entries, ent);
}
}
}
free(line);
fclose(fp);
qsort(entry_vec_data(new_entries),
entry_vec_size(new_entries),
sizeof(void *),
cmp_fileset_entry);
for (size_t i = 0; i < entry_vec_size(fs->entries); i++) {
ent = entry_vec_value(fs->entries, i);
assert(ent != NULL);
if (ent->keep == false && fs->unload)
fs->unload(fs, ent->fname, ent->ptr);
free(ent->fname);
free(ent);
}
entry_vec_destroy(&fs->entries);
fs->entries = new_entries;
ubuf_destroy(&u);
}
